Dual ARM Commands
Type a command and press Enter.
``` # 4 Low-Level Motion Control Development Interface The **cross-platform low-level motion control API** provides a unified C++/Python interface, compatible with ROS1, ROS2, and non-ROS systems, enabling rapid migration and deployment of motion control algorithms. Through a hardware abstraction layer and standardized communication protocols, developers can seamlessly switch between simulation and real hardware environments, significantly reducing multi-platform adaptation costs. > **Notes:** > > 1. To use the low-level control API, press `R1 + START` to switch to **Developer Mode**. In this mode, high-level control interfaces are disabled, and the robot only responds to power-on/power-off and zeroing remote controller commands. > 2. Example code for the low-level interface can be found in the RL deployment and training section. > 3. When switched to Developer Mode, the robot will retain the power state. To exit Developer Mode, press `L2 + ○`. ## 4.1 C++ Motion Control Development Interface ### 4.1.1 getInstance Interface | Function Name | **getInstance** | | ------------------ | --------------- | | Function Prototype | static Humanoid* getInstance(); | | Description | Retrieves the singleton instance pointer of the Humanoid robot class. | | Parameters | None | | Return Value | Humanoid*, Pointer to the Humanoid instance | | Remarks | Implements the singleton pattern to ensure only one instance of the Humanoid class exists in the program. | Code Example： ```cpp #include**Notes:** This interface reports joint states based on the robot’s equivalent serial URDF.
This robot adopts a series-parallel hybrid configuration design, with parallel drive structures used at some joints. Unlike traditional serial joints (where a joint is directly driven by a single actuator), parallel joints have the following characteristics:
- Multiple actuators collaboratively driving a single joint DOF
- Higher load capacity, stiffness, and dynamic performance
- More compact mechanical design with higher torque density
- Improved fault tolerance through actuator redundancy
While parallel actuation offers significant mechanical advantages, it also introduces challenges for control and application development:
- More complex kinematic and dynamic modeling
- Incompatibility with conventional serial robot control algorithms
- Higher learning curve due to parallel mechanism theory
- Limited compatibility with existing robotics ecosystems (e.g., ROS, MoveIt!)
To eliminate these complexities, the robot controller transparently maps parallel joints to an equivalent serial joint model, allowing upper-layer applications to interact with the robot as if it were a standard serial manipulator.
**State Feedback:**
Parallel actuator states (position, velocity, current/torque) → Equivalent serial joint computation → Equivalent serial joint states (position, velocity, torque) | | Parameters | cb: callback function, invoked upon receiving a state update, with a constant pointer to a RobotState object as its parameter. | | Return Value | None | | Remarks | - RobotState data structure prototype defined as follows: | ```cpp /** * @struct RobotState * * @brief Represents a data structure for robot state based on sensor feedback. * * This structure encapsulates various data points used for monitoring and controlling the robot, including IMU data (accelerometer, gyroscope, quaternion), output torques, current joint angles, velocities, and more. */ struct RobotState { // Default constructor RobotState() { } // Parameterized constructor, initializes vectors tau, q, and dq with size motor_num, all elements set to 0.0. RobotState(int motor_num) : tau(motor_num, 0.0) , q(motor_num, 0.0) , dq(motor_num, 0.0) { } , motor_names(motor_num, "") { } uint64_t stamp; // Timestamp （in nanoseconds）, typically indicates the time at which the data was recorded or generated. std::vector
**Notes:** This interface accepts joint commands for the robot’s equivalent serial URDF model.
The robot adopts a serial–parallel hybrid architecture, with parallel drive structures used at some joints. Unlike conventional serial joints, where each joint is driven by a single actuator, parallel joints have the following characteristics:
- Multiple actuators collaboratively drive a single joint DOF.
- Higher load capacity, stiffness, and dynamic performance.
- More compact mechanical design with higher joint torque output.
- Improved fault tolerance through actuator redundancy.
Although parallel joints offer significant mechanical advantages, they also introduce challenges for control and application development:
- More complex kinematic and dynamic models.
- Conventional serial robot control algorithms and toolchains cannot be applied directly.
- Higher learning curve due to the complexity of parallel mechanisms.
- Limited compatibility with existing robotics ecosystems (e.g., ROS and MoveIt!).
To address these challenges, the robot controller performs a transparent conversion from parallel joints to an equivalent serial joint model, completely hiding the complexity of the parallel mechanisms from upper-layer applications.
**Command Flow:**
Equivalent serial joint commands (position, velocity, torque) → Parallel actuator command computation → Actuator command execution
**Note:**
Since Kp and Kd gains cannot be efficiently converted to parallel actuator commands, users requiring force control are recommended to command joint torque (tau) directly instead of achieving force control indirectly through PD control. This is particularly relevant for reinforcement learning policies that output position or velocity actions, where the controller converts PD commands into torque commands internally. | | Parameters | cmd: a RobotCmd object specifying the desired robot command | | Return Value | None | | Remarks | - RobotCmd data structure prototype defined as follows: | ```cpp /** * @struct RobotCmd * * @brief Represents a data structure for robot state based on sensor feedback. * * This structure contains various commands that can be used to control the robot, including the desired operating mode, target joint angles, target velocities, target output torques, desired position stiffness, and desired velocity stiffness. */ struct RobotCmd { RobotCmd() { } RobotCmd(int motor_num) : mode(motor_num, 0) , q(motor_num, 0.0) , dq(motor_num, 0.0) , tau(motor_num, 0.0) , Kp(motor_num, 0.0) , Kd(motor_num, 0.0) { } , motor_names(motor_num, "") { } uint64_t stamp; // Timestamp （in nanoseconds）, typically indicates the time at which the data was recorded or generated. std::vector
The callback is triggered in the following cases:
1. When the robot returns a response to a previously sent JSON command (publishJsonMessage).
2. When the robot actively sends an unsolicited notification. | | Parameters | cb: callback function, prototype as `void(const std::string &json_payload)`
json_payload includes:
- Command response: `{"accid": "xxx", "title": "response_xxx", "timestamp": xxx, "guid": "xxx", "data": {}}`
- Notification: `{"accid": "xxx", "title": "notify_xxx", "timestamp": xxx, "guid": "xxx", "data": {}}` | | Return Value | None | | Remarks | Valid only in high-level development mode | Code Example： ```cpp #include
Failure: return False | | Remarks | None | Code Example： ```python import sys import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # Check whether a command-line argument is provided as the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot’s communication runtime environment using the IP address if not robot.init(robot_ip): sys.exit() ``` ### 4.2.4 getMotorNumber Interface | Function Name | **getMotorNumber** | | ------------------ | ------------------ | | Function Prototype | def getMotorNumber(self) | | Description | Retrieves the motor number in the robot. | | Parameters | None | | Return Value | Returns an unsigned integer representing the total number of motors in the robot. | | Remarks | Typically, a bipedal humanoid robot is equipped with 6 motors. | Code Example： ```python import sys import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # Check whether a command-line argument is provided as the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot using robot_ip if not robot.init(robot_ip): sys.exit() # Obtain the number of motors in the robot motor_number = robot.getMotorNumber() ``` ### 4.2.5 subscribeImuData Interface | Function Name | **subscribeImuData** | | ------------------ | -------------------- | | Function Prototype | def subscribeImuData(self, callback: Callable[[datatypes.ImuData], Any]) | | Description | Subscribes to the robot’s IMU data and triggers the specified callback function whenever new IMU data is received. | | Parameters | Callback: Callback function to process the new IMU data. | | Return Value | Success: return True Failure: return False | | Remarks | - datatypes.ImuData structure prototype defined as follows: | ```python import sys class ImuData(object): __slots__ = ['stamp','acc','gyro','quat'] def __init__(self): self.stamp = 0 # Timestamp: Typically indicates the time at which the data was recorded or generated, in nanoseconds self.acc = [0. for x in range(0, 3)] # Stores IMU (Inertial Measurement Unit) accelerometer data, used to track linear acceleration along the three axes self.gyro = [0. for x in range(0, 3)] # Stores IMU gyroscope data, used to track angular velocity or rotational speed self.quat = [0. for x in range(0, 4)] # Stores IMU quaternion data, representing orientation in 3D space ``` Code Example： ```python import sys from functools import partial import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType import limxsdk.datatypes as datatypes class RobotReceiver: # Subscribe to the robot's IMU data def imuDataCallback(self, imu: datatypes.ImuData): print("\n------\nrobot_state:" + \ "\n stamp: " + str(imu.stamp) + \ "\n acc: " + str(imu.acc) + \ "\n gyro: " + str(imu.gyro) + \ "\n quat: " + str(imu.quat)) if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # Check whether a command-line argument is provided for the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot using robot_ip if not robot.init(robot_ip): sys.exit() # Create a RobotReceiver instance to handle callbacks receiver = RobotReceiver() # Create a partial function for the callback imuDataCallback = partial(receiver.imuDataCallback) # Subscribe to the robot's IMU data robot.subscribeImuData(imuDataCallback) ``` ### 4.2.6 subscribeRobotState Interface | Function Name | **subscribeRobotState** | | ------------------ | ----------------------- | | Function Prototype | def subscribeRobotState(self, callback: Callable[[datatypes.RobotState], Any]) | | Description | Subscribes to receive updates on robots' status | | Parameters | Callback: callback function, invoked upon receiving a state update. Its parameter points to a datatypes.RobotState object.
- datatypes.RobotState structure fields:
- stamp: Timestamp, indicates when the data was recorded or generated.
- tau: Vector storing the estimated output torques (in newton-meters).
- q: Vector storing the current joint positions (in radians).
- dq: Vector storing the current joint velocities (in radians per second).
- motor_names: store the corresponding joint name.
**Notes:** This interface reports joint states based on the robot’s equivalent serial URDF.
This robot adopts a series-parallel hybrid configuration design, with parallel drive structures used at some joints. Unlike traditional serial joints (where a joint is directly driven by a single actuator), parallel joints have the following characteristics:
- Multiple actuators collaboratively driving a single joint DOF
- Higher load capacity, stiffness, and dynamic performance
- More compact mechanical design with higher torque density
- Improved fault tolerance through actuator redundancy
While parallel actuation offers significant mechanical advantages, it also introduces challenges for control and application development:
- More complex kinematic and dynamic modeling
- Incompatibility with conventional serial robot control algorithms
- Higher learning curve due to parallel mechanism theory
- Limited compatibility with existing robotics ecosystems (e.g., ROS, MoveIt!)
To eliminate these complexities, the robot controller transparently maps parallel joints to an equivalent serial joint model, allowing upper-layer applications to interact with the robot as if it were a standard serial manipulator.
**State Feedback:**
Parallel actuator states (position, velocity, current/torque) → Equivalent serial joint computation → Equivalent serial joint states (position, velocity, torque) | | Return Value | Success: return True Failure: return False | | Remarks | - datatypes.RobotState structure prototype defined as follows: | ```python import sys class RobotState(object): __slots__ = ['stamp','tau','q','dq'] def __init__(self): self.stamp = 0 # Timestamp: Typically indicates the time at which the data was recorded or generated, in nanoseconds self.tau = [] # Stores the vector of current estimated output torques (unit: N·m) self.q = [] # Stores the vector of current joint angles (unit: radians) self.dq = [] # Stores the vector of current joint velocities (unit: radians per second) self.motor_names = [] # Stores the corresponding joint names ``` Code Example： ```python import sys from functools import partial import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType import limxsdk.datatypes as datatypes class RobotReceiver: # Callback function for receiving the robot’s state def robotStateCallback(self, robot_state: datatypes.RobotState): print("\n------\nrobot_state:" + \ "\n stamp: " + str(robot_state.stamp) + \ "\n tau: " + str(robot_state.tau) + \ "\n q: " + str(robot_state.q) + \ "\n dq: " + str(robot_state.dq)) if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # Check whether a command-line argument is provided for the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot using robot_ip if not robot.init(robot_ip): sys.exit() # Create a RobotReceiver instance to handle callbacks receiver = RobotReceiver() # Create a partial function for the callback robotStateCallback = partial(receiver.robotStateCallback) # Subscribe to the robot's IMU data robot.subscribeRobotState(robotStateCallback) ``` ### 4.2.7 publishRobotCmd Interface | Function Name | **publishRobotCmd** | | ------------------ | ------------------- | | Function Prototype | def publishRobotCmd (self, cmd: datatypes.RobotCmd) | | Description | Publishes a command to control the robot’s actions. | | Parameters | cmd: A datatypes.RobotCmd object representing the desired robot command, containing the following fields:
- stamp: Timestamp in nanoseconds indicating when the data was recorded or generated.
- q: Vector storing the desired joint positions (in radians).
- dq: Vector storing the desired joint velocities (in radians per second).
- tau: Vector storing the desired output torques (in newton-meters).
- Kp: Vector storing the desired position stiffness (in newton-meters per radian).
- Kd: Vector storing the desired velocity stiffness (in newton-meters per radian per second).
- motor_names: store the joint names that need to be controlled.
**Notes:** This interface accepts joint commands for the robot’s equivalent serial URDF model.
The robot adopts a serial–parallel hybrid architecture, with parallel drive structures used at some joints. Unlike conventional serial joints, where each joint is driven by a single actuator, parallel joints have the following characteristics:
- Multiple actuators collaboratively drive a single joint DOF.
- Higher load capacity, stiffness, and dynamic performance.
- More compact mechanical design with higher joint torque output.
- Improved fault tolerance through actuator redundancy.
Although parallel joints offer significant mechanical advantages, they also introduce challenges for control and application development:
- More complex kinematic and dynamic models.
- Conventional serial robot control algorithms and toolchains cannot be applied directly.
- Higher learning curve due to the complexity of parallel mechanisms.
- Limited compatibility with existing robotics ecosystems (e.g., ROS and MoveIt!).
To address these challenges, the robot controller performs a transparent conversion from parallel joints to an equivalent serial joint model, completely hiding the complexity of the parallel mechanisms from upper-layer applications.
**Command Flow:**
Equivalent serial joint commands (position, velocity, torque) → Parallel actuator command computation → Actuator command execution
**Note:**
Since Kp and Kd gains cannot be efficiently converted to parallel actuator commands, users requiring force control are recommended to command joint torque (tau) directly instead of achieving force control indirectly through PD control. This is particularly relevant for reinforcement learning policies that output position or velocity actions, where the controller converts PD commands into torque commands internally. | | Return Value | Success: return True Failure: return False | | Remarks | - datatypes.RobotCmd structure prototype defined as follows: | ```python import sys class RobotCmd(object): __slots__ = ['stamp','mode','q','dq','tau','Kp','Kd'] def __init__(self): self.stamp = 0 # Timestamp （in nanoseconds）, typically indicates the time at which the data was recorded or generated. self.mode = [] # The robot's desired working mode self.q = [] # A vector for storing desired joint angles (unit: radians) self.dq = [] # A vector for storing desired joint velocities (unit: radians per second) self.tau = [] # A vector for storing desired output torques (unit: N·m) self.Kp = [] # A vector for storing desired position stiffness values (unit: N·m per radian) self.Kd = [] # A vector for storing desired velocity stiffness values (unit: N·m per radian per second) self.motor_names = [] # Stores the names of the robot joints to be controlled ``` Code Example： ```python import sys import time import limxsdk.robot.Rate as Rate import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType import limxsdk.datatypes as datatypes if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # Check whether a command-line argument is provided as the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot using robot_ip if not robot.init(robot_ip): sys.exit() # Obtain information on joint offsets, joint limits, and the number of motors joint_offset = robot.getJointOffset() joint_limit = robot.getJointLimit() motor_number = robot.getMotorNumber() # Main loop to continuously publish robot commands rate = Rate(500) # 1500 Hz cmd_msg = datatypes.RobotCmd() while True: # Set default values for timestamp, control mode, joint positions, velocities, torques, Kp, and Kd cmd_msg.stamp = time.time_ns() cmd_msg.mode = [1.0 for _ in range(motor_number)] cmd_msg.q = [1.0 for _ in range(motor_number)] cmd_msg.dq = [1.0 for _ in range(motor_number)] cmd_msg.tau = [1.0 for _ in range(motor_number)] cmd_msg.Kp = [1.0 for _ in range(motor_number)] cmd_msg.Kd = [1.0 for _ in range(motor_number)] robot.publishRobotCmd(cmd_msg) # Publish the robot commands rate.sleep() # Control the loop frequency ``` ### 4.2.8 subscribeSensorJoy Interface | Function Name | **subscribeSensorJoy** | | ------------------ | ---------------------- | | Function Prototype | def subscribeSensorJoy(self, callback: Callable[[datatypes.SensorJoy], Any]) | | Description | Subscribes to the robot’s remote controller data during real-machine deployment. When data is received, the specified callback function is invoked and provided with a constant pointer to a datatypes.SensorJoy structure for processing. | | Parameters | callback: Callback Function for receiving remote controller data with parameter type SensorJoyConstPtr. | | Return Value | Success: return True Failure: return False | | Remarks | - datatypes.SensorJoy structure prototype defined as follows: | ```python import sys class SensorJoy(object): __slots__ = ['stamp','axes','buttons'] def __init__(self): self.stamp = 0 # Timestamp corresponding to the sensor input time, in nanoseconds self.axes = [] # Values representing controller joystick manipulation self.buttons = [] # Values representing controller button operation states ``` Code Example： ```python import sys import time from functools import partial import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType import limxsdk.datatypes as datatypes class RobotReceiver: # Callback function for receiving the remote controller data def sensorJoyCallback(self, sensor_joy: datatypes.SensorJoy): print("\n------\nsensor_joy:" + \ "\n stamp: " + str(sensor_joy.stamp) + \ "\n axes: " + str(sensor_joy.axes) + \ "\n buttons: " + str(sensor_joy.buttons)) if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # Check whether a command-line argument is provided for the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot using robot_ip if not robot.init(robot_ip): sys.exit() # Create a RobotReceiver instance to handle callbacks receiver = RobotReceiver() # Create a partial function for the callback sensorJoyCallback = partial(receiver.sensorJoyCallback) # Subscribe to the robot's IMU data robot.subscribeSensorJoy(sensorJoyCallback) ``` ### 4.2.9 subscribeDiagnosticValue Interface | Function Name | **subscribeDiagnosticValue** | | ------------------ | ---------------------------- | | Function Prototype | def subscribeDiagnosticValue(self, callback: Callable[[datatypes.DiagnosticValue], Any]) | | Description | Subscribes to the robot’s diagnostic and status updates. Upon receiving a diagnostic message, the callback function is triggered with a datatypes.DiagnosticValue object, allowing continuous health monitoring and prompt response to detected issues. | | Parameters | Callback function for receiving diagnostic data. The parameter type is datatypes.DiagnosticValue, which contains fields such as timestamp, level, name, code, and message. | | Return Value | Success: return True Failure: return False | | Remarks | - datatypes.DiagnosticValue structure prototype defined as follows: | ```python import sys class DiagnosticValue(object): __slots__ = ['stamp','level','name','code','message'] def __init__(self): self.stamp = 0 # Timestamp, in nanoseconds self.level = 0 # Diagnostic level associated with the diagnostic value - 0: OK, 1: WARN, 2: ERROR self.name = '' # Name identifying the diagnostic value self.code = 0 # Code corresponding to the diagnostic value self.message = '' # Detailed message related to the diagnostic value ``` Code Example： ```python import sys from functools import partial import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType import limxsdk.datatypes as datatypes class RobotReceiver: # Callback function for receiving diagnostic value def diagnosticValueCallback(self, diagnostic_value: datatypes.DiagnosticValue): print("\n------\ndiagnostic_value:" + \ "\n stamp: " + str(diagnostic_value.stamp) + \ "\n name: " + diagnostic_value.name + \ "\n level: " + str(diagnostic_value.level) + \ "\n code: " + str(diagnostic_value.code) + \ "\n message: " + diagnostic_value.message) if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # Check whether a command-line argument is provided for the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot using robot_ip if not robot.init(robot_ip): sys.exit() # Create a RobotReceiver instance to handle callbacks receiver = RobotReceiver() # Create a partial function for the callback diagnosticValueCallback = partial(receiver.diagnosticValueCallback) # Subscribe to the robot's IMU data robot.subscribeDiagnosticValue(diagnosticValueCallback) ``` ### 4.2.10 publishJsonMessage Interface | Function Name | **publishJsonMessage** | | ------------------ | ---------------------- | | Function Prototype | def publishJsonMessage(self, json_payload: str) | | Description | Sends a JSON-formatted message to the robot following the High-Level Application Protocol Interface. | | Parameters | json_payload: A JSON string conforming to the High-Level Application Protocol specification. Example: {"accid": "xxx", "title": "request_xxx", "timestamp": xxx, "guid": "xxx", "data": {}} | | Return Value | None | | Remarks | Valid only in high-level development mode. | Code Example： ```python import sys import time import limxsdk.robot.Rate as Rate import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType import limxsdk.datatypes as datatypes if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "10.192.1.2" # Check whether a command-line argument is provided for the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot using robot_ip if not robot.init(robot_ip): sys.exit() # Set the protocol content to be sent json_payload = '''{ "accid": "HU_D03_01", # Replace with the real robot serial number (SN) "title": "request_get_joint_state", "timestamp": 1672373633989, "guid": "746d937cd8094f6a98c9577aaf213d98", "data": {} }''' # Send the JSON protocol. robot.publishJsonMessage(json_payload) # Keep the program running try: while True: time.sleep(1) except KeyboardInterrupt: print("Program interrupted by the user") ``` ### 4.2.11 subscribeJsonMessage Interface | Function Name | **subscribeJsonMessage** | | ------------------ | ------------------------ | | Function Prototype | def subscribeJsonMessage(self, callback: Callable[[str], Any]) | | Description | Registers a callback function to handle responses and notifications from the robot’s High-Level Application Protocol Interface.
The callback is triggered in the following cases:
1. When the robot returns a response to a previously sent JSON command (publishJsonMessage).
2. When the robot actively sends an unsolicited notification. | | Parameters | callback: callback function
json_payload includes:
- Command response: `{"accid": "xxx", "title": "response_xxx", "timestamp": xxx, "guid": "xxx", "data": {}}`
- Notification: `{"accid": "xxx", "title": "notify_xxx", "timestamp": xxx, "guid": "xxx", "data": {}}` | | Return Value | None | | Remarks | Valid only in high-level development mode | Code Example： ```python import sys import time from functools import partial import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType import limxsdk.datatypes as datatypes class RobotReceiver: # Handle responses and notifications from the robot’s “High-Level Application Protocol Interface” calls. def jsonMessageCallback(self, json_payload: str): print("\n------\njson_payload:" + json_payload) if __name__ == '__main__': # Create a Robot instance of type Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "10.192.1.2" # Check whether a command-line argument is provided for the robot’s IP address if len(sys.argv) > 1: robot_ip = sys.argv[1] # Initialize the robot using robot_ip if not robot.init(robot_ip): sys.exit() # Create a RobotReceiver instance to handle callbacks receiver = RobotReceiver() # Create a partial function for the callback jsonMessageCallback = partial(receiver.jsonMessageCallback) # Subscribe to the robot's IMU data robot.subscribeJsonMessage(jsonMessageCallback) ``` ### 4.2.12 Reference Example Github: `https://github.com/limxdynamics/humanoid-rl-deploy-python` # 5 Check and Set the Robot Model When compiling or running RL training, control algorithms and simulation programs, selecting the correct robot model is essential. Check the robot model and set it in the environment variable `ROBOT_TYPE` to ensure the correct model is identified and applied across different tasks. **Steps to View and Configure the Robot Model:** 1. Connect to the robot’s Wi-Fi hotspot and enter the password: `12345678`  2. Open a web browser and navigate to `http://10.192.1.2:8080`. The page displays the SN (serial number) — for example, **HU_D03_03_001** — where **HU_D03_03** represents the robot model, as shown below.  3. Set the robot model: Open a Bash terminal and run the following shell command to set the robot model. This ensures that the correct robot model information is recognized during secondary development. ```bash echo 'export ROBOT_TYPE=HU_D03_03' >> ~/.bashrc && source ~/.bashrc ``` # 6 Robot Simulator **MuJoCo** is a lightweight, high-performance physics simulator designed for multi-joint robots and mechanical systems. It features an efficient physics engine capable of accurately simulating contact and friction, and can operate independently without relying on ROS. ## 6.1 Running the Simulator 1. Environment Requirements: Python 3.8 or higher is recommended 2. Open a Bash Terminal 3. Download the MuJoCo Simulator Code: ```bash git clone --recurse git@github.com:limxdynamics/humanoid-mujoco-sim.git ``` 4. Install the Motion Control Development Library: - Linux x86_64 Environment ```bash pip install humanoid-mujoco-sim/limxsdk-lowlevel/python3/amd64/limxsdk-*-py3-none-any.whl ``` - Linux aarch64 Environment ```bash pip install humanoid-mujoco-sim/limxsdk-lowlevel/python3/aarch64/limxsdk-*-py3-none-any.whl ``` 5. Set the Robot Model: Please refer to the “check and set the Robot Model” section to check your robot model. If not yet configured, please follow the steps below: - List available robot types using the shell command tree -L 3 -P "meshes" -I "urdf|world|xml|usd" humanoid-mujoco-sim/humanoid-description: ```bash limx@limx:~$ tree -L 3 -P "meshes" -I "urdf|world|xml|usd" humanoid-mujoco-sim/humanoid-description humanoid-mujoco-sim/humanoid-description ├── HU_D03_description │ └── meshes │ └── HU_D03_03 └── HU_D04_description └── meshes └── HU_D04_01 ``` - For example, to set the robot model type HU_D04_01 (replace with your actual model): ```bash echo 'export ROBOT_TYPE=HU_D04_01' >> ~/.bashrc && source ~/.bashrc ``` 6. Run the MuJoCo simulator： ```bash python humanoid-mujoco-sim/simulator.py ``` ## 6.2 Demonstration Results > Actual performance may vary depending on your system configuration. >  # 7 RL Algorithm Deployment ## 7.1 Deployment with Standard C++ - **Github Repository:** [https://github.com/limxdynamics/humanoid-rl-deploy-cpp](https://github.com/limxdynamics/humanoid-rl-deploy-cpp) - A lightweight algorithm framework implemented in standard C++, enabling fast deployment of trained models without requiring ROS1 or ROS2. ## 7.2 Deployment with Python - **Github Repository:** [https://github.com/limxdynamics/humanoid-rl-deploy-python](https://github.com/limxdynamics/humanoid-rl-deploy-python) - A Python-based reinforcement learning deployment framework that simplifies the process of deploying trained models on Oli. ## 7.3 Deployment with ROS2 - **Github Repository:** [https://github.com/limxdynamics/humanoid-rl-deploy-ros2](https://github.com/limxdynamics/humanoid-rl-deploy-ros2) - A reinforcement learning deployment framework based on [ROS2](https://www.ros.org), allowing rapid deployment of trained models on Oli. ## 7.4 Deployment with ROS1 - **Github Repository:** [https://github.com/limxdynamics/humanoid-rl-deploy-ros](https://github.com/limxdynamics/humanoid-rl-deploy-ros) - A reinforcement learning deployment framework based on [ROS1](https://www.ros.org), enabling efficient deployment of trained models on Oli. # 8 Logs and Data Packages - **Automatic Data Recording:** The robot system automatically records essential data, including IMU data (ImuData), state data (/joint/state), control data (/joint/cmd), and runtime logs. These records are critical for motion control analysis and performance evaluation. - **Accessing and Downloading Data:** The robot stores runtime log data for troubleshooting and performance optimization. To access the data, connect your computer to the robot’s Wi-Fi hotspot, then open a browser at `http://10.192.1.2:8090` to download the desired datasets.  ## 8.1 Data Package Visualization and Analysis * **Downloading Data Packages: **After downloading a `.bag` file, you can use PlotJuggler to visualize and analyze the data.** **If the downloaded file is in `.bag.active` format, run the following shell command to reindex it and generate a new `.bag` file for PlotJuggler to load properly. ```bash rosbag reindex your_file.bag.active mv your_file.bag.active your_file.bag ``` * **Visualization: **Launch the PlotJuggler visualization tool using the shell command `rosrun plotjuggler plotjuggler -n`, then load the data packages as shown below:  ## 8.2 Logs and Diagnostic Trace Data Structured log and diagnostic trace data are recorded for system monitoring, as shown below. These datasets can be used for troubleshooting and performance optimization when needed.  # 9 Robot Software Upgrade You can upgrade the robot software via the web management interface using a locally downloaded software package. The steps are as follows: 1. **Connect to Wi-Fi: ** * Connect to your robot's Wi-Fi hotspot, password: `12345678`  2. **Access The Management Page: ** * Open a browser and enter [http://10.192.1.2:8080](http://10.192.1.2:8080/) to access the robot management interface 3. **Select and Upgrade Software：** * Navigate to "Version Management" -> "Browse" -> "Upgrade" * After the upgrade is complete, the robot's main control computer will restart automatically.  # 10 Developer Computer The developer computer is primarily used for developing robot-related algorithms and applications. It can be accessed via the robot’s onboard Wi-Fi network. The steps are as follows: 1. **Connect to Wi-Fi: ** * Connect to your robot's Wi-Fi hotspot, password: `12345678`  2. **SSH Login：** * IP Address: `10.192.1.3` * Password: `123456` * Use the following command in the terminal (fingerprint confirmation needed on first login) ```python ssh guest@10.192.1.3 ``` * System Configuration: * Operating System: Ubuntu 22.04 （Jetpack 6.2.1） * ROS2: ROS2 Humble (default installation) * ROS1: ROS1 Noetic (Docker-based environment), to enter the ROS1 Docker environment: ```python sudo docker exec -it ros_noetic /bin/bash ``` # 11 RealSense Camera Data Acquisition **Note:** 1. The camera driver starts automatically at power-on. Disable camera driver auto-start before acquiring camera data to prevent interference. (Supported in main controller software V2.0.33 or later.) 2. Disabling camera driver auto-start will prevent the provided data acquisition kit from functioning. ## 11.1 Disable Camera Auto-Start 1. Enter `10.192.1.2:8080` in a web browser to access the interface:  2. Set to disable and save:  ## 11.2 Camera Data Acquisition 1. **Log in to the Developer Computer：** * Please follow the procedures described in the *“Developer Computer”* section to log in to the computer 2. **Launch the Realsense ROS Node to Acquire Camera Data：** * launch instructions address: