kuavo-humanoid-sdk 1.1.3a1252__py3-none-any.whl → 1.1.6__py3-none-any.whl

kuavo_humanoid_sdk/kuavo/core/ros_env.py

@@ -2,15 +2,10 @@
 # coding: utf-8
 
 import os
-try:
-    import rospy
-except ImportError:
-    pass
+import rospy
 import subprocess
 import atexit
 from kuavo_humanoid_sdk.common.logger import SDKLogger
-from kuavo_humanoid_sdk.common.websocket_kuavo_sdk import WebSocketKuavoSDK
-import roslibpy
 
 class KuavoROSEnv:
     _instance = None
@@ -237,226 +232,3 @@ class KuavoROSEnv:
         except Exception as e:
             SDKLogger.error(f"Error checking if node {node_name} exists: {e}")
             return False
-
-class KuavoROSEnvWebsocket:
-    _instance = None
-    _processes = []  # Store all subprocess instances
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(KuavoROSEnvWebsocket, cls).__new__(cls)
-            cls._instance._initialized = False
-            cls._instance._init_success = False  # Add flag to track successful Init() call
-            # Register cleanup handler
-            atexit.register(cls._cleanup_processes)
-        return cls._instance
-
-    def __init__(self):
-        if not self._initialized:
-            self._initialized = True
-            self.websocket = None
-
-    @classmethod
-    def _cleanup_processes(cls):
-        """Cleanup all registered processes on exit"""
-        for process in cls._processes:
-            if process.poll() is None:  # Process is still running
-                process.terminate()
-                try:
-                    process.wait(timeout=3)  # Wait for process to terminate
-                except subprocess.TimeoutExpired:
-                    process.kill()  # Force kill if not terminated
-        cls._processes.clear()
-
-    def _get_kuavo_ws_root(self) -> str:
-        # For WebSocket version, we'll use environment variable instead of ROS param
-        model_path = os.environ.get('KUAVO_MODEL_PATH')
-        if not model_path:
-            raise Exception("KUAVO_MODEL_PATH environment variable not found")
-        
-        if not os.path.exists(model_path):
-            raise Exception(f"Model path {model_path} not found")
-            
-        # ws 
-        return model_path.replace('/src/kuavo_assets/models', '')
-    
-    def Init(self) -> bool:
-        """
-        Initialize the WebSocket environment.
-        Raises:
-            Exception: If the KUAVO_MODEL_PATH environment variable is not found or the path is not valid.
-        """
-        # if generate docs, skip init.
-        if 'GEN_KUAVO_HUMANOID_SDK_DOCS' in os.environ:
-            return True
-
-        # Return directly if already initialized successfully
-        if self._init_success:
-            return True
-        
-        # Check if WebSocket server is running
-        try:
-            
-            self.websocket = WebSocketKuavoSDK()
-            if not self.websocket.client.is_connected:
-                print(f"\033[31m\nError: Can't connect to WebSocket server. Please ensure the server is running.\033[0m"
-                      "\nMaybe manually launch the app first?"
-                      "\n - for example(sim): roslaunch humanoid_controller load_kuavo_mujoco_sim.launch, "
-                      "\n - for example(real): roslaunch humanoid_controller load_kuavo_real.launch\n")
-                exit(1)
-        except Exception as e:
-            print(f"\033[31m\nError: Failed to connect to WebSocket server: {e}\033[0m")
-            exit(1)
-        
-        # Only check nodes exist when Init SDK, if not, tips user manually launch nodes.
-        deps_nodes = ['/humanoid_gait_switch_by_name']
-        for node in deps_nodes:
-            if not self.check_rosnode_exists(node):
-                print(f"\033[31m\nError: Node {node} not found. Please launch it manually.\033[0m")
-                exit(1)
-                
-        self._init_success = True  # Set flag after successful initialization
-
-        return True
-    
-    def _launch_ros_node(self, node_name, launch_cmd, log_name):
-        """Launch a ROS node with the given command and log the output.
-        
-        Args:
-            node_name (str): Name of the node to launch
-            launch_cmd (str): Full launch command including source and roslaunch
-            log_name (str): Name for the log file
-            
-        Raises:
-            Exception: If node launch fails
-        """
-        # Launch in background and check if successful
-        try:
-            os.makedirs('/var/log/kuavo_humanoid_sdk', exist_ok=True)
-            log_path = f'/var/log/kuavo_humanoid_sdk/{log_name}.log'
-        except PermissionError:
-            os.makedirs('log/kuavo_humanoid_sdk', exist_ok=True)
-            log_path = f'log/kuavo_humanoid_sdk/{log_name}.log'
-            
-        with open(log_path, 'w') as log_file:
-            process = subprocess.Popen(launch_cmd, shell=True, executable='/bin/bash', stdout=log_file, stderr=log_file)
-            self._processes.append(process)  # Add process to tracking list
-            
-        if process.returncode is not None and process.returncode != 0:
-            raise Exception(f"Failed to launch {node_name}, return code: {process.returncode}")
-
-        SDKLogger.info(f"{node_name} launched successfully")
-
-    def _get_setup_file(self, ws_root=None):
-        """Get the appropriate ROS setup file path based on shell type.
-        
-        Args:
-            ws_root (str, optional): ROS workspace root path. If None, uses ROS_WORKSPACE.
-            
-        Returns:
-            str: Path to the setup file
-            
-        Raises:
-            Exception: If setup file not found
-        """
-        is_zsh = 'zsh' in os.environ.get('SHELL', '')
-        
-        if ws_root is None:
-            ws_root = os.environ['ROS_WORKSPACE']
-            
-        setup_files = {
-            'zsh': os.path.join(ws_root, 'devel/setup.zsh'),
-            'bash': os.path.join(ws_root, 'devel/setup.bash')
-        }
-        
-        setup_file = setup_files['zsh'] if is_zsh else setup_files['bash']
-        if not os.path.exists(setup_file):
-            setup_file = setup_file.replace('devel', 'install')
-            if not os.path.exists(setup_file):
-                raise Exception(f"Setup file not found in either devel or install: {setup_file}")
-                
-        return setup_file
-
-    def launch_ik_node(self):
-        # nodes: /arms_ik_node
-        # services: /ik/two_arm_hand_pose_cmd_srv, /ik/fk_srv
-        try:
-            if not self.websocket or not self.websocket.client.is_connected:
-                raise Exception("WebSocket server is not running")
-        except Exception as e:
-            raise Exception(f"WebSocket server is not running: {e}")
-
-        # Check if IK node and services exist
-        try:
-            # Check if arms_ik_node is running using roslibpy
-            service = roslibpy.Service(self.websocket.client, '/rosnode/list', 'rosapi/Nodes')
-            response = service.call({})
-            nodes = response.get('nodes', [])
-            
-            if '/arms_ik_node' not in nodes:
-                # Launch IK node if not running
-                kuavo_ws_root = self._get_kuavo_ws_root()
-                setup_file = self._get_setup_file(kuavo_ws_root)
-                source_cmd = f"source {setup_file}"
-                
-                # Get robot version from environment variable
-                robot_version = os.environ.get('ROBOT_VERSION')
-                if robot_version is None:
-                    raise Exception("Failed to get ROBOT_VERSION from environment variables")
-                
-                # Launch IK node
-                launch_cmd = f"roslaunch motion_capture_ik ik_node.launch robot_version:={robot_version}"
-                full_cmd = f"{source_cmd} && {launch_cmd}"
-                
-                self._launch_ros_node('IK node', full_cmd, 'launch_ik')
-
-            return True
-
-        except Exception as e:
-            raise Exception(f"Failed to verify IK node and services: {e}")
-        
-
-    def launch_gait_switch_node(self)-> bool:
-        """Verify that the gait switch node is running, launch if not."""
-        try:
-            # Check if node exists using roslibpy
-            service = roslibpy.Service(self.websocket.client, '/rosnode/list', 'rosapi/Nodes')
-            response = service.call({})
-            nodes = response.get('nodes', [])
-            
-            if '/humanoid_gait_switch_by_name' not in nodes:
-                kuavo_ws_root = self._get_kuavo_ws_root()
-                setup_file = self._get_setup_file(kuavo_ws_root)
-                source_cmd = f"source {setup_file}"
-    
-                # Launch gait switch node
-                launch_cmd = "roslaunch humanoid_interface_ros humanoid_switch_gait.launch"
-                full_cmd = f"{source_cmd} && {launch_cmd}"
-                
-                self._launch_ros_node('Gait switch node', full_cmd, 'launch_gait_switch')
-
-        except Exception as e:
-            raise Exception(f"Failed to launch gait_switch node: {e}")
-        
-    @staticmethod
-    def check_rosnode_exists(node_name):
-        """Check if a ROS node is running using roslibpy.
-        
-        Args:
-            node_name (str): Name of the node to check
-            
-        Returns:
-            bool: True if node is running, False otherwise
-        """
-        websocket = WebSocketKuavoSDK()
-        try:
-            if not websocket or not websocket.client.is_connected:
-                return False
-                
-            service = roslibpy.Service(websocket.client, '/rosapi/nodes', 'rosapi/Nodes')
-            response = service.call({})
-            nodes = response.get('nodes', [])
-            return node_name in nodes
-        except Exception as e:
-            SDKLogger.error(f"Error checking if node {node_name} exists: {e}")
-            return False

