kuavo-humanoid-sdk-ws 1.3.2__20260122221834-py3-none-any.whl

kuavo_humanoid_sdk/kuavo/robot_arm.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+# coding: utf-8
+
+import math
+from typing import Tuple
+from kuavo_humanoid_sdk.interfaces.data_types import KuavoArmCtrlMode, KuavoIKParams, KuavoPose, KuavoManipulationMpcFrame, KuavoManipulationMpcCtrlMode, KuavoManipulationMpcControlFlow
+from kuavo_humanoid_sdk.kuavo.core.core import KuavoRobotCore
+from kuavo_humanoid_sdk.kuavo.robot_info import KuavoRobotInfo
+
+class KuavoRobotArm:
+    def __init__(self):
+        self._kuavo_core = KuavoRobotCore()
+        self._robot_info = KuavoRobotInfo(robot_type="kuavo")
+    
+    def arm_reset(self)-> bool:
+        return self._kuavo_core.robot_arm_reset()
+    
+    def manipulation_mpc_reset(self)-> bool:
+        return self._kuavo_core.robot_manipulation_mpc_reset()
+        
+    def control_arm_joint_positions(self, joint_position:list)->bool:
+        """
+            Control the position of the robot arm joint.
+            Args:
+                joint_position (list): List of joint positions in radians
+            Raises:
+                ValueError: If the joint position list is not of the correct length.
+                RuntimeError: If the robot is not in stance state when trying to control the arm.
+            Returns:
+                True if the control was successful, False otherwise.
+            Note:
+                Joint positions that exceed physical limits will be automatically clipped to the limit values.
+        """
+        if len(joint_position) != self._robot_info.arm_joint_dof:
+            raise ValueError("Invalid position length. Expected {}, got {}".format(self._robot_info.arm_joint_dof, len(joint_position)))
+        
+        # Automatically clip joint positions to physical limits
+        arm_min, arm_max = self._robot_info.get_arm_joint_limits()
+        joint_position_clipped = list(joint_position)  # Create a copy to avoid modifying the original list
+        
+        for i, pos in enumerate(joint_position):
+            if pos < arm_min[i] or pos > arm_max[i]:
+                # Automatically clip to limits
+                joint_position_clipped[i] = max(arm_min[i], min(pos, arm_max[i]))
+
+        return self._kuavo_core.control_robot_arm_joint_positions(joint_data=joint_position_clipped)
+
+    def control_arm_joint_trajectory(self, times:list, joint_q:list)->bool:
+        """
+            Control the target poses of the robot arm.
+            Args:
+                times (list): List of time intervals in seconds
+                joint_q (list): List of joint positions in radians
+            Raises:
+                ValueError: If the times list is not of the correct length.
+                ValueError: If the joint position list is not of the correct length.
+                RuntimeError: If the robot is not in stance state when trying to control the arm.
+            Returns:
+                bool: True if the control was successful, False otherwise.
+            Note:
+                Joint positions that exceed physical limits will be automatically clipped to the limit values.
+        """
+        if len(times) != len(joint_q):
+            raise ValueError("Invalid input. times and joint_q must have thesame length.")
+        
+        # Automatically clip joint positions to physical limits
+        arm_min, arm_max = self._robot_info.get_arm_joint_limits()
+        q_degs = []
+        for frame_idx, q in enumerate(joint_q):
+            if len(q) != self._robot_info.arm_joint_dof:
+                raise ValueError("Invalid position length. Expected {}, got {}".format(self._robot_info.arm_joint_dof, len(q)))
+            
+            # Create a copy to avoid modifying the original list
+            q_clipped = list(q)
+            
+            # Automatically clip each joint position to physical limits
+            for joint_idx, pos in enumerate(q):
+                if pos < arm_min[joint_idx] or pos > arm_max[joint_idx]:
+                    # Automatically clip to limits
+                    q_clipped[joint_idx] = max(arm_min[joint_idx], min(pos, arm_max[joint_idx]))
+            
+            # Convert joint positions from radians to degrees
+            q_degs.append([(p * 180.0 / math.pi) for p in q_clipped])
+
+        return self._kuavo_core.control_robot_arm_joint_trajectory(times=times, joint_q=q_degs)
+
+    def control_robot_end_effector_pose(self, left_pose: KuavoPose, right_pose: KuavoPose, frame: KuavoManipulationMpcFrame)->bool:
+        """
+            Control the end effector pose of the robot arm.
+            Args:
+                left_pose (KuavoPose): Pose of the robot left arm, xyz and quat.
+                right_pose (KuavoPose): Pose of the robot right arm, xyz and quat.
+                frame (KuavoManipulationMpcFrame): Frame of the robot end effector pose.
+            Returns:
+                bool: True if the control was successful, False otherwise.
+        """
+        return self._kuavo_core.control_robot_end_effector_pose(left_pose, right_pose, frame)
+
+    def is_arm_collision(self)->bool:
+        """Check if the arm is in collision.
+        """
+        return self._kuavo_core.is_arm_collision()
+    
+    def is_arm_collision_mode(self)->bool:
+        """Check if arm collision mode is enabled.
+        
+        Returns:
+            bool: True if collision mode is enabled, False otherwise.
+        """
+        return self._kuavo_core.is_arm_collision_mode()
+    
+    def wait_arm_collision_complete(self):
+        """Wait for the arm collision to complete.
+        """
+        self._kuavo_core.wait_arm_collision_complete()
+    
+    def release_arm_collision_mode(self):
+        """Release the arm collision mode.
+        """
+        self._kuavo_core.release_arm_collision_mode()
+
+    def set_arm_collision_mode(self, enable: bool):
+        """Set the arm collision mode.
+        """
+        self._kuavo_core.set_arm_collision_mode(enable)
+
+    def set_fixed_arm_mode(self) -> bool:
+        """
+        Freezes the robot arm.
+        Returns:
+            bool: True if the arm is frozen successfully, False otherwise.
+        """
+        return self._kuavo_core.change_robot_arm_ctrl_mode(KuavoArmCtrlMode.ArmFixed)
+
+    def set_auto_swing_arm_mode(self) -> bool:
+        """
+        Swing the robot arm.
+        Returns:
+            bool: True if the arm is swinging successfully, False otherwise.
+        """
+        return self._kuavo_core.change_robot_arm_ctrl_mode(KuavoArmCtrlMode.AutoSwing)
+    
+    def set_external_control_arm_mode(self) -> bool:
+        """
+        External control the robot arm.
+        Returns:
+            bool: True if the arm is external controlled successfully, False otherwise.
+        """
+        return self._kuavo_core.change_robot_arm_ctrl_mode(KuavoArmCtrlMode.ExternalControl)
+
+    def set_manipulation_mpc_mode(self, ctrl_mode: KuavoManipulationMpcCtrlMode) -> bool:
+        """
+        Set the manipulation mpc mode.
+        Returns:
+            bool: True if the manipulation mpc mode is set successfully, False otherwise.
+        """
+        return self._kuavo_core.change_manipulation_mpc_ctrl_mode(ctrl_mode)
+    
+    def set_manipulation_mpc_control_flow(self, control_flow: KuavoManipulationMpcControlFlow) -> bool:
+        """
+        Set the manipulation mpc control flow.
+        Returns:
+            bool: True if the manipulation mpc control flow is set successfully, False otherwise.
+        """
+        return self._kuavo_core.change_manipulation_mpc_control_flow(control_flow)
+    
+    def set_manipulation_mpc_frame(self, frame: KuavoManipulationMpcFrame) -> bool:
+        """
+        Set the manipulation mpc frame.
+        Returns:
+            bool: True if the manipulation mpc frame is set successfully, False otherwise.
+        """
+        return self._kuavo_core.change_manipulation_mpc_frame(frame)
+    
+    """ Arm Forward kinematics && Arm Inverse kinematics """
+    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:
+        """Inverse kinematics for the robot arm.
+        
+        Args:
+            left_pose (KuavoPose): Pose of the robot left arm, xyz and quat.
+            right_pose (KuavoPose): Pose of the robot right arm, xyz and quat.
+            left_elbow_pos_xyz (list): Position of the robot left elbow. If [0.0, 0.0, 0.0], will be ignored.
+            right_elbow_pos_xyz (list): Position of the robot right elbow. If [0.0, 0.0, 0.0], will be ignored.
+            arm_q0 (list, optional): Initial joint positions in radians. If None, will be ignored.
+            params (KuavoIKParams, optional): Parameters for the inverse kinematics. If None, will be ignored.
+                Contains:
+                - major_optimality_tol: Major optimality tolerance
+                - major_feasibility_tol: Major feasibility tolerance
+                - minor_feasibility_tol: Minor feasibility tolerance
+                - major_iterations_limit: Major iterations limit
+                - oritation_constraint_tol: Orientation constraint tolerance
+                - pos_constraint_tol: Position constraint tolerance, works when pos_cost_weight==0.0
+                - pos_cost_weight: Position cost weight. Set to 0.0 for high accuracy
+                
+        Returns:
+            list: List of joint positions in radians, or None if inverse kinematics failed.
+
+        Warning:
+            This function requires initializing the SDK with the :attr:`KuavoSDK.Options.WithIK`.        
+        """
+        return self._kuavo_core.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]:
+        """Forward kinematics for the robot arm.
+        
+        Args:
+            q (list): List of joint positions in radians.
+            
+        Returns:
+            Tuple[KuavoPose, KuavoPose]: Tuple of poses for the robot left arm and right arm,
+                or (None, None) if forward kinematics failed.
+        
+        Warning:
+            This function requires initializing the SDK with the :attr:`KuavoSDK.Options.WithIK`.        
+        """
+        if len(q) != self._robot_info.arm_joint_dof:
+            raise ValueError("Invalid position length. Expected {}, got {}".format(self._robot_info.arm_joint_dof, len(q)))
+        
+        result = self._kuavo_core.arm_fk(q)
+        if result is None:
+            return None, None
+        return result
+
+# if __name__ == "__main__":
+#     arm = KuavoRobotArm()
+#     arm.set_manipulation_mpc_mode(KuavoManipulationMpcCtrlMode.ArmOnly)
+#     arm.set_manipulation_mpc_control_flow(KuavoManipulationMpcControlFlow.DirectToWbc)
+#     arm.set_manipulation_mpc_frame(KuavoManipulationMpcFrame.WorldFrame)
+#     arm.control_robot_end_effector_pose(KuavoPose(position=[0.3, 0.4, 0.9], orientation=[0.0, 0.0, 0.0, 1.0]), KuavoPose(position=[0.3, -0.5, 1.0], orientation=[0.0, 0.0, 0.0, 1.0]), KuavoManipulationMpcFrame.WorldFrame)

