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

kuavo_humanoid_sdk/kuavo/core/ros/control.py

@@ -1,19 +1,28 @@
+from kuavo_humanoid_sdk.common.global_config import GlobalConfig
 import os
-import rospy
+import roslibpy
 import numpy as np
 from typing import Tuple
 from kuavo_humanoid_sdk.common.logger import SDKLogger
+from kuavo_humanoid_sdk.common.websocket_kuavo_sdk import WebSocketKuavoSDK
 from kuavo_humanoid_sdk.interfaces.data_types import KuavoArmCtrlMode, KuavoIKParams, KuavoPose
 from kuavo_humanoid_sdk.kuavo.core.ros.sat_utils import RotatingRectangle
 from kuavo_humanoid_sdk.kuavo.core.ros.param import EndEffectorType
-from geometry_msgs.msg import Twist
-from sensor_msgs.msg import JointState, Joy
-from kuavo_humanoid_sdk.msg.kuavo_msgs.msg import (gestureTask,robotHandPosition, robotHeadMotionData, armTargetPoses, switchGaitByName,
-                            footPose, footPoseTargetTrajectories, dexhandCommand)                         
-from kuavo_humanoid_sdk.msg.kuavo_msgs.srv import (gestureExecute, gestureExecuteRequest,gestureList, gestureListRequest,
+
+try:
+    import rospy
+    from geometry_msgs.msg import Twist
+    from sensor_msgs.msg import JointState, Joy
+    from kuavo_humanoid_sdk.msg.kuavo_msgs.msg import (gestureTask,robotHandPosition, robotHeadMotionData, armTargetPoses, switchGaitByName,
+                                footPose, footPoseTargetTrajectories, dexhandCommand)
+    from kuavo_humanoid_sdk.msg.kuavo_msgs.srv import (gestureExecute, gestureExecuteRequest,gestureList, gestureListRequest,
                             controlLejuClaw, controlLejuClawRequest, changeArmCtrlMode, changeArmCtrlModeRequest)
-from kuavo_humanoid_sdk.msg.motion_capture_ik.msg import twoArmHandPoseCmd, ikSolveParam
-from kuavo_humanoid_sdk.msg.motion_capture_ik.srv import twoArmHandPoseCmdSrv, fkSrv
+    from kuavo_humanoid_sdk.msg.kuavo_msgs.msg import twoArmHandPoseCmd, ikSolveParam
+    from kuavo_humanoid_sdk.msg.kuavo_msgs.srv import twoArmHandPoseCmdSrv, fkSrv
+except:
+    pass
+
+
 
 class ControlEndEffector:
     def __init__(self, eef_type: str = EndEffectorType.QIANGNAO):
@@ -175,7 +184,205 @@ class ControlEndEffector:
             SDKLogger.error(f"Service `control_robot_leju_claw` call failed: {e}")
         return False
 
-""" Control Robot Arm"""
+class ControlEndEffectorWebsocket:
+    def __init__(self, eef_type: str = EndEffectorType.QIANGNAO):
+        self._eef_type = eef_type
+        self._pubs = []
+        websocket = WebSocketKuavoSDK()
+        if self._eef_type == EndEffectorType.QIANGNAO:
+            self._pub_ctrl_robot_hand = roslibpy.Topic(websocket.client, '/control_robot_hand_position', 'kuavo_msgs/robotHandPosition')                
+            # publisher, name, require
+            self._pubs.append((self._pub_ctrl_robot_hand, True))
+        elif self._eef_type == EndEffectorType.QIANGNAO_TOUCH:
+            self._pub_ctrl_robot_hand = roslibpy.Topic(websocket.client, '/control_robot_hand_position', 'kuavo_msgs/robotHandPosition')                
+            self._pub_dexhand_command = roslibpy.Topic(websocket.client, '/dexhand/command', 'kuavo_msgs/dexhandCommand')
+            self._pub_dexhand_right_command = roslibpy.Topic(websocket.client, '/dexhand/right/command', 'kuavo_msgs/dexhandCommand')
+            self._pub_dexhand_left_command = roslibpy.Topic(websocket.client, '/dexhand/left/command', 'kuavo_msgs/dexhandCommand')
+            # publisher, name, require
+            self._pubs.append((self._pub_dexhand_command, True))
+            self._pubs.append((self._pub_dexhand_right_command, True))
+            self._pubs.append((self._pub_dexhand_left_command, True))
+
+    def connect(self, timeout:float=1.0)-> bool:
+        return True
+
+    def pub_control_robot_dexhand(self, left_position:list, right_position:list)->bool:
+        if not self._eef_type.startswith(EndEffectorType.QIANGNAO): # qiangnao, qiangnao_touch
+            SDKLogger.warning(f"{self._eef_type} not support control dexhand")
+            return False
+        try:
+            hand_pose_msg = {
+                "left_hand_position": bytes(left_position),
+                "right_hand_position": bytes(right_position)
+            }
+            self._pub_ctrl_robot_hand.publish(roslibpy.Message(hand_pose_msg))
+            SDKLogger.debug(f"publish robot dexhand: {left_position}, {right_position}")
+            return True
+        except Exception as e:
+            SDKLogger.error(f"publish robot dexhand: {e}")
+            return False
+    
+    def pub_dexhand_command(self, data:list, ctrl_mode, hand_side)->bool:
+        """
+            ctrl_mode: 0 --> POSITION, 1 --> VELOCITY
+            hand_side: 0 --> left, 1 --> right, 2-->dual
+        """
+        if not self._eef_type == EndEffectorType.QIANGNAO_TOUCH:
+            SDKLogger.warning(f"{self._eef_type} not support pub_left_dexhand_command")
+            return False
+        try:
+            if hand_side != 2 and len(data) != 6:
+                SDKLogger.warning("Data length should be 6")
+                return False
+            if hand_side == 2 and len(data) != 12:
+                SDKLogger.warning("Data length should be 12")
+                return False
+            if ctrl_mode not in [dexhandCommand.POSITION_CONTROL, dexhandCommand.VELOCITY_CONTROL]:
+                SDKLogger.error(f"Invalid mode for pub_left_dexhand_command: {ctrl_mode}")
+                return False
+            
+            msg = {
+                "data": [int(d) for d in data],  # Convert data to integers
+                "control_mode": ctrl_mode
+            }
+            if hand_side == 0:
+                self._pub_dexhand_left_command.publish(roslibpy.Message(msg))
+            elif hand_side == 1:
+                self._pub_dexhand_right_command.publish(roslibpy.Message(msg))
+            else:
+                self._pub_dexhand_command.publish(roslibpy.Message(msg))
+            return True
+        except Exception as e:
+            SDKLogger.error(f"Failed to publish left dexhand command: {e}")
+            return False
+        
+    def srv_execute_gesture(self, gestures:list)->bool:
+        if not self._eef_type.startswith(EndEffectorType.QIANGNAO): # qiangnao, qiangnao_touch
+            SDKLogger.warning(f"{self._eef_type} not support control dexhand")
+            return False
+        try:
+            websocket = WebSocketKuavoSDK()
+            service = roslibpy.Service(websocket.client, 'gesture/execute', 'kuavo_msgs/gestureExecute')
+            request = {
+                "gestures": [
+                    {
+                        "gesture_name": gs["gesture_name"],
+                        "hand_side": gs["hand_side"]
+                    } for gs in gestures
+                ]
+            }
+            response = service.call(request)
+            if not response.get('result', False):
+                SDKLogger.error(f"Failed to execute gesture '{gestures}': {response.get('message', '')}")
+            return response.get('result', False)
+        except Exception as e:
+            SDKLogger.error(f"Service call failed: {e}")
+            return False
+
+    def srv_get_gesture_names(self)->list:
+        if not self._eef_type.startswith(EndEffectorType.QIANGNAO): # qiangnao, qiangnao_touch
+            SDKLogger.warning(f"{self._eef_type} not support control dexhand")
+            return []
+        try:
+            websocket = WebSocketKuavoSDK()
+            service = roslibpy.Service(websocket.client, 'gesture/list', 'kuavo_msgs/gestureList')
+            request = {}
+            response = service.call(request)
+            gestures = []
+            for gesture_info in response.get('gesture_infos', []):
+                gestures.append(gesture_info['gesture_name'])
+                for alias in gesture_info.get('alias', []):
+                    gestures.append(alias)
+            return list(set(gestures))
+        except Exception as e:
+            SDKLogger.error(f"Service call failed: {e}")
+            return []
+
+    def srv_control_leju_claw(self, postions:list, velocities:list, torques:list) ->bool:
+        if self._eef_type != 'lejuclaw':
+            SDKLogger.warning(f"{self._eef_type} not support control lejuclaw.")
+            return False
+        try:
+            websocket = WebSocketKuavoSDK()
+            service = roslibpy.Service(websocket.client, 'control_robot_leju_claw', 'kuavo_msgs/controlLejuClaw')
+            request = {
+                "data": {
+                    "position": postions,
+                    "velocity": velocities,
+                    "effort": torques
+                }
+            }
+            response = service.call(request)
+            if not response.get('result', False):
+                SDKLogger.error(f"Failed to control leju claw: {response.get('message', '')}")
+            return response.get('result', False)
+        except Exception as e:
+            SDKLogger.error(f"Service `control_robot_leju_claw` call failed: {e}")
+            return False
+
+class ControlRobotArmWebsocket:
+    def __init__(self):
+        websocket = WebSocketKuavoSDK()
+        self._pub_ctrl_arm_traj = roslibpy.Topic(websocket.client, '/kuavo_arm_traj', 'sensor_msgs/JointState')
+        self._pub_ctrl_arm_traj.advertise()
+        self._pub_ctrl_arm_target_poses = roslibpy.Topic(websocket.client, '/kuavo_arm_target_poses', 'kuavo_msgs/armTargetPoses')
+        self._pub_ctrl_arm_target_poses.advertise()
+    def connect(self, timeout:float=1.0)-> bool:
+        return True
+
+    def pub_control_robot_arm_traj(self, joint_q: list)->bool:
+        try:
+            msg = {
+                "name": ["arm_joint_" + str(i) for i in range(0, 14)],
+                "position": [float(180.0 / np.pi * q) for q in joint_q]  # convert to degree
+            }
+            self._pub_ctrl_arm_traj.publish(roslibpy.Message(msg))
+            return True
+        except Exception as e:
+            SDKLogger.error(f"publish robot arm traj: {e}")
+        return False
+        
+    def pub_arm_target_poses(self, times:list, joint_q:list):
+        try:
+            msg_values = []
+            for i in range(len(joint_q)):
+                degs = [float(q) for q in joint_q[i]]
+                msg_values.extend(degs)
+            msg = {
+                "times": [float(q) for q in times],
+                "values": msg_values
+            }
+            self._pub_ctrl_arm_target_poses.publish(roslibpy.Message(msg))
+            return True
+        except Exception as e:
+            SDKLogger.error(f"publish arm target poses: {e}")
+            
+        return False
+
+    def srv_change_arm_ctrl_mode(self, mode: KuavoArmCtrlMode)->bool:
+        try:
+            websocket = WebSocketKuavoSDK()
+            service = roslibpy.Service(websocket.client, '/arm_traj_change_mode', 'kuavo_msgs/changeArmCtrlMode')
+            request = {
+                "control_mode": mode.value
+            }
+            response = service.call(request)
+            return response.get('result', False)
+        except Exception as e:
+            SDKLogger.error(f"Service call failed: {e}")
+        return False
+    
+    def srv_get_arm_ctrl_mode(self)-> KuavoArmCtrlMode:
+        try:
+            websocket = WebSocketKuavoSDK()
+            service = roslibpy.Service(websocket.client, '/humanoid_get_arm_ctrl_mode', 'kuavo_msgs/changeArmCtrlMode')
+            request = {}
+            response = service.call(request)
+            return KuavoArmCtrlMode(response.get('control_mode', 0))
+        except Exception as e:
+            SDKLogger.error(f"Service call failed: {e}")
+        return None
+
 class ControlRobotArm:
     def __init__(self):
         self._pub_ctrl_arm_traj = rospy.Publisher('/kuavo_arm_traj', JointState, queue_size=10)
@@ -277,6 +484,26 @@ class ControlRobotHead:
             SDKLogger.error(f"[Error] publish robot head: {e}")
             return False
 
+""" Control Robot Head """
+class ControlRobotHeadWebsocket:
+    def __init__(self):
+        websocket = WebSocketKuavoSDK()
+        self._pub_ctrl_robot_head = roslibpy.Topic(websocket.client, '/robot_head_motion_data', 'kuavo_msgs/robotHeadMotionData')
+
+    def connect(self, timeout:float=1.0)->bool:
+        return True
+
+    def pub_control_robot_head(self, yaw:float, pitch:float)->bool:
+        try:
+            msg = {
+                "joint_data": [float(yaw), float(pitch)]
+            }
+            self._pub_ctrl_robot_head.publish(roslibpy.Message(msg))
+            return True
+        except Exception as e:
+            SDKLogger.error(f"[Error] publish robot head: {e}")
+            return False
+
 """ Control Robot Motion """
 
 # JoyButton constants
@@ -299,6 +526,7 @@ AXIS_RIGHT_RT = 5  # 1 -> (-1)
 AXIS_LEFT_RIGHT_TRIGGER = 6
 AXIS_FORWARD_BACK_TRIGGER = 7
 
+
 class ControlRobotMotion:
     def __init__(self):
         self._pub_cmd_vel = rospy.Publisher('/cmd_vel', Twist, queue_size=10)
@@ -339,7 +567,7 @@ class ControlRobotMotion:
             SDKLogger.error(f"[Error] publish cmd vel: {e}")
             return False
 
-    def pub_cmd_pose(self, twist:Twist)->bool:
+    def pub_cmd_pose(self, twist)->bool:
         try:
             self._pub_cmd_pose.publish(twist)
             return True
@@ -347,7 +575,7 @@ class ControlRobotMotion:
             SDKLogger.error(f"[Error] publish cmd pose: {e}")
             return False    
     
-    def _create_joy_msg(self)->Joy:
+    def _create_joy_msg(self):
         joy_msg = Joy()
         joy_msg.axes = [0.0] * 8  # Initialize 8 axes
         joy_msg.buttons = [0] * 16  # Initialize 16 buttons
@@ -393,17 +621,114 @@ class ControlRobotMotion:
         # return self._pub_joy_command(BUTTON_B, "trot")
         return self._pub_switch_gait_by_name("walk")
     
-    def pub_step_ctrl(self, msg:footPoseTargetTrajectories)->bool:
+    def pub_step_ctrl(self, msg)->bool:
         try:
             self._pub_step_ctrl.publish(msg)
             return True
         except Exception as e:
             SDKLogger.error(f"[Error] publish step ctrl: {e}")
             return False
-        
-"""
-Kuavo Robot Arm IK&FK
-"""
+   
+
+class ControlRobotMotionWebsocket:
+    def __init__(self):
+        websocket = WebSocketKuavoSDK()
+        self._pub_cmd_vel = roslibpy.Topic(websocket.client, '/cmd_vel', 'geometry_msgs/Twist')
+        self._pub_cmd_pose = roslibpy.Topic(websocket.client, '/cmd_pose', 'geometry_msgs/Twist')
+        self._pub_joy = roslibpy.Topic(websocket.client, '/joy', 'sensor_msgs/Joy')
+        self._pub_switch_gait = roslibpy.Topic(websocket.client, '/humanoid_switch_gait_by_name', 'kuavo_msgs/switchGaitByName')
+        self._pub_step_ctrl = roslibpy.Topic(websocket.client, '/humanoid_mpc_foot_pose_target_trajectories', 'kuavo_msgs/footPoseTargetTrajectories')
+
+    def connect(self, timeout:float=2.0)-> bool:
+        return True
+
+    def pub_cmd_vel(self, linear_x: float, linear_y: float, angular_z: float)->bool:
+        try:
+            msg = {
+                "linear": {"x": float(linear_x), "y": float(linear_y), "z": 0.0},
+                "angular": {"x": 0.0, "y": 0.0, "z": float(angular_z)}
+            }
+            self._pub_cmd_vel.publish(roslibpy.Message(msg))
+            return True
+        except Exception as e:
+            SDKLogger.error(f"[Error] publish cmd vel: {e}")
+            return False
+
+    def pub_cmd_pose(self, height:float, pitch:float)->bool:
+        # com_msg = Twist()
+        # com_msg.linear.z = height
+        # com_msg.angular.y = pitch
+        try:
+            msg = {
+                "linear": {"x": 0, "y": 0, "z": float(height)},
+                "angular": {"x": 0, "y": float(pitch), "z": 0}
+            }
+            self._pub_cmd_pose.publish(roslibpy.Message(msg))
+            return True
+        except Exception as e:
+            SDKLogger.error(f"[Error] publish cmd pose: {e}")
+            return False
+
+    def _pub_joy_command(self, button_index: int, command_name: str) -> bool:
+        try:
+            msg = {
+                "axes": [0.0] * 8,
+                "buttons": [0] * 16
+            }
+            msg["buttons"][button_index] = 1
+            self._pub_joy.publish(roslibpy.Message(msg))
+            SDKLogger.debug(f"Published {command_name} command")
+            return True
+        except Exception as e:
+            SDKLogger.error(f"[Error] publish {command_name}: {e}")
+            return False
+
+    def _pub_switch_gait_by_name(self, gait_name: str) -> bool:
+        try:
+            msg = {
+                "gait_name": gait_name
+            }
+            self._pub_switch_gait.publish(roslibpy.Message(msg))
+            return True
+        except Exception as e:
+            SDKLogger.error(f"[Error] publish switch gait {gait_name}: {e}")
+            return False
+
+    def pub_walk_command(self) -> bool:
+        return self._pub_switch_gait_by_name("walk")
+
+    def pub_stance_command(self) -> bool:
+        try:
+            self.pub_cmd_vel(linear_x=0.0, linear_y=0.0, angular_z=0.0)
+            return self._pub_switch_gait_by_name("stance")
+        except Exception as e:
+            SDKLogger.error(f"[Error] publish stance: {e}")
+            return False
+
+    def pub_trot_command(self) -> bool:
+        return self._pub_switch_gait_by_name("walk")
+    
+    def pub_step_ctrl(self, msg)->bool:
+        try:
+            websocket_msg = {
+                "timeTrajectory": msg.timeTrajectory,
+                "footIndexTrajectory": msg.footIndexTrajectory,
+                "footPoseTrajectory": [
+                    {
+                        "footPose": list(fp.footPose),
+                        "torsoPose": list(fp.torsoPose)
+                    } for fp in msg.footPoseTrajectory
+                ]
+            }
+            SDKLogger.debug(f"websocket_msg {websocket_msg}")
+            self._pub_step_ctrl.publish(roslibpy.Message(websocket_msg))
+            SDKLogger.debug(f"after publish")
+            return True
+        except Exception as e:
+            SDKLogger.error(f"[Error] publish step ctrl: {e}")
+            return False
+
+
 class KuavoRobotArmIKFK:
     def __init__(self):
         pass
@@ -448,7 +773,7 @@ class KuavoRobotArmIKFK:
     def arm_fk(self, q: list) -> Tuple[KuavoPose, KuavoPose]:
         return self._srv_arm_fk(q)
     
-    def _srv_arm_ik(self, eef_pose_msg:twoArmHandPoseCmd)->list:
+    def _srv_arm_ik(self, eef_pose_msg)->list:
         try:
             rospy.wait_for_service('/ik/two_arm_hand_pose_cmd_srv',timeout=1.0)
             ik_srv = rospy.ServiceProxy('/ik/two_arm_hand_pose_cmd_srv', twoArmHandPoseCmdSrv)
@@ -480,6 +805,88 @@ class KuavoRobotArmIKFK:
         except Exception as e:
             print(f"Failed to call ik/fk_srv: {e}")
             return None
+
+class KuavoRobotArmIKFKWebsocket:
+    def __init__(self):
+        pass
+
+    def arm_ik(self, 
+               left_pose: KuavoPose, 
+               right_pose: KuavoPose, 
+               left_elbow_pos_xyz: list = [0.0, 0.0, 0.0],
+               right_elbow_pos_xyz: list = [0.0, 0.0, 0.0],
+               arm_q0: list = None,
+               params: KuavoIKParams=None) -> list:
+        try:
+            websocket = WebSocketKuavoSDK()
+            service = roslibpy.Service(websocket.client, '/ik/two_arm_hand_pose_cmd_srv', 'motion_capture_ik/twoArmHandPoseCmdSrv')
+            
+            request = {
+                "twoArmHandPoseCmdRequest": {
+                    "hand_poses": {
+                        "header": {
+                            "seq": 0,
+                            "stamp": {
+                                "secs": 0,
+                                "nsecs": 0
+                            },
+                            "frame_id": ""
+                        },
+                        "left_pose": {
+                            "pos_xyz": left_pose.position,
+                            "quat_xyzw": left_pose.orientation,
+                            "elbow_pos_xyz": left_elbow_pos_xyz,
+                        },
+                        "right_pose": {
+                            "pos_xyz": right_pose.position,
+                            "quat_xyzw": right_pose.orientation,
+                            "elbow_pos_xyz": right_elbow_pos_xyz,
+                        }
+                    },
+                    "use_custom_ik_param": params is not None,
+                    "joint_angles_as_q0": arm_q0 is not None,
+                    "ik_param": {
+                        "major_optimality_tol": params.major_optimality_tol if params else 0.0,
+                        "major_feasibility_tol": params.major_feasibility_tol if params else 0.0,
+                        "minor_feasibility_tol": params.minor_feasibility_tol if params else 0.0,
+                        "major_iterations_limit": params.major_iterations_limit if params else 0,
+                        "oritation_constraint_tol": params.oritation_constraint_tol if params else 0.0,
+                        "pos_constraint_tol": params.pos_constraint_tol if params else 0.0,
+                        "pos_cost_weight": params.pos_cost_weight if params else 0.0
+                    }
+                }
+            }
+            
+            response = service.call(request)
+            if response.get('success', False):
+                return response['hand_poses']['left_pose']['joint_angles'] + response['hand_poses']['right_pose']['joint_angles']
+            return None
+        except Exception as e:
+            SDKLogger.error(f"Service call failed: {e}")
+            return None
+
+    def arm_fk(self, q: list) -> Tuple[KuavoPose, KuavoPose]:
+        try:
+            websocket = WebSocketKuavoSDK()
+            service = roslibpy.Service(websocket.client, '/ik/fk_srv', 'motion_capture_ik/fkSrv')
+            request = {"q": q}
+            response = service.call(request)
+            
+            if response.get('success', False):
+                left_pose = KuavoPose(
+                    position=response['hand_poses']['left_pose']['pos_xyz'],
+                    orientation=response['hand_poses']['left_pose']['quat_xyzw']
+                )
+                right_pose = KuavoPose(
+                    position=response['hand_poses']['right_pose']['pos_xyz'],
+                    orientation=response['hand_poses']['right_pose']['quat_xyzw']
+                )
+                return left_pose, right_pose
+            return None
+        except Exception as e:
+            SDKLogger.error(f"Service call failed: {e}")
+            return None
+
 """
     Kuavo Robot Control 
 """
@@ -698,6 +1105,226 @@ class KuavoRobotControl:
         msg = get_multiple_steps_msg(body_poses, dt, is_left_first_default, collision_check)
         return self.kuavo_motion_control.pub_step_ctrl(msg)
 """ ------------------------------------------------------------------------------"""    
+
+
+class KuavoRobotControlWebsocket:
+    _instance = None
+    
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if not hasattr(self, '_initialized'):
+            try:
+                self._initialized = True
+                self.kuavo_eef_control = None
+                self.kuavo_head_control = ControlRobotHeadWebsocket()
+                self.kuavo_arm_control = ControlRobotArmWebsocket()
+                self.kuavo_motion_control = ControlRobotMotionWebsocket()
+                self.kuavo_arm_ik_fk = KuavoRobotArmIKFKWebsocket()
+            except Exception as e:
+                SDKLogger.error(f"Failed to initialize KuavoRobotControlWebsocket: {e}")
+                raise
+
+    def initialize(self, eef_type:str=None, debug:bool=False, timeout:float=1.0)-> Tuple[bool, str]:
+        try:
+            # init eef control
+            if eef_type is None:
+                self.kuavo_eef_control = None
+            else:
+                self.kuavo_eef_control = ControlEndEffectorWebsocket(eef_type=eef_type)
+            
+            connect_success = True
+            err_msg = ''
+            if not self.kuavo_arm_control.connect(timeout):
+                connect_success = False
+                err_msg = "Failed to connect to arm control topics, \n"
+            if not self.kuavo_head_control.connect(timeout):
+                connect_success = False
+                err_msg += "Failed to connect to head control topics, \n"
+            if not self.kuavo_motion_control.connect(timeout):
+                err_msg += "Failed to connect to motion control topics, \n"
+                connect_success = False
+
+            if self.kuavo_eef_control is not None and not self.kuavo_eef_control.connect(timeout):
+                connect_success = False
+                err_msg += "Failed to connect to end effector control topics."
+
+            if connect_success:
+                err_msg = 'success'
+            return connect_success, err_msg
+        except Exception as e:
+            SDKLogger.error(f"Failed to initialize KuavoRobotControlWebsocket: {e}")
+            return False, str(e)
+    
+    """ End Effector Control"""
+    def control_robot_dexhand(self, left_position:list, right_position:list)->bool:
+        """
+            Control robot dexhand
+            Args:
+                left_position: list of 6 floats between 0 and 100
+                right_position: list of 6 floats between 0 and 100
+        """
+        if self.kuavo_eef_control is None:
+            SDKLogger.error("End effector control is not initialized.")
+            return False
+        
+        if len(left_position) != 6 or len(right_position) != 6:
+            raise ValueError("Position lists must have a length of 6.")
+        
+        for position in left_position + right_position:
+            if position < 0.0 or position > 100.0:
+                raise ValueError("All position values must be in the range [0.0, 100.0].")    
+        
+        SDKLogger.debug(f"Control robot dexhand: {left_position}, {right_position}")
+        return self.kuavo_eef_control.pub_control_robot_dexhand(left_position, right_position)
+
+    def robot_dexhand_command(self, data, ctrl_mode, hand_side):
+        """
+            Publish dexhand command
+            Args:
+                - data: list of 6 floats between 0 and 100
+                - ctrl_mode: int between 0(position), 1(velocity)
+                - hand_side: int between 0(left), 1(right), 2(dual)
+        """
+        if self.kuavo_eef_control is None:
+            SDKLogger.error("End effector control is not initialized.")
+            return False
+        return self.kuavo_eef_control.pub_dexhand_command(data, ctrl_mode, hand_side)
+
+    def execute_gesture(self, gestures:list)->bool:
+        """
+            Execute gestures
+            Arguments:
+                - gestures: list of dicts with keys 'gesture_name' and 'hand_side'
+                 e.g. [{'gesture_name': 'fist', 'hand_side': 0},]
+        """
+        if self.kuavo_eef_control is None:
+            SDKLogger.warn("End effectors control is not initialized.")
+            return False
+        return self.kuavo_eef_control.srv_execute_gesture(gestures)
+
+    def get_gesture_names(self)->list:
+        """
+            Get the names of all gestures.
+        """
+        if self.kuavo_eef_control is None:
+            SDKLogger.warn("End effectors control is not initialized.")
+            return []
+        return self.kuavo_eef_control.srv_get_gesture_names()
+
+    def control_leju_claw(self, postions:list, velocities:list=[90, 90], torques:list=[1.0, 1.0]) ->bool:
+        """
+            Control leju claw
+            Arguments:
+                - postions: list of positions for left and right claw
+                - velocities: list of velocities for left and right claw
+                - torques: list of torques for left and right claw
+        """
+        if self.kuavo_eef_control is None:
+            SDKLogger.warn("End effectors control is not initialized.")
+            return False
+        SDKLogger.debug(f"Control leju claw: {postions}, {velocities}, {torques}")
+        if len(postions) != 2 or len(velocities) != 2 or len(torques) != 2:
+                raise ValueError("Position, velocity, and torque lists must have a length of 2.")
+        return self.kuavo_eef_control.srv_control_leju_claw(postions, velocities, torques)
+
+    def control_robot_head(self, yaw:float, pitch:float)->bool:
+        """
+            Control robot head
+            Arguments:
+                - yaw: yaw angle, radian
+                - pitch: pitch angle, radian
+        """
+        SDKLogger.debug(f"Control robot head: {yaw}, {pitch}")
+        return self.kuavo_head_control.pub_control_robot_head(yaw, pitch)
+    
+    def control_robot_arm_traj(self, joint_data:list)->bool:
+        """
+            Control robot arm trajectory
+            Arguments:
+                - joint_data: list of joint data (degrees)
+        """
+        return self.kuavo_arm_control.pub_control_robot_arm_traj(joint_data)
+    
+    def control_robot_arm_target_poses(self, times:list, joint_q:list)->bool:
+        """
+            Control robot arm target poses
+            Arguments:
+                - times: list of times (seconds)
+                - joint_q: list of joint data (degrees)
+        """
+        if len(times) != len(joint_q):
+            raise ValueError("Times and joint_q must have the same length.")
+        elif len(times) == 0:
+            raise ValueError("Times and joint_q must not be empty.")
+        
+        return self.kuavo_arm_control.pub_arm_target_poses(times=times, joint_q=joint_q)
+    
+    def change_robot_arm_ctrl_mode(self, mode:KuavoArmCtrlMode)->bool:
+        """
+            Change robot arm control mode
+            Arguments:
+                - mode: arm control mode
+        """
+        SDKLogger.debug(f"[WebSocket] Change robot arm control mode: {mode}")
+        return self.kuavo_arm_control.srv_change_arm_ctrl_mode(mode)
+    
+    def get_robot_arm_ctrl_mode(self)->int:
+        """
+            Get robot arm control mode
+        """
+        return self.kuavo_arm_control.srv_get_arm_ctrl_mode()
+    
+    def arm_ik(self, left_pose: KuavoPose, right_pose: KuavoPose, 
+               left_elbow_pos_xyz: list = [0.0, 0.0, 0.0],  
+               right_elbow_pos_xyz: list = [0.0, 0.0, 0.0],
+               arm_q0: list = None, params: KuavoIKParams=None) -> list:
+        return self.kuavo_arm_ik_fk.arm_ik(left_pose, right_pose, left_elbow_pos_xyz, right_elbow_pos_xyz, arm_q0, params)
+
+    def arm_fk(self, q: list) -> Tuple[KuavoPose, KuavoPose]:
+        return self.kuavo_arm_ik_fk.arm_fk(q)
+    
+    """ Motion """
+    def robot_stance(self)->bool:
+        return self.kuavo_motion_control.pub_stance_command()
+
+    def robot_trot(self)->bool:
+        return self.kuavo_motion_control.pub_trot_command()
+    
+    def robot_walk(self, linear_x:float, linear_y:float, angular_z:float)->bool:
+        return self.kuavo_motion_control.pub_cmd_vel(linear_x, linear_y, angular_z)
+    
+    def control_torso_height(self, height:float, pitch:float=0.0)->bool:
+        return self.kuavo_motion_control.pub_cmd_pose(height, pitch)
+
+    def step_control(self, body_poses:list, dt:float, is_left_first_default:bool=True, collision_check:bool=True)->bool:
+        """
+            Step control
+            Arguments:
+                - body_poses: list of body poses (x, y, z, yaw), meters and degrees
+                - dt: time step (seconds)
+                - is_left_first_default: whether to start with left foot
+                - collision_check: whether to check for collisions
+        """
+        if len(body_poses) == 0:
+            raise ValueError("Body poses must not be empty.")
+        if dt <= 0.0:
+            raise ValueError("Time step must be greater than 0.0.")
+        for bp in body_poses:
+            if len(bp) != 4:
+                raise ValueError("Body pose must have 4 elements: [x, y, z, yaw]")
+        
+        msg = get_multiple_steps_msg(body_poses, dt, is_left_first_default, collision_check)
+        return self.kuavo_motion_control.pub_step_ctrl(msg)
+
+# if GlobalConfig.use_websocket:
+#     kuavo_robot_control = KuavoRobotControlWebsocket()
+# else:
+#     kuavo_robot_control = KuavoRobotControl()
+
 def euler_to_rotation_matrix(yaw, pitch, roll):
     # 计算各轴的旋转矩阵
     R_yaw = np.array([[np.cos(yaw), -np.sin(yaw), 0],
@@ -810,5 +1437,4 @@ def get_multiple_steps_msg(body_poses:list, dt:float, is_left_first:bool=True, c
     # print("foot_idx_traj:", foot_idx_traj)
     # print("foot_traj:", foot_traj)
     # print("torso_traj:", torso_traj)
-    return get_foot_pose_traj_msg(time_traj, foot_idx_traj, foot_traj, torso_traj)
-""" ------------------------------------------------------------------------------"""
+    return get_foot_pose_traj_msg(time_traj, foot_idx_traj, foot_traj, torso_traj)