kuavo_humanoid_sdk/kuavo/dexterous_hand.py

@@ -4,8 +4,7 @@ from typing import Tuple
 from kuavo_humanoid_sdk.interfaces.end_effector import EndEffector
 from kuavo_humanoid_sdk.interfaces.data_types import EndEffectorSide, EndEffectorState, KuavoDexHandTouchState
 from kuavo_humanoid_sdk.kuavo.core.dex_hand_control import DexHandControl
-from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore, KuavoRobotStateCoreWebsocket
-from kuavo_humanoid_sdk.common.global_config import GlobalConfig
+from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore
 
 class DexterousHand(EndEffector):
     def __init__(self):
@@ -13,10 +12,7 @@ class DexterousHand(EndEffector):
                        'r_thumb', 'r_thumb_aux', 'r_index', 'r_middle', 'r_ring', 'r_pinky',]
         super().__init__(joint_names=joint_names)
         self.dex_hand_control = DexHandControl()
-        if GlobalConfig.use_websocket:
-            self._rb_state = KuavoRobotStateCoreWebsocket()
-        else:
-            self._rb_state = KuavoRobotStateCore()
+        self._rb_state = KuavoRobotStateCore()
 
     def control(self, target_positions:list, target_velocities:list=None, target_torques:list=None)->bool:
         """Set the position of the hand.

kuavo_humanoid_sdk/kuavo/leju_claw.py

@@ -5,17 +5,13 @@ from typing import Tuple
 from kuavo_humanoid_sdk.interfaces.end_effector import EndEffector
 from kuavo_humanoid_sdk.interfaces.data_types import EndEffectorSide, EndEffectorState
 from kuavo_humanoid_sdk.kuavo.core.leju_claw_control import LejuClawControl
-from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore, KuavoRobotStateCoreWebsocket
-from kuavo_humanoid_sdk.common.global_config import GlobalConfig
+from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore
 
 class LejuClaw(EndEffector):
     def __init__(self):
         super().__init__(joint_names=['left_claw', 'right_claw'])
         self.leju_claw_control = LejuClawControl()
-        if GlobalConfig.use_websocket:
-            self._rb_state = KuavoRobotStateCoreWebsocket()
-        else:
-            self._rb_state = KuavoRobotStateCore()
+        self._rb_state = KuavoRobotStateCore()
 
     def control(self, target_positions: list, target_velocities:list=None, target_torques: list=None)->bool:
         """Control the claws to grip.