kuavo_humanoid_sdk/kuavo/robot_audio.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# coding: utf-8
+from kuavo_humanoid_sdk.kuavo.core.audio import KuavoRobotAudioCore   
+
+class KuavoRobotAudio:
+    """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 = KuavoRobotAudioCore()
+
+    def play_audio(self, file_name: str, volume: int = 100, 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
+        """
+        return self.audio.play_audio(file_name, volume, speed)
+    
+    def stop_music(self):
+        """Stop the currently playing audio."""
+        return self.audio.stop_music()
+    
+    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
+        """
+        return self.audio.text_to_speech(text, volume)

kuavo_humanoid_sdk/kuavo/robot_head.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# coding: utf-8
+import math
+from kuavo_humanoid_sdk.kuavo.core.core import KuavoRobotCore
+from kuavo_humanoid_sdk.common.logger import SDKLogger
+
+class KuavoRobotHead:
+    def __init__(self):
+        self._kuavo_core = KuavoRobotCore()
+    
+    def control_head(self, yaw: float, pitch: float)->bool:
+        """
+            Control the head of the robot.
+            Args:
+                yaw (float): The yaw angle of the head in radians, range [-1.396, 1.396] (-80 to 80 degrees).
+                pitch (float): The pitch angle of the head in radians, range [-0.436, 0.436] (-25 to 25 degrees).
+            Returns:
+                bool: True if the head is controlled successfully, False otherwise.
+        """
+        # Check yaw limits (-80 to 80 degrees)
+        if yaw < -math.pi*4/9 or yaw > math.pi*4/9:  # -80 to 80 degrees in radians
+            SDKLogger.warn(f"[Robot] yaw {yaw} exceeds limit [-{math.pi*4/9:.3f}, {math.pi*4/9:.3f}] radians (-80 to 80 degrees), will be limited")
+        limited_yaw = min(math.pi*4/9, max(-math.pi*4/9, yaw))
+
+        # Check pitch limits (-25 to 25 degrees)
+        if pitch < -math.pi/7.2 or pitch > math.pi/7.2:  # -25 to 25 degrees in radians
+            SDKLogger.warn(f"[Robot] pitch {pitch} exceeds limit [-{math.pi/7.2:.3f}, {math.pi/7.2:.3f}] radians (-25 to 25 degrees), will be limited")
+        limited_pitch = min(math.pi/7.2, max(-math.pi/7.2, pitch))
+        return self._kuavo_core.control_robot_head(yaw=limited_yaw, pitch=limited_pitch)
+
+    def enable_head_tracking(self, target_id: int)->bool:
+        """Enable the head tracking.
+        """
+        return self._kuavo_core.enable_head_tracking(target_id)
+    
+    def disable_head_tracking(self)->bool:
+        """Disable the head tracking.
+        """
+        return self._kuavo_core.disable_head_tracking()

kuavo_humanoid_sdk/kuavo/robot_info.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+# coding: utf-8
+from typing import Tuple
+import math
+import xml.etree.ElementTree as ET
+from kuavo_humanoid_sdk.interfaces.robot_info import RobotInfoBase
+from kuavo_humanoid_sdk.kuavo.core.ros.param import RosParamWebsocket, make_robot_param
+from kuavo_humanoid_sdk.common.logger import SDKLogger
+
+class KuavoRobotInfo(RobotInfoBase):
+    def __init__(self, robot_type: str = "kuavo"):
+        super().__init__(robot_type=robot_type)
+        
+        # Load robot parameters from ROS parameter server
+        kuavo_ros_param = make_robot_param()
+        self._ros_param = RosParamWebsocket()
+            
+        self._robot_version = kuavo_ros_param['robot_version']
+        self._robot_version_major = (int(self._robot_version) // 10) % 10
+        self._end_effector_type = kuavo_ros_param['end_effector_type']
+        self._arm_joint_dof = kuavo_ros_param['arm_dof']
+        self._leg_joint_dof = kuavo_ros_param['leg_dof']
+        self._waist_joint_dof = kuavo_ros_param.get('waist_dof', 0)  # 腰部关节自由度，默认为0
+        self._joint_dof = kuavo_ros_param['arm_dof'] + kuavo_ros_param['leg_dof'] + kuavo_ros_param['head_dof'] + self._waist_joint_dof
+        self._joint_names = kuavo_ros_param['joint_names']
+        self._end_frames_names = kuavo_ros_param['end_frames_names']
+        self._head_joint_dof = kuavo_ros_param['head_dof']
+        
+
+        # 动态计算关节索引，避免硬编码
+        self._head_joint_names = self._joint_names[-self._head_joint_dof:]
+        
+        if self._waist_joint_dof > 0:
+            self._waist_joint_names = self._joint_names[self._leg_joint_dof:self._leg_joint_dof + self._waist_joint_dof]
+        else:
+            self._waist_joint_names = []
+        
+        # 根据版本计算手臂关节索引
+        if self._robot_version_major == 6:
+            wheel_joint_dof = 4  
+            arm_start_idx = wheel_joint_dof
+            self._arm_joint_names = self._joint_names[arm_start_idx:arm_start_idx + self._arm_joint_dof]
+        else:
+            # 手臂关节起始索引需要考虑腰部关节的偏移
+            arm_start_idx = self._leg_joint_dof + self._waist_joint_dof
+            self._arm_joint_names = self._joint_names[arm_start_idx:arm_start_idx + self._arm_joint_dof]
+        self._init_stand_height = kuavo_ros_param['init_stand_height']
+    @property
+    def robot_version(self) -> str:
+        """Return the version of the robot.
+
+        Returns:
+            str: The robot version, e.g. "42", "43"...
+        """
+        return self._robot_version
+
+    @property
+    def end_effector_type(self) -> str:
+        """Return the type of the end effector.
+
+        Returns:
+            str: The end effector type, where:
+                - "qiangnao" means "dexteroushand"
+                - "lejuclaw" means "lejuclaw"
+                - "qiangnao_touch" means "touchdexteroushand"
+                - ...
+        """
+        return self._end_effector_type
+
+    @property
+    def joint_names(self) -> list:
+        """Return the names of all joints in the robot.
+
+        Returns:
+            list: A list containing the names of all robot joints.
+        """
+        return self._joint_names
+
+    @property
+    def joint_dof(self) -> int:
+        """Return the total number of joints in the robot.
+
+        Returns:
+            int: Total number of joints, e.g. 28
+        """
+        return self._joint_dof
+
+    @property
+    def arm_joint_dof(self) -> int:
+        """Return the number of joints in the double-arm.
+
+        Returns:
+            int: Number of joints in double-arm, e.g. 14
+        """
+        return self._arm_joint_dof
+
+    @property
+    def arm_joint_names(self) -> list:
+        """Return the names of joints in the double-arm.
+
+        Returns:
+            list: A list containing the names of joints in the double-arm.
+        """
+        return self._arm_joint_names
+
+    @property
+    def head_joint_dof(self) -> int:
+        """Return the number of joints in the head.
+
+        Returns:
+            int: Number of joints in head, e.g. 2
+        """
+        return self._head_joint_dof
+
+    @property
+    def waist_joint_dof(self) -> int:
+        """Return the number of joints in the waist.
+
+        Returns:
+            int: Number of joints in waist, e.g. 0 or 1
+        """
+        return self._waist_joint_dof
+
+    @property
+    def waist_joint_names(self) -> list:
+        """Return the names of joints in the waist.
+
+        Returns:
+            list: A list containing the names of joints in the waist.
+                Note: For websocket SDK, joint_names() does not include waist joints,
+                so this will always return an empty list.
+        """
+        return self._waist_joint_names
+
+    @property
+    def head_joint_names(self) -> list:
+        """Return the names of joints in the head.
+
+        Returns:
+            list: A list containing the names of joints in the head.
+        """
+        return self._head_joint_names
+
+    @property
+    def eef_frame_names(self) -> Tuple[str, str]:
+        """Returns the names of the end effector frames.
+
+        Returns:
+            Tuple[str, str]:
+                A tuple containing the end effector frame names, where:
+                - First element is the left hand frame name
+                - Second element is the right hand frame name
+                e.g. ("zarm_l7_link", "zarm_r7_link")
+        """
+        return self._end_frames_names[1], self._end_frames_names[2]
+    
+    @property
+    def init_stand_height(self) -> float:
+        """Return the height of the robot's center of mass.
+        """
+        return self._init_stand_height
+    
+    def get_arm_joint_limits(self) -> Tuple[list, list]:
+        """获取手臂关节的角度限制范围（基于URDF文件中的真实物理限制）。
+        
+        返回每个关节的最小值和最大值（单位：弧度）。
+        这些限制从URDF文件中解析得到，基于机器人的真实物理结构，用于防止电机堵转。
+        
+        Returns:
+            Tuple[list, list]: (arm_min, arm_max) 
+                - arm_min: 每个关节的最小角度值列表（弧度）
+                - arm_max: 每个关节的最大角度值列表（弧度）
+                
+        Note:
+            这些限制从URDF文件的 <joint><limit> 标签中解析得到，针对每个关节的真实角度范围进行了定义。
+            动态从URDF中提取所有手臂相关的link和关节，兼容不同机器人版本。
+        """
+        try:
+            # 获取URDF内容
+            robot_desc = self._ros_param.humanoid_description()
+            if robot_desc is None:
+                SDKLogger.warn("Failed to get URDF description, using default limits")
+                return self._get_default_arm_joint_limits()
+            
+            # 解析URDF XML
+            root = ET.fromstring(robot_desc)
+            
+            # 获取关节限制
+            arm_min = []
+            arm_max = []
+            
+            # 直接使用 arm_joint_names 从 URDF 中查找对应的关节
+            for joint_name in self._arm_joint_names:
+                # 直接通过关节名称查找
+                joint_elem = root.find(f".//joint[@name='{joint_name}']")
+                
+                if joint_elem is not None:
+                    limit_elem = joint_elem.find("limit")
+                    if limit_elem is not None:
+                        lower = float(limit_elem.get("lower", str(-math.pi)))
+                        upper = float(limit_elem.get("upper", str(math.pi)))
+                        arm_min.append(lower)
+                        arm_max.append(upper)
+                    else:
+                        SDKLogger.warn(f"Joint {joint_name} has no limit tag, using default [-π, π]")
+                        arm_min.append(-math.pi)
+                        arm_max.append(math.pi)
+                else:
+                    SDKLogger.warn(f"Joint {joint_name} not found in URDF, using default [-π, π]")
+                    arm_min.append(-math.pi)
+                    arm_max.append(math.pi)
+            
+            if len(arm_min) != self._arm_joint_dof or len(arm_max) != self._arm_joint_dof:
+                SDKLogger.warn(f"Failed to parse all joint limits from URDF (got {len(arm_min)}/{self._arm_joint_dof}), using default limits")
+                return self._get_default_arm_joint_limits()
+            
+            return arm_min, arm_max
+            
+        except Exception as e:
+            SDKLogger.error(f"Error parsing joint limits from URDF: {e}, using default limits")
+            return self._get_default_arm_joint_limits()
+    
+    def _get_default_arm_joint_limits(self) -> Tuple[list, list]:
+        """获取默认的手臂关节限制（当无法从URDF解析时使用）。
+        
+        Returns:
+            Tuple[list, list]: (arm_min, arm_max) 默认限制值
+        """
+        # 默认使用较大的范围作为后备方案
+        arm_min = [-math.pi] * self._arm_joint_dof
+        arm_max = [math.pi] * self._arm_joint_dof
+        return arm_min, arm_max
+    
+    def __str__(self) -> str:
+        return f"KuavoRobotInfo(robot_type={self.robot_type}, robot_version={self.robot_version}, end_effector_type={self.end_effector_type}, joint_names={self.joint_names}, joint_dof={self.joint_dof}, arm_joint_dof={self.arm_joint_dof}, init_stand_height={self.init_stand_height})"

kuavo_humanoid_sdk/kuavo/robot_observation.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+# coding: utf-8
+from kuavo_humanoid_sdk.interfaces.data_types import (
+    KuavoJointCommand, KuavoTwist)
+from kuavo_humanoid_sdk.kuavo.core.ros.observation import KuavoRobotObservationCoreWebsocket
+
+class KuavoRobotObservation:
+    """Class for accessing robot observation data.
+    
+    This class provides a high-level interface to access robot observation data,
+    including joint commands, velocity commands, and pose commands.
+    
+    Attributes:
+        _obs_core: The core observation object that handles ROS communication.
+    """
+    
+    def __init__(self, robot_type: str = "kuavo"):
+        """Initialize the robot observation interface.
+        
+        Args:
+            robot_type (str): Type of the robot. Defaults to "kuavo".
+        """
+        self._obs_core = KuavoRobotObservationCoreWebsocket()
+
+    @property
+    def joint_command(self) -> KuavoJointCommand:
+        """Get the current joint command.
+        
+        Returns:
+            KuavoJointCommand: Object containing position, velocity, and torque commands
+                for all robot joints.
+        """
+        return self._obs_core.joint_command
+
+    @property
+    def cmd_vel(self) -> KuavoTwist:
+        """Get the current velocity command.
+        
+        Returns:
+            KuavoTwist: Object containing linear velocity (m/s) and angular velocity (rad/s) commands.
+        """
+        return self._obs_core.cmd_vel
+
+    @property
+    def cmd_pose(self) -> KuavoTwist:
+        """Get the current pose command.
+        
+        Returns:
+            KuavoTwist: Object containing linear pose commands (m) and angular pose commands (rad).
+        """
+        return self._obs_core.cmd_pose
+
+    @property    
+    def arm_position_command(self) -> list:
+        """Get the position commands for the arm joints.
+        
+        Returns:
+            list: Position commands for arm joints (indices 12-25) in radians.
+        """
+        return self._obs_core.arm_position_command
+
+    @property
+    def head_position_command(self) -> list:
+        """Get the position commands for the head joints.
+        
+        Returns:
+            list: Position commands for head joints (indices 26-27) in radians.
+        """
+        return self._obs_core.head_position_command