| 
|
##### 3.4.14.2.1 请求：request_set_ub_manip_ee_pose
```json
{
"accid": "HU_D04_01_001",
"title": "request_set_ub_manip_ee_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 参考坐标系定义：
# 原点：base_link坐标系
# 方向：x方向对齐机器人正前方，y方向朝向机器人左侧，z方向竖直向上
#
# 参数定义：
# 头相对于参考坐标系的姿态，四元数[x,y,z,w]
"head_quat": [0.0, 0.0, 0.0, 1.0],
# 左手相对于参考坐标系的位置，单位为米
"left_hand_pos": [0.0, 0.0, 0.0],
# 左手相对于参考坐标系的姿态，四元数[x,y,z,w]
"left_hand_quat": [0.0, 0.0, 0.0, 1.0],
# 右手相对于参考坐标系的位置，单位为米
"right_hand_pos": [0.0, 0.0, 0.0],
# 右手相对于参考坐标系的姿态，四元数[x,y,z,w]
"right_hand_quat": [0.0, 0.0, 0.0, 1.0]
}
}
```
##### 3.4.14.2.2 响应：response_set_ub_manip_ee_pose
```json
{
"accid": "HU_D04_01_001",
"title": "response_set_ub_manip_ee_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 成功, fail_motor: 电机错误, fail_invalid_cmd: 非法指令
}
}
```
##### 3.4.14.2.3 消息推送：无
#### 3.4.14.3 获取移动操作位姿信息
##### 3.4.14.3.1 请求：request_get_ub_manip_ee_pose
```json
{
"accid": "HU_D04_01_001",
"title": "request_get_ub_manip_ee_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
}
}
```
##### 3.4.14.3.2 响应：response_get_ub_manip_ee_pose
```json
{
"accid": "HU_D04_01_001",
"title": "response_get_ub_manip_ee_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 参考坐标系定义：
# 原点：base_link坐标系
# 方向：x方向对齐机器人正前方，y方向朝向机器人左侧，z方向竖直向上
#
# 参数定义：
# 头相对于参考坐标系的位置，单位为米
"head_pos": [0.0, 0.0, 0.0],
# 头相对于参考坐标系的姿态，四元数[x,y,z,w]
"head_quat": [0.0, 0.0, 0.0, 1.0],
# 左手相对于参考坐标系的位置，单位为米
"left_hand_pos": [0.0, 0.0, 0.0],
# 左手相对于参考坐标系的姿态，四元数[x,y,z,w]
"left_hand_quat": [0.0, 0.0, 0.0,1.0],
# 右手相对于参考坐标系的位置，单位为米
"right_hand_pos": [0.0, 0.0, 0.0],
# 右手相对于参考坐标系的姿态，四元数[x,y,z,w]
"right_hand_quat": [0.0, 0.0, 0.0,1.0],
"result": "success" # success: 成功, fail_motor: 电机错误, fail_invalid_cmd: 非法指令
}
}
```
### 3.4.15 机器人原地操作
#### 3.4.15.1 进入原地操作模式
原地操作模式下，您可控制机器人的身体运动，但无法操控其行走功能。
##### 3.4.15.1.1 请求：request_set_wb_manip_mode
```json
{
"accid": "HU_D04_01_001",
"title": "request_set_wb_manip_mode",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"mode": 0 # 0: 准备进入模式 1: 操作模式，开始跟踪末端位置 2: 准备退出模式
}
}
```
##### 3.4.15.1.2 响应：response_set_wb_manip_mode
```json
{
"accid": "HU_D04_01_001",
"title": "response_set_wb_manip_mode",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 成功, fail_motor: 电机错误
}
}
```
##### 3.4.15.1.3 消息推送：无
#### 3.4.15.2 原地操作控制
需要通过协议接口 `request_set_wb_manip_mode`，mode 为 1 进入原地操作模式下，功能才生效。
- **参考坐标系示意图：**
- 位置 —— left_ankle_roll_link 与 right_ankle_roll_link 原点连线的中点
- 姿态 —— yaw方向为 left_ankle_roll_link 与 right_ankle_roll_link 转向的中间值
- 坐标轴定义：红色为x方向：由机器人双脚朝向决定；绿色为y方向：可根据右手坐标系规则确定；蓝色为z方向：竖直朝上。
| | |
| --- | --- |
| 
| 
|
##### 3.4.15.2.1 请求：request_set_wb_manip_ee_pose
```json
{
"accid": "HU_D04_01_001",
"title": "request_set_wb_manip_ee_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 参考坐标系定义：
# 原点：为左脚以及右脚的中心位置在地面上的投影（z=0)
# 方向：x方向对齐机器人正前方，y方向朝向机器人左侧，z方向竖直向上
#
# 参数定义：
# 左手相对于参考坐标系的位置，单位为米
"left_hand_pos": [0.0, 0.3, 0.8],
# 左手相对于参考坐标系的姿态，四元数[x,y,z,w]
"left_hand_quat": [0.0, 0.0, 0.0, 1.0],
# 右手相对于参考坐标系的位置，单位为米
"right_hand_pos": [0.0, -0.3, 0.8],
# 右手相对于参考坐标系的姿态，四元数[x,y,z,w]
"right_hand_quat": [0.0, 0.0, 0.0, 1.0]
}
}
```
##### 3.4.15.2.2 响应：response_set_wb_manip_ee_pose
```json
{
"accid": "HU_D04_01_001",
"title": "response_set_wb_ee_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 成功, fail_motor: 电机错误, fail_invalid_cmd: 非法指令
}
}
```
##### 3.4.15.2.3 消息推送：无
#### 3.4.15.3 获取原地操作位姿信息
##### 3.4.15.3.1 请求：request_get_wb_manip_ee_pose
```json
{
"accid": "HU_D04_01_001",
"title": "request_get_wb_manip_ee_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
}
}
```
##### 3.4.15.3.2 响应：response_get_wb_manip_ee_pose
```json
{
"accid": "HU_D04_01_001",
"title": "response_get_wb_manip_ee_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 参考坐标系定义：
# 原点：为左脚以及右脚的中心位置在地面上的投影（z=0)
# 方向：x方向对齐机器人正前方，y方向朝向机器人左侧，z方向竖直向上
#
# 参数定义：
# 左手相对于参考坐标系的位置，单位为米
"left_hand_pos": [0.0, 0.0, 0.0],
# 左手相对于参考坐标系的姿态，四元数[x,y,z,w]
"left_hand_quat": [0.0, 0.0, 0.0, 1.0],
# 右手相对于参考坐标系的位置，单位为米
"right_hand_pos": [0.0, 0.0, 0.0],
# 右手相对于参考坐标系的姿态，四元数[x,y,z,w]
"right_hand_quat": [0.0, 0.0, 0.0, 1.0],
"result": "success" # success: 成功, fail_motor: 电机错误, fail_invalid_cmd: 非法指令
}
}
```
##### 3.4.15.3.3 消息推送：无
### 3.4.16 双臂协同 Move 控制
#### 3.4.16.1 切换 Move 控制模式
##### 3.4.16.1.1 请求：request_set_move_mode
```json
{
"accid": "HU_D04_01_001",
"title": "request_set_move_mode",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 0: 退出Move控制
# 1: 移动Move模式
# 2: 原地Move模式
"mode": 0
}
}
```
##### 3.4.16.1.2 响应：response_set_move_mode
```json
{
"accid": "HU_D04_01_001",
"title": "response_set_move_mode",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 成功, fail_motor: 电机错误
}
}
```
##### 3.4.16.1.3 消息推送：无
#### 3.4.16.2 MoveJ 控制指令
##### 3.4.16.2.1 请求：request_moveJ
```python
{
"accid": "HU_D04_01_001",
"title": "request_moveJ",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 各关节位置范围根据对应型号机器人URDF获取
# 模型文件下载地址：https://github.com/limxdynamics/humanoid-description
# 如您同时给出以下数据，则会控制双臂运动(目标位置，单位弧度)
# 左臂关节顺序：
# - "left_shoulder_pitch_joint"
# - "left_shoulder_roll_joint"
# - "left_shoulder_yaw_joint"
# - "left_elbow_joint"
# - "left_wrist_yaw_joint"
# - "left_wrist_pitch_joint"
# - "left_wrist_roll_joint"
"left": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
# 右臂关节顺序：
# - "right_shoulder_pitch_joint"
# - "right_shoulder_roll_joint"
# - "right_shoulder_yaw_joint"
# - "right_elbow_joint"
# - "right_wrist_yaw_joint"
# - "right_wrist_pitch_joint"
# - "right_wrist_roll_joint"
"right": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
# 仅在原地MoveJ可控，如您同时给出以下数据，则会控制躯干姿态
"torso_height": 0, # 调整身高比例值，取值范围[-1, 1]
"torso_pitch": 0, # Pitch方向运动比例值，取值范围[-1, 1]
"torso_roll": 0, # Roll方向运动比例值，取值范围[-1, 1]
"torso_yaw": 0, # Yaw方向运动比例值，取值范围[-1, 1]
# 如您同时给出以下数据，则会控制头运动
"head_pitch": 0.0, # pitch 关节的目标位置，单位为弧度
"head_yaw": 0.0, # yaw 关节的目标位置，单位为弧度
"speed": 0.2 # 运动速度，取值范围为 0 到 0.5 弧度 / 秒，控制双臂运动的快慢
}
}
```
##### 3.4.16.2.2 响应：response_moveJ
```python
{
"accid": "HU_D04_01_001",
"title": "response_moveJ",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 成功, fail_motor: 电机错误
}
}
```
##### 3.4.16.2.3 消息推送：notify_moveJ
执行完成或失败，主动推送此消息。
```python
{
"accid": "HU_D04_01_001",
"title": "notify_moveJ",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 执行完成， fail_motor: 电机错误， fail_invalid_speed: 非法速度值
}
}
```
#### 3.4.16.3 MoveP 控制指令
- **参考坐标系示意图：**
- 位置 —— waist_pitch_link 的原点
- 坐标轴定义：红色为x方向：机器人前进方向；绿色为y方向：正方向向左；蓝色为z方向：竖直朝上
| | |
| --- | --- |
| 
| 
|
##### 3.4.16.3.1 请求：request_moveP
```python
{
"accid": "HU_D04_01_001",
"title": "request_moveP",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 如您同时给出以下数据，则会控制双臂运动
"left_position": [0.0, 0.0, 0.0], # 表示左臂末端要移动到的目标位置，单位为米，顺序为 x, y, z
"left_quat": [0.0, 0.0, 0.0, 1.0], # 用四元数（x, y, z, w）表示左臂末端的目标姿态
"right_position": [0.0, 0.0, 0.0], # 表示右臂末端要移动到的目标位置，单位为米，顺序为 x, y, z
"right_quat": [0.0, 0.0, 0.0, 1.0], # 用四元数（x, y, z, w）表示右臂末端的目标姿态
# 仅在原地MoveP可控，如您同时给出以下数据，则会控制躯干姿态
"torso_height": 0, # 调整身高比例值，取值范围[-1, 1]
"torso_pitch": 0, # Pitch方向运动比例值，取值范围[-1, 1]
"torso_roll": 0, # Roll方向运动比例值，取值范围[-1, 1]
"torso_yaw": 0, # Yaw方向运动比例值，取值范围[-1, 1]
# 如您同时给出以下数据，则会控制头运动
"head_pitch": 0.0, # pitch 关节的目标位置，单位为弧度
"head_yaw": 0.0, # yaw 关节的目标位置，单位为弧度
"speed": 0.2 # 运动速度，取值范围为 0 到 0.5 弧度 / 秒，控制双臂运动的快慢
}
}
```
##### 3.4.16.3.2 响应：response_moveP
```python
{
"accid": "HU_D04_01_001",
"title": "response_moveP",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 成功, fail_motor: 电机错误
}
}
```
##### 3.4.16.3.3 消息推送：notify_moveP
执行完成或失败，主动推送此消息。
```python
{
"accid": "HU_D04_01_001",
"title": "notify_moveP",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 执行完成， fail_motor: 电机错误， fail_invalid_speed: 非法速度值
}
}
```
#### 3.4.16.4 获取双臂末端位姿
##### 3.4.16.4.1 请求：request_get_move_pose
通过此接口获取机器人双臂的末端位姿信息。
```json
{
"accid": "HU_D04_01_001",
"title": "request_get_move_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {}
}
```
##### 3.4.16.4.2 响应：response_get_move_pose
接收到请求后，返回双臂当前位姿的相关信息。
```
{
"accid": "HU_D04_01_001",
"title": "response_get_move_pose",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"timestamp": 1672373633989, # 表示数据时戳，单位为毫秒
"left_position": [0.0, 0.0, 0.0], # 表示左臂末端的位置，单位为米，顺序为 x, y, z
"left_quat": [0.0, 0.0, 0.0, 1.0], # 表示左臂末端的姿态，以四元数表示，顺序为 x, y, z, w
"right_position": [0.0, 0.0, 0.0], # 表示右臂末端的位置，单位为米，顺序为 x, y, z
"right_quat": [0.0, 0.0, 0.0, 1.0], # 表示右臂末端的姿态，以四元数表示，顺序为 x, y, z, w
"result": "success" # fail_not_data
}
}
```
### 3.4.17 双臂协同 Servo 控制
#### 3.4.17.1 切换 Servo 控制模式
##### 3.4.17.1.1 请求：request_set_servo_mode
```json
{
"accid": "HU_D04_01_001",
"title": "request_set_servo_mode",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 0: 退出Servo控制
# 1: 移动Servo模式
# 2: 原地Servo模式
"mode": 0
}
}
```
##### 3.4.17.1.2 响应：response_set_servo_mode
```json
{
"accid": "HU_D04_01_001",
"title": "response_set_servo_mode",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "success" # success: 成功, fail_motor: 电机错误
}
}
```
##### 3.4.17.1.3 消息推送：无
#### 3.4.17.2 ServoJ 控制指令
##### 3.4.17.2.1 请求：request_servoJ
- 推荐在实时系统中按控制频率 >= 500Hz 要求来控制机械臂运动，以保证控制效果和稳定性。
```json
{
"accid": "HU_D04_01_001",
"title": "request_servoJ",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
# 各关节位置范围根据对应型号机器人URDF获取
# 模型文件下载地址：https://github.com/limxdynamics/humanoid-description
# 如您同时给出以下数据，则会控制双臂运动(目标位置，单位弧度)
# 左臂关节顺序：
# - "left_shoulder_pitch_joint"
# - "left_shoulder_roll_joint"
# - "left_shoulder_yaw_joint"
# - "left_elbow_joint"
# - "left_wrist_yaw_joint"
# - "left_wrist_pitch_joint"
# - "left_wrist_roll_joint"
"left": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
# 右臂关节顺序：
# - "right_shoulder_pitch_joint"
# - "right_shoulder_roll_joint"
# - "right_shoulder_yaw_joint"
# - "right_elbow_joint"
# - "right_wrist_yaw_joint"
# - "right_wrist_pitch_joint"
# - "right_wrist_roll_joint"
"right": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
# 仅在原地ServoJ可控，如您同时给出以下数据，则会控制躯干姿态
"torso_height": 0, # 调整身高比例值，取值范围[-1, 1]
"torso_pitch": 0, # Pitch方向运动比例值，取值范围[-1, 1]
"torso_roll": 0, # Roll方向运动比例值，取值范围[-1, 1]
"torso_yaw": 0, # Yaw方向运动比例值，取值范围[-1, 1]
# 如您同时给出以下数据，则会控制头运动
"head_yaw": 0.0, # yaw 关节的目标位置，单位为弧度
"head_pitch": 0.0 # picth 关节的目标位置，单位为弧度
}
}
```
##### 3.4.17.2.2 响应：无
##### 3.4.17.2.3 消息推送：notify_servoJ
当 ServoJ 控制操作执行失败时，服务器会主动推送此消息，告知客户端失败原因。
```json
{
"accid": "HU_D04_01_001",
"title": "notify_servoJ",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {
"result": "fail_invalid_cmd" # fail_invalid_cmd: 非法指令， fail_motor: 电机错误
}
}
```
#### 3.4.17.3 ServoP 控制指令
- **参考坐标系示意图：**
- 位置 —— waist_pitch_link 的原点
- 坐标轴定义：红色为x方向：机器人前进方向；绿色为y方向：正方向向左；蓝色为z方向：竖直朝上。
Dual ARM Commands
Type a command and press Enter.
``` # 4 底层运动控制开发接口 **跨平台底层运动控制开发接口库**提供统一的 C++/Python API，兼容 ROS1、ROS2 及非 ROS 系统，实现运动控制算法的快速移植与部署。通过硬件抽象层和标准化通信协议，开发者可无缝切换仿真与真实硬件环境，显著降低多平台适配成本。 > **注意：** > > 1. 使用底层控制开发接口时，需通过按键 `R1+START` 切换**开发者模式**，此时高层开发接口会被禁用，机器人只响应上下电和校零遥控器指令。 > 2. 底层接口代码调用示例可参考 RL 部署训练。 > 3. 切换到开发者模式后，掉电模式会保留，退出开发者模式按键：`L2+○` ## 4.1 C++ 运动控制开发接口 ### 4.1.1 getInstance 接口 | 函数名 | getInstance | | -------- | -------------------------------------------------------- | | 函数原型 | static Humanoid* getInstance(); | | 功能概述 | 获取 Humanoid 机器人类单例实例的指针 | | 参数 | 无 | | 返回值 | Humanoid*，指向 Humanoid 实例的指针 | | 备注 | 使用了单例模式，确保 Humanoid 类只有一个实例存在于程序中 | 代码示例： ```cpp #include失败：返回False | | 备注 | 无 | **代码示例**： ```python import sys import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType if __name__ == '__main__': # 创建一个类型为Humanoid的Robot实例 robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # 检查是否提供了命令行参数作为机器人IP if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用IP地址初始化机器人的通信运行环境 if not robot.init(robot_ip): sys.exit() ``` ### 4.2.4 getMotorNumber 接口 | 函数名 | getMotorNumber | | -------- | ------------------------------------------------ | | 函数原型 | def getMotorNumber(self) | | 功能概述 | 获取机器人中的电机数量。 | | 参数 | 无 | | 返回值 | 返回一个无符号整数，表示机器人中的总电机数量。 | | 备注 | 通常情况下，点足机器人的电机数量为6个 | **代码示例**： ```python import sys import limxsdk.robot.Robot as Robot import limxsdk.robot.RobotType as RobotType if __name__ == '__main__': # 创建一个 Humanoid 类型的 Robot 实例 robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # 检查是否提供了机器人 IP 的命令行参数 if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用 robot_ip 初始化机器人 if not robot.init(robot_ip): sys.exit() # 获取机器人中的电机数量 motor_number = robot.getMotorNumber() ``` ### 4.2.5 subscribeImuData 接口 | 函数名 | subscribeImuData | | -------- | ---------------------------------------------------------------- | | 函数原型 | def subscribeImuData(self, callback: Callable[[datatypes.ImuData], Any]) | | 功能概述 | 订阅机器人的 IMU数据，并在接收到新的 IMU 数据时调用指定的回调函数。 | | 参数 | callback：用于处理新 IMU 数据的回调函数。 | | 返回值 | 成功：返回True
失败：返回False | **备注**：datatypes.ImuData 数据结构原型如下： ```python import sys class ImuData(object): __slots__ = ['stamp','acc','gyro','quat'] def __init__(self): self.stamp = 0 # 时间戳，通常表示记录或生成这些数据的时间，以纳秒为单位 self.acc = [0. for x in range(0, 3)] # 用于存储 IMU（惯性测量单元）加速度计数据，用于跟踪三个轴上的线性加速度 self.gyro = [0. for x in range(0, 3)] # 用于存储 IMU 陀螺仪数据，用于跟踪角速度或旋转速度 self.quat = [0. for x in range(0, 4)] # 用于存储 IMU 四元数数据，表示在三维空间中的方向 ``` **代码示例**： ```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: # 订阅机器人的 IMU数据 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__': # 创建一个 Robot 实例，类型为 Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # 检查是否提供了机器人 IP 的命令行参数 if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用 robot_ip 初始化机器人 if not robot.init(robot_ip): sys.exit() # 创建一个 RobotReceiver 实例来处理回调 receiver = RobotReceiver() # 创建回调函数的 partial 函数 imuDataCallback = partial(receiver.imuDataCallback) # 订阅机器人IMU数据 robot.subscribeImuData(imuDataCallback) ``` ### 4.2.6 subscribeRobotState 接口 | 函数名 | subscribeRobotState | | -------- | ---------------------------------------------------------------- | | 函数原型 | def subscribeRobotState(self, callback: Callable[[datatypes.RobotState], Any]) | | 功能概述 | 订阅接收关于机器人状态的更新。 | | 参数 | callback：回调函数，当接收到机器人状态更新时将被调用。回调函数参数指向datatypes.RobotState 对象。
- datatypes.RobotState数据结构字段：
- stamp：时间戳，通常表示记录或生成这些数据的时间。
- tau：用于存储当前估计的输出扭矩（以牛顿米为单位）的向量。
- q：用于存储当前角度（以弧度为单位）的向量。
- dq：用于存储当前速度（以弧度每秒为单位）的向量。
- motor_names：用于存储对应的关节名称。 | | 返回值 | 成功：返回True
失败：返回False | **备注**：datatypes.RobotState 数据结构原型如下： ```python import sys class RobotState(object): __slots__ = ['stamp','tau','q','dq'] def __init__(self): self.stamp = 0 # 时间戳，通常表示记录或生成这些数据的时间，以纳秒为单位 self.tau = [] # 用于存储当前估计的输出扭矩（以牛顿米为单位）的向量 self.q = [] # 用于存储当前角度（以弧度为单位）的向量 self.dq = [] # 用于存储当前速度（以弧度每秒为单位）的向量 self.motor_names = [] # 用于存储对应的关节名称。 ``` **代码示例**： ```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: # 用于接收机器人状态的回调函数 def robotStateCallback(self, robot_state: datatypes.RobotState): print(" ------ robot_state:" + \ " stamp: " + str(robot_state.stamp) + \ " tau: " + str(robot_state.tau) + \ " q: " + str(robot_state.q) + \ " dq: " + str(robot_state.dq)) if __name__ == '__main__': # 创建一个 Robot 实例，类型为 Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # 检查是否提供了机器人 IP 的命令行参数 if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用 robot_ip 初始化机器人 if not robot.init(robot_ip): sys.exit() # 创建一个 RobotReceiver 实例来处理回调 receiver = RobotReceiver() # 创建回调函数的 partial 函数 robotStateCallback = partial(receiver.robotStateCallback) # 订阅机器人状态 robot.subscribeRobotState(robotStateCallback) ``` ### 4.2.7 publishRobotCmd 接口 | 函数名 | publishRobotCmd | | -------- | ------------------------------------------------------------ | | 函数原型 | def publishRobotCmd (self, cmd: datatypes.RobotCmd) | | 功能概述 | 发布一个命令来控制机器人的动作。 | | 参数 | cmd：表示所需机器人命令的 datatypes.RobotCmd 对象，包含以下字段：
- stamp：记录或生成数据时的时间戳，以纳秒为单位。
- q：存储所需的关节角度（以弧度为单位）的向量。
- dq：存储所需的关节速度（以弧度每秒为单位）的向量。
- tau：存储所需的输出扭矩（以牛顿米为单位）的向量。
- Kp：存储所需的位置刚度（以牛顿米每弧度为单位）的向量。
- Kd：存储所需的速度刚度（以牛顿米每弧度每秒为单位）的向量。
- motor_names：存储需要控制的关节名称。 | | 参数取值 | - q、dq、tau：在urdf中已定义范围，举例如下：
- joint的
- lower和upper共同对应"q"，表示控制位置范围（单位为弧度）；
- effort对应"tau"，表示扭矩峰值（单位为牛顿米）；
- velocity对应"dq"，表示速度峰值（单位为弧度每秒）；
- Kp、Kd可用值（用户自行开发控制器时需根据实际效果调整取值）： | | 返回值 | 成功：返回True
失败：返回False | **备注**：datatypes.RobotCmd 数据结构原型如下： ```python import sys class RobotCmd(object): __slots__ = ['stamp','mode','q','dq','tau','Kp','Kd'] def __init__(self): self.stamp = 0 # 时间戳（以纳秒为单位），表示记录或生成数据时的时间。 self.mode = [] # 机器人的期望工作模式。 self.q = [] # 存储期望角度的向量（以弧度为单位） self.dq = [] # 存储期望速度的向量（以弧度每秒为单位）。 self.tau = [] # 存储期望输出扭矩的向量（以牛顿米为单位）。 self.Kp = [] # 存储期望位置刚度的向量（以牛顿米每弧度为单位）。 self.Kd = [] # 存储期望速度刚度的向量（以牛顿米每弧度每秒为单位）。 self.motor_names = [] # 存储需要控制的关节名称。 ``` **代码示例**： ```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__': # 创建一个 Robot 实例，类型为 Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # 检查是否提供了机器人 IP 的命令行参数 if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用 robot_ip 初始化机器人 if not robot.init(robot_ip): sys.exit() # 获取关节偏移、关节限制和电机数量信息 joint_offset = robot.getJointOffset() joint_limit = robot.getJointLimit() motor_number = robot.getMotorNumber() # 主循环以连续发布机器人命令 rate = Rate(500) # 1500 Hz cmd_msg = datatypes.RobotCmd() while True: # 设置时间戳、控制模式、关节位置、速度、力矩、Kp 和 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) # 发布机器人命令 rate.sleep() # 控制循环频率 ``` ### 4.2.8 subscribeSensorJoy 接口 | 函数名 | subscribeSensorJoy | | -------- | ------------------------------------------------------------ | | 函数原型 | def subscribeSensorJoy(self, callback: Callable[[datatypes.SensorJoy], Any]) | | 功能概述 | 在真机部署中，该方法用于订阅来自机器人遥控器的数据。当机器人接收到遥控器的数据时，将会调用指定的回调函数，并传递包含遥控器数据的 datatypes.SensorJoy 结构体常量指针给回调函数进行处理。 | | 参数 | callback: 表示回调函数，用于接收机器人遥控器的数据。回调函数的参数类型为 datatypes.SensorJoy | | 返回值 | 成功：返回True
失败：返回False | **备注**: datatypes.SensorJoy 数据结构原型如下： ```python import sys class SensorJoy(object): __slots__ = ['stamp','axes','buttons'] def __init__(self): self.stamp = 0 # 与传感器输入相关的时间戳，单位为纳秒。 self.axes = [] # 表示操纵摇杆的值。 self.buttons = [] # 表示操纵按钮状态的值。 ``` **代码示例**： ```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: # 用于接收遥控器数据的回调函数 def sensorJoyCallback(self, sensor_joy: datatypes.SensorJoy): print(" ------ sensor_joy:" + \ " stamp: " + str(sensor_joy.stamp) + \ " axes: " + str(sensor_joy.axes) + \ " buttons: " + str(sensor_joy.buttons)) if __name__ == '__main__': # 创建一个 Robot 实例，类型为 Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # 检查是否提供了机器人 IP 的命令行参数 if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用 robot_ip 初始化机器人 if not robot.init(robot_ip): sys.exit() # 创建一个 RobotReceiver 实例来处理回调 receiver = RobotReceiver() # 创建回调函数的 partial 函数 sensorJoyCallback = partial(receiver.sensorJoyCallback) # 订阅机器人遥控数据 robot.subscribeSensorJoy(sensorJoyCallback) ``` ### 4.2.9 subscribeDiagnosticValue 接口 | 函数名 | subscribeDiagnosticValue | | -------- | ------------------------------------------------------------ | | 函数原型 | def subscribeDiagnosticValue(self, callback: Callable[[datatypes.DiagnosticValue], Any]) | | 功能概述 | 在真机部署中，该方法用于订阅机器人的诊断值和状态信息。当机器人发出诊断值时，系统会调用指定的回调函数，并传递包含诊断值的 datatypes.DiagnosticValue 结构对象给回调函数进行处理。这可以帮助实时监控机器人的健康状态，并及时做出反应以处理可能的问题。 | | 参数 | callback: 用于接收机器人诊断值的回调函数，其参数类型为 datatypes.DiagnosticValue。datatypes.DiagnosticValue 结构体包含了机器人诊断值的信息，包括时间戳、级别、名称、代码和消息字段。 | | 返回值 | 成功：返回True
失败：返回False | **备注**: datatypes.DiagnosticValue 数据结构原型如下： ```python import sys class DiagnosticValue(object): __slots__ = ['stamp','level','name','code','message'] def __init__(self): self.stamp = 0 # 时间戳，单位为纳秒。 self.level = 0 # 与诊断值相关联的级别 - 0: OK, 1: WARN, 2: ERROR self.name = '' # 标识诊断值的名称。 self.code = 0 # 与诊断值对应的代码。 self.message = '' # 与诊断值相关的详细消息。 ``` **代码示例**： ```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: # 用于接收诊断值的回调函数 def diagnosticValueCallback(self, diagnostic_value: datatypes.DiagnosticValue): print(" ------ diagnostic_value:" + \ " stamp: " + str(diagnostic_value.stamp) + \ " name: " + diagnostic_value.name + \ " level: " + str(diagnostic_value.level) + \ " code: " + str(diagnostic_value.code) + \ " message: " + diagnostic_value.message) if __name__ == '__main__': # 创建一个 Robot 实例，类型为 Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "127.0.0.1" # 检查是否提供了机器人 IP 的命令行参数 if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用 robot_ip 初始化机器人 if not robot.init(robot_ip): sys.exit() # 创建一个 RobotReceiver 实例来处理回调 receiver = RobotReceiver() # 创建回调函数的 partial 函数 diagnosticValueCallback = partial(receiver.diagnosticValueCallback) # 订阅机器人诊断信息 robot.subscribeDiagnosticValue(diagnosticValueCallback) ``` ### 4.2.10 publishJsonMessage 接口 | 函数名 | publishJsonMessage | | -------- | ------------------------------------------------------------ | | 函数原型 | def publishJsonMessage(self, json_payload: str) | | 功能概述 | 向机器人发送 "上层应用协议接口" 的 JSON 格式消息。 | | 参数 | json_payload: 符合 "上层应用协议接口" 协议的 JSON 字符串。
示例：{"accid": "xxx", "title": "request_xxx", "timestamp": xxx, "guid": "xxx", "data": {}} | | 返回值 | 无 | | 备注 | 高阶开发模式下有效 | **代码示例**： ```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__': # 创建一个 Robot 实例，类型为 Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "10.192.1.2" # 检查是否提供了机器人 IP 的命令行参数 if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用 robot_ip 初始化机器人 if not robot.init(robot_ip): sys.exit() # 设置要发送的协议内容 json_payload = '''{ "accid": "HU_D03_01", # 替换为真实机器人SN "title": "request_get_joint_state", "timestamp": 1672373633989, "guid": "746d937cd8094f6a98c9577aaf213d98", "data": {} }''' # 发送JSON协议 robot.publishJsonMessage(json_payload) # 保持程序运行 try: while True: time.sleep(1) except KeyboardInterrupt: print("程序被用户中断") ``` ### 4.2.11 subscribeJsonMessage 接口 | 函数名 | subscribeJsonMessage | | -------- | ------------------------------------------------------------ | | 函数原型 | def subscribeJsonMessage(self, callback: Callable[[str], Any]) | | 功能概述 | 注册一个回调函数，用于处理来自机器人的 "上层应用协议接口" 调用的响应和通知。
该回调函数会在以下两种场景中被调用：
1. 当机器人对之前发送的 JSON 命令（publishJsonMessage）返回响应时
2. 当机器人主动发起通知（未经请求的消息）时 | | 参数 | callback: 回调函数, 其中 json_payload 包含：
- 命令响应：{"accid": "xxx", "title": "response_xxx", "timestamp": xxx, "guid": "xxx", "data": {}}
- 通知：{"accid": "xxx", "title": "notify_xxx", "timestamp": xxx, "guid": "xxx", "data": {}} | | 返回值 | 无 | | 备注 | 高阶开发模式下有效 | **代码示例**： ```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: # 处理来自机器人的 "上层应用协议接口" 调用的响应和通知 def jsonMessageCallback(self, json_payload: str): print(" ------ json_payload:" + json_payload) if __name__ == '__main__': # 创建一个 Robot 实例，类型为 Humanoid robot = Robot(RobotType.Humanoid) robot_ip = "10.192.1.2" # 检查是否提供了机器人 IP 的命令行参数 if len(sys.argv) > 1: robot_ip = sys.argv[1] # 使用 robot_ip 初始化机器人 if not robot.init(robot_ip): sys.exit() # 创建一个 RobotReceiver 实例来处理回调 receiver = RobotReceiver() # 创建回调函数的 partial 函数 jsonMessageCallback = partial(receiver.jsonMessageCallback) # 订阅机器人遥控数据 robot.subscribeJsonMessage(jsonMessageCallback) ``` ### 4.2.12 参考例程 Github: https://github.com/limxdynamics/humanoid-rl-deploy-python # 5 查看/设置机器人型号 在编译和运行RL训练、控制算法及仿真器程序时，选择正确的机器人型号至关重要。通过查看机器人型号并将其设置到环境变量 `ROBOT_TYPE` 中，确保在不同任务中准确识别并应用相应的机器人模型。 **查看和配置机器人型号步骤：** 1. 选择并连接您机器人Wi-Fi 热点，密码为：`12345678`  1. 在浏览器中输入`http://10.192.1.2:8080`进入“机器人信息页”，查看机器人信息。如下图所示，页面中显示的SN (序列号) 为HU_D03_03_001，其中HU_D03_03为机器人型号。  1. 设置机器人型号：打开 Bash 终端，输入以下 Shell 命令来设置机器人型号。这样在二次开发时，您将能获取到正确的机器人型号信息。 ```bash echo 'export ROBOT_TYPE=HU_D03_03' >> ~/.bashrc && source ~/.bashrc ``` # 6 机器人仿真器 MuJoCo 是一款轻量级且高性能的物理仿真器，专为多关节机器人和机械系统设计。它具备高效的物理引擎，能够精确处理接触和摩擦，且无需依赖 ROS，可独立运行。凭借其高速计算能力，MuJoCo 被广泛应用于机器人仿真和强化学习，尤其适合对仿真效率要求较高的场景。 ## 6.1 运行仿真器步骤 1. 运行环境：推荐 Pyhon 3.8 及以上版本 2. 打开一个 Bash 终端。 3. 下载 MuJoCo 仿真器代码： ```bash git clone --recurse git@github.com:limxdynamics/humanoid-mujoco-sim.git ``` 4. 安装运动控制开发库： - Linux x86_64 环境 ```bash pip install humanoid-mujoco-sim/limxsdk-lowlevel/python3/amd64/limxsdk-*-py3-none-any.whl ``` - Linux aarch64 环境 ```bash pip install humanoid-mujoco-sim/limxsdk-lowlevel/python3/aarch64/limxsdk-*-py3-none-any.whl ``` 1. 设置机器人型号：请参考"查看/设置机器人型号"章节，查看您的机器人型号。如果尚未设置，请按照以下步骤进行设置。 - 通过 Shell 命令 `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 ``` - 以`HU_D04_01`（请根据实际机器人类型进行替换）为例，设置机器人型号类型： ```bash echo 'export ROBOT_TYPE=HU_D04_01' >> ~/.bashrc && source ~/.bashrc ``` 1. 运行 MuJoCo 仿真器： ```bash python humanoid-mujoco-sim/simulator.py ``` ## 6.2 演示效果(请以实际为准)  # 7 RL 算法部署 ## 7.1 基于标准C++进行部署 Github项目地址：https://github.com/limxdynamics/humanoid-rl-deploy-cpp，它是一个在标准C++中实现的轻量级算法框架。无需 ROS1/ROS2 即可快速部署训练的模型。 ## 7.2 基于Python进行部署 Github项目地址：https://github.com/limxdynamics/humanoid-rl-deploy-python，它是一种基于Python的强化学习部署算法框架，它简化了在Oli机器人上部署训练模型的过程。 ## 7.3 基于ROS2 进行部署 Github项目地址：https://github.com/limxdynamics/humanoid-rl-deploy-ros2，它是基于 [ROS2](https://www.ros.org) 的强化学习部署框架，可在 Oli 机器人上快速部署经过训练的模型。 ## 7.4 基于ROS1 进行部署 Github项目地址：https://github.com/limxdynamics/humanoid-rl-deploy-ros，它是基于[ROS1](https://www.ros.org)的强化学习部署框架，可以在Oli机器人上快速部署经过训练的模型。 # 8 日志和数据包 - **机器人系统自动录制数据：** IMU数据(ImuData)、状态数据（/joint/state）、控制数据（/joint/cmd）、运行日志数据等重要数据，这些数据对于机器人的运动控制分析至关重要。 - **访问并下载机器人数据：** 机器人将会记录运行时的日志数据，以便在需要时进行故障排查和性能优化，电脑与机器人 WiFi 热点连接后浏览器输入 `http://10.192.1.2:8090`，可自行选择下载所需数据。 ## 8.1 数据包可视化分析方法 - **数据包下载：** 下载 `.bag` 文件后，可以使用PlotJuggler可视化工具加载这些数据包进行分析。需要特别注意的是，如果下载的是 `.bag.active` 文件，需要使用如下Shell命令把它重新索引 `.bag.active` 文件，生成一个新的 `.bag` 文件，以便PlotJuggler加载。 ```bash rosbag reindex your_file.bag.active mv your_file.bag.active your_file.bag ``` - **可视化查看：** 通过Shell命令 `rosrun plotjuggler plotjuggler -n` 启动PlotJuggler可视化工具。如下图所示加载数据包进行可视化分析。 ## 8.2 日志及诊断埋点数据 如下图所示分别为日志和埋点结构化数据。在需要时可以用于故障排查和性能优化。  # 9 机器人软件升级 软件升级注意事项： 1. 请确保设备电量不低于 30%。升级过程中如发生断电，可能导致设备无法正常使用 2. 请提前将机器人切换至零力矩模式或阻尼模式。升级完成后设备将自动重启，若机器人处于站立状态,可能存在跌倒风险。 通过浏览器进入机器人管理页面,选择本地提前下载好的机器人软件版本进行升级。具体步骤如下： 1. 连接 Wi-Fi： - 选择并连接机器人的 Wi-Fi 热点，密码为：12345678  2. 访问管理页面： - 在浏览器地址栏输入： `http://10.192.1.2:8080` 进入机器人管理页面。 3. 选择并升级软件： - 依次选择"版本管理 -> 浏览 -> 升级"。 - 升级完成后，机器人主控电脑将自动重启。  # 10 开发者电脑 开发者电脑主要用于开发机器人相关算法及应用程序。可以通过 WiFi 连接机器人本体系统登录到开发者电脑，具体步骤如下： 1. 连接Wi-Fi： - 选择并连接机器人的 Wi-Fi 热点，密码为：12345678  2. 通过 SSH 登录开发者电脑系统： - 登录地址：10.192.1.3 - 登录密码：123456 - 在终端中输入以下命令（首次连接需确认指纹）： ```bash ssh guest@10.192.1.3 ``` - 开发者电脑系统配置： - 操作系统：Ubuntu 22.04 （Jetpack 6.2.1） - ROS2：系统默认安装ROS2 Humble 版本机器人系统 - ROS1：系统默认安装ROS1 Noetic 版本机器人系统Docker，进入方法如下： ```bash sudo docker exec -it ros_noetic /bin/bash ``` # 11 Realsense 相机数据获取 **注意事项：** 1. 机器人开机后默认会自动启动相机驱动。因此，在进行以下操作前，请先关闭相机驱动的自动启动功能。关闭方法请参考下文说明。该功能仅支持主控版本 V2.0.33 及以上。 2. 关闭相机驱动自动启动功能后，我司配套的数据采集套件（数采套件）将无法正常使用。请根据实际需求决定是否执行该操作。 ## 11.1 关闭相机驱动自启动 1. 在浏览器地址栏输入 `http://10.192.1.2:8080`，进入以下界面。  2. 设置关闭并保存。  ## 11.2 获取相机数据 1. 登录开发者电脑： - 请按照“开发者电脑”章节中的步骤登录该电脑。 2. 启动 Realsense 的 ROS 节点以获取相机数据： - 启动方式参考链接：[realsense-ros](https://github.com/IntelRealSense/realsense-ros) - 电脑已预装 Realsense 相机的 SDK： - 版本为 v2.56.3，官方下载链接：[librealsense v2.56.3](https://github.com/IntelRealSense/librealsense/releases/tag/v2.56.3)，可基于此官方 SDK 自主开发应用程序来获取数据。 3. 示例代码说明： - 相机命名规则： - 默认命名：脚本会将多个相机的 topic 前缀命名为 `camera` 加上序号（如 `camera0`、`camera1`）。 - 自定义命名：可通过修改脚本，根据相机的序列号（Serial Number）指定 topic 前缀，而非使用默认的 `camera + counter` 命名规则。 以下代码示例展示了如何获取多个相机的数据： 1. 通过 SSH 登录开发者电脑系统 2. 登录 ROS1 系统 ```bash sudo docker exec -it ros_noetic /bin/bash ``` 3. 将下面的脚本保存为 `rs_camera.sh`： ```bash #!/bin/bash source /opt/ros/noetic/setup.bash # Function to detect connected RealSense cameras detect_cameras() { # List all connected RealSense cameras, excluding Asic Serial Number serial_numbers=($(rs-enumerate-devices | grep "Serial Number" | grep -v "Asic" | awk '{print $NF}')) echo "${serial_numbers[@]}" } # Loop to check for the launch flag file and connected cameras while true; do serial_numbers=($(detect_cameras)) # Check if any cameras were found if [ ${#serial_numbers[@]} -gt 0 ]; then echo "Detected ${#serial_numbers[@]} cameras." break # Exit the loop if cameras are detected else echo "No RealSense cameras detected. Retrying in 5 seconds..." sleep 5 # Wait for a while before retrying fi done # Automatically start a ROS node for each detected camera if [ ${#serial_numbers[@]} -gt 0 ]; then for i in "${!serial_numbers[@]}"; do serial=${serial_numbers[$i]} # Default camera naming using index (camera0, camera1, ...) # Customize camera naming by modifying the code below camera_topic="camera$i" # Example: Custom camera naming based on serial number # Uncomment and replace with your actual serial numbers # if [[ "$serial" == "0123456789" ]]; then # camera_topic="head" # Name specific camera as "head" # elif [[ "$serial" == "9876543210" ]]; then # camera_topic="chest" # Name another camera as "chest" # fi echo "Starting ROS node for camera $serial (topic prefix: $camera_topic)..." roslaunch realsense2_camera rs_camera.launch \ serial_no:=$serial \ camera:=$camera_topic \ enable_pointcloud:=True \ enable_accel:=True \ enable_gyro:=True \ enable_sync:=True \ unite_imu_method:=linear_interpolation & sleep 10 # Optional: wait a bit before starting the next camera done # Wait for all background processes to finish wait else echo "No cameras to start." fi ``` 4. 在终端执行脚本，启动相机节点： ```bash /bin/bash rs_camera.sh ``` 5. 在另一个终端中，通过 `rostopic list` 验证结果： ```bash rostopic list ```