kuavo_humanoid_sdk/kuavo/robot.py

@@ -1,17 +1,18 @@
 #!/usr/bin/env python3
 # coding: utf-8
-from kuavo_humanoid_sdk.common.global_config import GlobalConfig
-
-from kuavo_humanoid_sdk.kuavo.core.ros_env import KuavoROSEnv, KuavoROSEnvWebsocket
-from kuavo_humanoid_sdk.interfaces.robot import RobotBase
-from kuavo_humanoid_sdk.common.logger import SDKLogger, disable_sdk_logging
-from kuavo_humanoid_sdk.interfaces.data_types import KuavoPose, KuavoIKParams
-from kuavo_humanoid_sdk.kuavo.core.core import KuavoRobotCore
-
-from typing import Tuple
-from kuavo_humanoid_sdk.kuavo.robot_info import KuavoRobotInfo
-from kuavo_humanoid_sdk.kuavo.robot_arm import KuavoRobotArm 
-from kuavo_humanoid_sdk.kuavo.robot_head import KuavoRobotHead
+from kuavo_humanoid_sdk.kuavo.core.ros_env import KuavoROSEnv
+kuavo_ros_env = KuavoROSEnv()
+if not kuavo_ros_env.Init():
+    raise RuntimeError("Failed to initialize ROS environment")
+else:
+    from typing import Tuple
+    from kuavo_humanoid_sdk.kuavo.robot_info import KuavoRobotInfo
+    from kuavo_humanoid_sdk.kuavo.robot_arm import KuavoRobotArm 
+    from kuavo_humanoid_sdk.kuavo.robot_head import KuavoRobotHead
+    from kuavo_humanoid_sdk.kuavo.core.core import KuavoRobotCore
+    from kuavo_humanoid_sdk.interfaces.robot import RobotBase
+    from kuavo_humanoid_sdk.interfaces.data_types import KuavoPose, KuavoIKParams
+    from kuavo_humanoid_sdk.common.logger import SDKLogger, disable_sdk_logging
 
 """
 Kuavo SDK - Python Interface for Kuavo Robot Control
@@ -44,30 +45,19 @@ class KuavoSDK:
        pass
 
     @staticmethod   
-    def Init(options:int=Options.Normal, log_level: str = "INFO", 
-             websocket_mode: bool = False, websocket_host='127.0.0.1', websocket_port=9090, websocket_timeout=5)-> bool:
+    def Init(options:int=Options.Normal, log_level: str = "INFO")-> bool:
         """Initialize the SDK.
