kuavo-humanoid-sdk 1.1.2a924__py3-none-any.whl → 1.1.3a1226__py3-none-any.whl

kuavo_humanoid_sdk/common/global_config.py

@@ -0,0 +1,15 @@
+
+class GlobalConfig:
+
+    _instance = None
+
+    use_websocket = False
+    websocket_host = '127.0.0.1'
+    websocket_port = 9090
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+

kuavo_humanoid_sdk/common/websocket_kuavo_sdk.py

@@ -0,0 +1,23 @@
+import roslibpy
+from kuavo_humanoid_sdk.common.global_config import GlobalConfig
+
+class WebSocketKuavoSDK:
+
+    _instance = None
+    _initialized = False
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not self._initialized:
+            self._initialized = True
+            self.client = roslibpy.Ros(host=GlobalConfig.websocket_host, port=GlobalConfig.websocket_port)
+            self.client.run(timeout=GlobalConfig.websocket_timeout)
+            
+
+    def __del__(self):
+        self.client.terminate()
+        self.instance = None

kuavo_humanoid_sdk/interfaces/data_types.py

@@ -1,6 +1,7 @@
 from typing import Tuple
 from enum import Enum
 from dataclasses import dataclass
+import numpy as np
 
 @dataclass
 class KuavoJointData:
@@ -143,3 +144,48 @@ class KuavoDexHandTouchState:
         status: int  # 传感器状态
     # 5 fingers
     data: Tuple[KuavoTouchState, KuavoTouchState, KuavoTouchState, KuavoTouchState, KuavoTouchState]
+
+@dataclass
+class AprilTagData:
+    """Represents detected AprilTag information with pose estimation.
+    
+    Attributes:
+        id (list): List of detected AprilTag IDs (integers)
+        size (list): List of tag physical sizes in meters (floats)
+        pose (list): List of PoseQuaternion objects representing tag poses
+    """
+    id: list
+    size: list
+    pose: list
+
+@dataclass
+class HomogeneousMatrix:
+    """4x4 homogeneous transformation matrix for 3D transformations.
+    
+    Represents both rotation and translation in 3D space. Can be used for
+    coordinate frame transformations and pose composition.
+    
+    Attributes:
+        matrix (np.ndarray): 4x4 numpy array of shape (4, 4) containing::
+        
+            [[R, t],
+             [0, 1]] 
+            
+        where R is 3x3 rotation matrix and t is 3x1 translation
+    """
+    matrix: np.ndarray  # Shape (4,4) homogeneous transformation matrix
+
+@dataclass
+class PoseQuaternion:
+    """3D pose representation using position and quaternion orientation.
+    
+    Provides a singularity-free orientation representation. Commonly used
+    in robotics for smooth interpolation between orientations.
+    
+    Attributes:
+        position (Tuple[float, float, float]): XYZ coordinates in meters
+        orientation (Tuple[float, float, float, float]): Unit quaternion in
+            (x, y, z, w) format following ROS convention
+    """
+    position: Tuple[float, float, float]
+    orientation: Tuple[float, float, float, float]

kuavo_humanoid_sdk/kuavo/__init__.py

@@ -1,7 +1,10 @@
 from .robot import KuavoSDK, KuavoRobot  
 from .robot_info import KuavoRobotInfo
 from .robot_state import KuavoRobotState
+from .robot_vision import KuavoRobotVision
+from .robot_tool import KuavoRobotTools
 from .robot_arm import KuavoRobotArm
 from .robot_head import KuavoRobotHead
+from .robot_audio import KuavoRobotAudio
 from .dexterous_hand import DexterousHand, TouchDexterousHand
 from .leju_claw import LejuClaw

kuavo_humanoid_sdk/kuavo/core/audio.py

@@ -0,0 +1,33 @@
+import time
+import math
+import rospy
+import threading
+import numpy as np
+from typing import Tuple
+from transitions import Machine, State
+
+from kuavo_humanoid_sdk.common.logger import SDKLogger
+from kuavo_humanoid_sdk.kuavo.core.ros.audio import Audio
+
+class KuavoRobotAudioCore:
+    def __init__(self):
+        self.robot_audio = Audio()
+
+    def play_audio(self, music_number: str, volume: float = 0.5, speed: float = 1.0) -> bool:
+        """
+        play music
+        """
+        return self.robot_audio.play_audio(music_number, volume, speed)
+
+    def stop_music(self) -> bool:
+        """
+        stop music
+        """
+        return self.robot_audio.stop_audio()
+
+    def text_to_speech(self, text: str, volume: float = 0.5) -> bool:
+        """
+        text to speech
+        """
+        return self.robot_audio.text_to_speech(text, volume)
+

kuavo_humanoid_sdk/kuavo/core/core.py

@@ -19,18 +19,19 @@ Each state has an entry callback that handles initialization when entering that
 
 import time
 import math
-import rospy
 import threading
 import numpy as np
 from typing import Tuple
 from transitions import Machine, State
 
 from kuavo_humanoid_sdk.interfaces.data_types import KuavoArmCtrlMode, KuavoIKParams, KuavoPose
-from kuavo_humanoid_sdk.kuavo.core.ros.control import KuavoRobotControl
-from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore
+from kuavo_humanoid_sdk.kuavo.core.ros.control import KuavoRobotControl, KuavoRobotControlWebsocket
+from kuavo_humanoid_sdk.kuavo.core.ros.vision import KuavoRobotVisionCore
+from kuavo_humanoid_sdk.kuavo.core.ros.tools import KuavoRobotToolsCore
+from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore, KuavoRobotStateCoreWebsocket
 from kuavo_humanoid_sdk.kuavo.core.ros.param import make_robot_param
 from kuavo_humanoid_sdk.common.logger import SDKLogger
-
+from kuavo_humanoid_sdk.common.global_config import GlobalConfig
 # Define robot states
 ROBOT_STATES = [
     State(name='stance', on_enter=['_on_enter_stance']),
@@ -65,9 +66,18 @@ class KuavoRobotCore:
                 send_event=True
             )
             # robot control
-            self._control = KuavoRobotControl()
-            self._rb_state = KuavoRobotStateCore()
+            if GlobalConfig.use_websocket:
+                self._control = KuavoRobotControlWebsocket()
+                self._rb_state = KuavoRobotStateCoreWebsocket()
+            else:
+                self._control = KuavoRobotControl()
+                self._rb_state = KuavoRobotStateCore()
+                
             self._arm_ctrl_mode = KuavoArmCtrlMode.AutoSwing
+            # robot vision
+            self._robot_vision = KuavoRobotVisionCore()
+            # robot ros tf
+            self._robot_tf_tool = KuavoRobotToolsCore()
             # register gait changed callback
             self._rb_state.register_gait_changed_callback(self._humanoid_gait_changed)
             # initialized

kuavo_humanoid_sdk/kuavo/core/ros/audio.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# coding: utf-8
+import rospy
+from std_msgs.msg import Bool
+from kuavo_humanoid_sdk.common.logger import SDKLogger
+from kuavo_humanoid_sdk.kuavo.core.core import KuavoRobotCore
+from kuavo_humanoid_sdk.msg.kuavo_msgs.srv import  playmusic, playmusicRequest
+from kuavo_humanoid_sdk.msg.kuavo_msgs.srv import  SpeechSynthesis, SpeechSynthesisRequest
+class Audio:
+    """Audio system interface for controlling audio playback functionality of Kuavo humanoid robot.
+    
+    Provides functionality to play music files.
+    """
+    
+    def __init__(self):
+        """Initialize the audio system."""
+        self._audio_stop_publisher = rospy.Publisher('stop_music', Bool, queue_size=10)
+        rospy.sleep(0.5)  # Wait for publisher initialization
+    def play_audio(self, file_name: str,volume: float = 0.5,speed: float = 1.0) -> bool:
+        """Play the specified audio file.
+        
+        Args:
+            file_name (str): Name of the audio file to play
+                
+        Returns:
+            bool: True if the play request was successfully sent, False otherwise
+        """
+        try:
+            # Wait for service availability
+            rospy.wait_for_service('play_music', timeout=2.0)
+            # Create service client
+            play_music_service = rospy.ServiceProxy('play_music', playmusic)
+            # Call service
+            request = playmusicRequest()
+            request.music_number = file_name
+            volume = min(max(volume , 0), 1.0)
+            request.volume = volume
+            request.speed = speed
+            response = play_music_service(request)
+            SDKLogger.info(f"[Robot Audio] Requested to play audio file: {file_name}")
+            return True
+        except rospy.ROSException as e:
+            SDKLogger.error(f"[Robot Audio] Audio playback service unavailable: {str(e)}")
+            return False
+        except Exception as e:
+            SDKLogger.error(f"[Robot Audio] Failed to play audio file: {str(e)}")
+            return False
+    
+    def stop_audio(self):
+        """Stop the currently playing audio."""
+        try:
+            msg = Bool()
+            msg.data = True
+            self._audio_stop_publisher.publish(msg)
+            SDKLogger.info("[Robot Audio] Requested to stop audio playback")
+            return True 
+        except Exception as e:
+            SDKLogger.error(f"[Robot Audio] Failed to stop audio playback: {str(e)}")
+            return False    
+    
+    def text_to_speech(self, text: str,volume: float = 0.5) -> bool:
+        """Synthesize and play the specified text.
+        
+        Args:
+            text (str): Text to be played
+                
+        Returns:
+            bool: True if the play request was successfully sent, False otherwise
+        """
+        try:
+            # Wait for service availability
+            rospy.wait_for_service('play_music', timeout=2.0)
+            # Create service client
+            play_music_service = rospy.ServiceProxy('speech_synthesis', SpeechSynthesis)
+            # Call service
+            request = SpeechSynthesisRequest()
+            request.data = text
+            request.volume = volume
+            response = play_music_service(request)
+            SDKLogger.info(f"[Robot Audio] Requested to play audio text: {text}")
+            return True
+        except rospy.ROSException as e:
+            SDKLogger.error(f"[Robot Audio] Audio playback service unavailable: {str(e)}")
+            return False
+        except Exception as e:
+            SDKLogger.error(f"[Robot Audio] Failed to play audio text: {str(e)}")
+            return False