+        
         Args:
             log_level (str): The logging level to use. Can be "ERROR", "WARN", "INFO", "DEBUG".
                 Defaults to "INFO".
-            websocket_mode (bool): Whether to use websocket mode for ROS communication. If True,
-                the SDK will connect to ROS through websocket instead of direct ROS connection.
-                Defaults to False.
-            websocket_host (str): The host address of the rosbridge websocket server when using
-                websocket mode. Defaults to "127.0.0.1".
-            websocket_port (int): The port number of the rosbridge websocket server when using
-                websocket mode. Defaults to 9090.
-            websocket_timeout (int): The timeout for the websocket connection. Defaults to 5.
+                
         Returns:
             bool: True if initialization is successful, False otherwise.
             
         Raises:
             RuntimeError: If the initialization fails.
         """
-        GlobalConfig.use_websocket = websocket_mode
-        GlobalConfig.websocket_host = websocket_host
-        GlobalConfig.websocket_port = websocket_port
-        GlobalConfig.websocket_timeout = websocket_timeout
         SDKLogger.setLevel(log_level.upper())
         # Initialize core components, connect ROS Topics...
         kuavo_core = KuavoRobotCore()
@@ -75,18 +65,12 @@ class KuavoSDK:
             debug = True
         else:
             debug = False   
-        # Check if IK option is enabled
-        if GlobalConfig.use_websocket:
-            if options & KuavoSDK.Options.WithIK:
-                if not KuavoROSEnvWebsocket.check_rosnode_exists('/arms_ik_node'):
-                    print("\033[31m\nError:WithIK option is enabled but ik_node is not running, please run `roslaunch motion_capture_ik ik_node.launch`\033[0m")      
-                    exit(1)
-        else:
-            if options & KuavoSDK.Options.WithIK:
-                if not KuavoROSEnv.check_rosnode_exists('/arms_ik_node'):
-                    print("\033[31m\nError:WithIK option is enabled but ik_node is not running, please run `roslaunch motion_capture_ik ik_node.launch`\033[0m")      
-                    exit(1)
 
+        # Check if IK option is enabled
+        if options & KuavoSDK.Options.WithIK:
+            if not KuavoROSEnv.check_rosnode_exists('/arms_ik_node'):
+                print("\033[31m\nError:WithIK option is enabled but ik_node is not running, please run `roslaunch motion_capture_ik ik_node.launch`\033[0m")      
+                exit(1)
 
         if not kuavo_core.initialize(debug=debug):
             SDKLogger.error("[SDK] Failed to initialize core components.")
@@ -102,16 +86,11 @@ class KuavoSDK:
 class KuavoRobot(RobotBase):
     def __init__(self):
         super().__init__(robot_type="kuavo")
-        
-        if not GlobalConfig.use_websocket:
-            kuavo_ros_env = KuavoROSEnv()
-            if not kuavo_ros_env.Init():
-                raise RuntimeError("Failed to initialize ROS environment")
-
         self._robot_info = KuavoRobotInfo()
         self._robot_arm  = KuavoRobotArm()
         self._robot_head = KuavoRobotHead()
         self._kuavo_core = KuavoRobotCore()
+
     def stance(self)->bool:
         """Put the robot into 'stance' mode.
         

kuavo_humanoid_sdk/kuavo/robot_info.py

@@ -2,8 +2,7 @@
 # coding: utf-8
 from typing import Tuple
 from kuavo_humanoid_sdk.interfaces.robot_info import RobotInfoBase
-from kuavo_humanoid_sdk.kuavo.core.ros.param import RosParameter, RosParamWebsocket, make_robot_param
-from kuavo_humanoid_sdk.common.global_config import GlobalConfig
+from kuavo_humanoid_sdk.kuavo.core.ros.param import RosParameter, make_robot_param
 
 class KuavoRobotInfo(RobotInfoBase):
     def __init__(self, robot_type: str = "kuavo"):
@@ -11,11 +10,7 @@ class KuavoRobotInfo(RobotInfoBase):
         
         # Load robot parameters from ROS parameter server
         kuavo_ros_param = make_robot_param()
-        if GlobalConfig.use_websocket:
-            self._ros_param = RosParamWebsocket()
-        else:
-            self._ros_param = RosParameter()
-            
+        self._ros_param = RosParameter()
         self._robot_version = kuavo_ros_param['robot_version']
         self._end_effector_type = kuavo_ros_param['end_effector_type']
         self._arm_joint_dof = kuavo_ros_param['arm_dof']

kuavo_humanoid_sdk/kuavo/robot_state.py

@@ -4,15 +4,11 @@ import time
 from typing import Tuple
 from kuavo_humanoid_sdk.interfaces.data_types import (
     KuavoImuData, KuavoJointData, KuavoOdometry, KuavoArmCtrlMode,EndEffectorState)
-from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore, KuavoRobotStateCoreWebsocket
-from kuavo_humanoid_sdk.common.global_config import GlobalConfig
+from kuavo_humanoid_sdk.kuavo.core.ros.state import KuavoRobotStateCore
 
 class KuavoRobotState:
     def __init__(self, robot_type: str = "kuavo"):
-        if GlobalConfig.use_websocket:
-            self._rs_core = KuavoRobotStateCoreWebsocket()
-        else:
-            self._rs_core = KuavoRobotStateCore()
+        self._rs_core = KuavoRobotStateCore()
 
     @property
     def imu_data(self) -> KuavoImuData:

kuavo_humanoid_sdk/msg/kuavo_msgs/msg/__init__.py

@@ -1,7 +1,6 @@
 from ._AprilTagDetection import *
 from ._AprilTagDetectionArray import *
 from ._Metadata import *
-from ._armHandPose import *
 from ._armPoseWithTimeStamp import *
 from ._armTargetPoses import *
 from ._dexhandCommand import *
@@ -12,24 +11,18 @@ from ._footPoseTargetTrajectories import *
 from ._gaitTimeName import *
 from ._gestureInfo import *
 from ._gestureTask import *
-from ._handPose import *
 from ._headBodyPose import *
-from ._ikSolveError import *
-from ._ikSolveParam import *
 from ._imuData import *
 from ._jointCmd import *
 from ._jointData import *
 from ._lejuClawCommand import *
 from ._lejuClawState import *
 from ._questJoySticks import *
-from ._robotArmQVVD import *
 from ._robotHandPosition import *
 from ._robotHeadMotionData import *
 from ._robotState import *
 from ._sensorsData import *
 from ._switchGaitByName import *
 from ._touchSensorStatus import *
-from ._twoArmHandPose import *
-from ._twoArmHandPoseCmd import *
 from ._yoloDetection import *
 from ._yoloOutputData import *

kuavo_humanoid_sdk/msg/kuavo_msgs/srv/__init__.py

@@ -1,10 +1,7 @@
-from ._SpeechSynthesis import *
 from ._changeArmCtrlMode import *
-from ._changeArmCtrlModeKuavo import *
 from ._changeTorsoCtrlMode import *
 from ._controlLejuClaw import *
 from ._enableHandTouchSensor import *
-from ._fkSrv import *
 from ._footPoseTargetTrajectoriesSrv import *
 from ._gestureExecute import *
 from ._gestureExecuteState import *
@@ -17,4 +14,3 @@ from ._setHwIntialState import *
 from ._setMotorEncoderRoundService import *
 from ._setTagId import *
 from ._singleStepControl import *
-from ._twoArmHandPoseCmdSrv import *

kuavo_humanoid_sdk/msg/kuavo_msgs/srv/_playmusic.py

@@ -8,15 +8,14 @@ import struct
 
 
 class playmusicRequest(genpy.Message):
-  _md5sum = "24067736323ff98005697d24ca92721f"
+  _md5sum = "b4bd61c49344d06e17224a3598f23d8e"
   _type = "kuavo_msgs/playmusicRequest"
   _has_header = False  # flag to mark the presence of a Header object
   _full_text = """string music_number
-float32 volume
-float32 speed
+int64 volume
 """
-  __slots__ = ['music_number','volume','speed']
-  _slot_types = ['string','float32','float32']
+  __slots__ = ['music_number','volume']
+  _slot_types = ['string','int64']
 
   def __init__(self, *args, **kwds):
     """
@@ -26,7 +25,7 @@ float32 speed
     changes.  You cannot mix in-order arguments and keyword arguments.
 
     The available fields are:
-       music_number,volume,speed
+       music_number,volume
 
     :param args: complete set of field values, in .msg order
     :param kwds: use keyword arguments corresponding to message field names
@@ -38,13 +37,10 @@ float32 speed
       if self.music_number is None:
         self.music_number = ''
       if self.volume is None:
-        self.volume = 0.
-      if self.speed is None:
-        self.speed = 0.
+        self.volume = 0
     else:
       self.music_number = ''
-      self.volume = 0.
-      self.speed = 0.
+      self.volume = 0
 
   def _get_types(self):
     """
@@ -64,8 +60,8 @@ float32 speed
         _x = _x.encode('utf-8')
         length = len(_x)
       buff.write(struct.Struct('<I%ss'%length).pack(length, _x))
-      _x = self
-      buff.write(_get_struct_2f().pack(_x.volume, _x.speed))
+      _x = self.volume
+      buff.write(_get_struct_q().pack(_x))
     except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
     except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
 
@@ -87,10 +83,9 @@ float32 speed
         self.music_number = str[start:end].decode('utf-8', 'rosmsg')
       else:
         self.music_number = str[start:end]
-      _x = self
       start = end
       end += 8
-      (_x.volume, _x.speed,) = _get_struct_2f().unpack(str[start:end])
+      (self.volume,) = _get_struct_q().unpack(str[start:end])
       return self
     except struct.error as e:
       raise genpy.DeserializationError(e)  # most likely buffer underfill
@@ -109,8 +104,8 @@ float32 speed
         _x = _x.encode('utf-8')
         length = len(_x)
       buff.write(struct.Struct('<I%ss'%length).pack(length, _x))
-      _x = self
-      buff.write(_get_struct_2f().pack(_x.volume, _x.speed))
+      _x = self.volume
+      buff.write(_get_struct_q().pack(_x))
     except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
     except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))
 
@@ -133,10 +128,9 @@ float32 speed
         self.music_number = str[start:end].decode('utf-8', 'rosmsg')
       else:
         self.music_number = str[start:end]
-      _x = self
       start = end
       end += 8
-      (_x.volume, _x.speed,) = _get_struct_2f().unpack(str[start:end])
+      (self.volume,) = _get_struct_q().unpack(str[start:end])
       return self
     except struct.error as e:
       raise genpy.DeserializationError(e)  # most likely buffer underfill
@@ -145,12 +139,12 @@ _struct_I = genpy.struct_I
 def _get_struct_I():
     global _struct_I
     return _struct_I
-_struct_2f = None
-def _get_struct_2f():
-    global _struct_2f
-    if _struct_2f is None:
-        _struct_2f = struct.Struct("<2f")
-    return _struct_2f
+_struct_q = None
+def _get_struct_q():
+    global _struct_q
+    if _struct_q is None:
+        _struct_q = struct.Struct("<q")
+    return _struct_q
 # This Python file uses the following encoding: utf-8
 """autogenerated by genpy from kuavo_msgs/playmusicResponse.msg. Do not edit."""
 import codecs
@@ -269,6 +263,6 @@ def _get_struct_B():
     return _struct_B
 class playmusic(object):
   _type          = 'kuavo_msgs/playmusic'
-  _md5sum = '348f2445d1e569f5dc4e72a19fb11934'
+  _md5sum = '3d99283888736c5e18f20ac685e5f8bf'
   _request_class  = playmusicRequest
   _response_class = playmusicResponse

kuavo_humanoid_sdk/msg/motion_capture_ik/msg/__init__.py

@@ -0,0 +1,9 @@
+from ._armHandPose import *
+from ._handPose import *
+from ._headBodyPose import *
+from ._ikSolveError import *
+from ._ikSolveParam import *
+from ._robotArmQVVD import *
+from ._robotHandPosition import *
+from ._twoArmHandPose import *
+from ._twoArmHandPoseCmd import *

kuavo_humanoid_sdk/msg/{kuavo_msgs → motion_capture_ik}/msg/_armHandPose.py

@@ -1,5 +1,5 @@
 # This Python file uses the following encoding: utf-8
-"""autogenerated by genpy from kuavo_msgs/armHandPose.msg. Do not edit."""
+"""autogenerated by genpy from motion_capture_ik/armHandPose.msg. Do not edit."""
 import codecs
 import sys
 python3 = True if sys.hexversion > 0x03000000 else False
@@ -9,7 +9,7 @@ import struct
 
 class armHandPose(genpy.Message):
   _md5sum = "4f28a253cb60d59c6491569369f38f4d"
-  _type = "kuavo_msgs/armHandPose"
+  _type = "motion_capture_ik/armHandPose"
   _has_header = False  # flag to mark the presence of a Header object
   _full_text = """float64[3] pos_xyz
 float64[4] quat_xyzw

kuavo_humanoid_sdk/msg/{kuavo_msgs → motion_capture_ik}/msg/_handPose.py

@@ -1,5 +1,5 @@
 # This Python file uses the following encoding: utf-8
-"""autogenerated by genpy from kuavo_msgs/handPose.msg. Do not edit."""
+"""autogenerated by genpy from motion_capture_ik/handPose.msg. Do not edit."""
 import codecs
 import sys
 python3 = True if sys.hexversion > 0x03000000 else False
@@ -9,7 +9,7 @@ import struct
 
 class handPose(genpy.Message):
   _md5sum = "1a83f0bdabe750ce0cfb45a14ec63457"
-  _type = "kuavo_msgs/handPose"
+  _type = "motion_capture_ik/handPose"
   _has_header = False  # flag to mark the presence of a Header object
   _full_text = """# pos
 float64 x