::connection_ptr con = ws_client.get_connection(server_uri, ec); // Get connection pointer
if (ec) {
std::cout << "Error: " << ec.message() << std::endl;
return 1; // Exit if connection error occurs
}
connection_hdl hdl = con->get_handle(); // Get connection handle
ws_client.connect(con); // Connect to server
std::cout << "Press Ctrl+C to exit." << std::endl;
// Run the WebSocket client loop
ws_client.run();
return 0;
}
```
### 3.8.3 JavaScript 示例
- **运行 humanoid.html：** 将 humanoid.html 文件保存到电脑中，然后在浏览器中打开 humanoid.html 运行。
- **humanoid.html 实现**
```html
WebSocket Robot Control
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
// 包含 limxsdk::Humanoid 头文件，用于引入 Humanoid 类
#include "limxsdk/humanoid.h"
// 使用 limxsdk 命名空间，简化对 Humanoid 类的引用
using namespace limxsdk;
int main(int argc, char *argv[]){
// 获取 Humanoid 类的单例实例
Humanoid* robot = Humanoid::getInstance();
// 无限循环以保持程序运行
while (true)
{
// 休眠 1000 毫秒
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.2 init 接口
| 函数名 | init |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| 函数原型 | bool init(const std::string& robot_ip_address = "127.0.0.1"); |
| 功能概述 | 初始化运动控制算法程序的通信运行环境，通常在主函数中调用其它接口之前调用，完成初始化工作。 |
| 参数 | robot_ip_address：机器人的 IP 地址。对于仿真，通常设置为 "127.0.0.1"，而对于真实机器人，可能设置为 "10.192.1.2"。 |
| 返回值 | 如果初始化成功，则返回 true；否则返回 false。 |
| 备注 | 无 |
代码示例：
```cpp
#include
// 包含 limxsdk::Humanoid 头文件，用于引入 Humanoid 类
#include "limxsdk/humanoid.h"
// 使用 limxsdk 命名空间，简化对 Humanoid 类的引用
using namespace limxsdk;
int main(int argc, char *argv[]){
// 获取 Humanoid 类的单例实例
Humanoid* robot = Humanoid::getInstance();
// 默认机器人 IP 地址
std::string robot_ip = "127.0.0.1";
if (argc > 1)
{
// 如果提供了命令行参数，则使用命令行参数作为机器人 IP 地址
robot_ip = argv[1];
}
// 初始化运动控制算法程序的通信运行环境
if (!robot->init(robot_ip))
{
// 如果初始化失败，则退出程序
exit(1);
}
// 无限循环以保持程序运行
while (true)
{
// 休眠 1000 毫秒
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.3 getMotorNumber 接口
| 函数名 | getMotorNumber |
| -------- | ------------------------------------------ |
| 函数原型 | uint32_t getMotorNumber(); |
| 功能概述 | 获取机器人中的电机数量。 |
| 参数 | 无 |
| 返回值 | 返回一个无符号整数，表示机器人中的总电机数量。 |
| 备注 | 无 |
代码示例：
```cpp
#include
// 包含 limxsdk::Humanoid 头文件，用于引入 Humanoid 类
#include "limxsdk/humanoid.h"
// 使用 limxsdk 命名空间，简化对 Humanoid 类的引用
using namespace limxsdk;
int main(int argc, char *argv[]){
// 获取 Humanoid 类的单例实例
Humanoid* robot = Humanoid::getInstance();
// 默认机器人 IP 地址
std::string robot_ip = "127.0.0.1";
if (argc > 1)
{
// 如果提供了命令行参数，则使用命令行参数作为机器人 IP 地址
robot_ip = argv[1];
}
// 初始化运动控制算法程序的通信运行环境
if (!robot->init(robot_ip))
{
// 如果初始化失败，则退出程序
exit(1);
}
// 获取机器人中的电机数量
uint32_t motor_num = robot->getMotorNumber();
// 无限循环以保持程序运行
while (true)
{
// 休眠 1000 毫秒
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.4 subscribeImuData 接口
| 函数名 | subscribeImuData |
| -------- | ---------------------------------------------------------------------- |
| 函数原型 | void subscribeImuData(std::function cb); |
| 功能概述 | 订阅机器人的 IMU数据，并在接收到新的 IMU 数据时调用指定的回调函数。 |
| 参数 | cb: 用于处理新 IMU 数据的回调函数。 |
| 返回值 | 无 |
备注：ImuData 数据结构原型如下：
```cpp
/**
* @struct ImuData
*
* @brief 表示基于传感器反馈的机器人 IMU 数据的结构体。
*
* 此结构体封装了 IMU 数据，包括加速度计、陀螺仪和四元数。
*/
struct ImuData {
uint64_t stamp; // 时间戳，以纳秒为单位，通常表示记录或生成此数据时的时间。
float acc[3]; // 用于存储 IMU 加速度计数据，以跟踪沿三个轴（X、Y、Z）的线性加速度。
float gyro[3]; // 用于存储 IMU 陀螺仪数据，以跟踪沿三个轴（X、Y、Z）的角速度或旋转速度。
float quat[4]; // 用于存储 IMU 四元数数据，表示在三维空间中的方向（w、x、y、z）。
};
// 智能指针类型别名
typedef std::shared_ptr ImuDataPtr;
typedef std::shared_ptr ImuDataConstPtr;
```
代码示例：
```cpp
#include
// 包含 limxsdk::Humanoid 头文件，用于引入 Humanoid 类
#include "limxsdk/humanoid.h"
// 使用 limxsdk 命名空间，简化对 Humanoid 类的引用
using namespace limxsdk;
int main(int argc, char *argv[]){
// 获取 Humanoid 类的单例实例
Humanoid* robot = Humanoid::getInstance();
// 默认机器人 IP 地址
std::string robot_ip = "127.0.0.1";
if (argc > 1)
{
// 如果提供了命令行参数，则使用命令行参数作为机器人 IP 地址
robot_ip = argv[1];
}
// 初始化运动控制算法程序的通信运行环境
if (!robot->init(robot_ip))
{
// 如果初始化失败，则退出程序
exit(1);
}
// 订阅机器人状态更新，并指定回调函数
robot->subscribeImuData([&](const ImuDataConstPtr& msg) {
// 在这里处理接收到的 ImuData 数据
// 注意：回调函数会在收到ImuData时被调用
});
// 无限循环以保持程序运行
while (true)
{
// 休眠 1000 毫秒
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.5 subscribeRobotState 接口
| 函数名 | subscribeRobotState |
| -------- | ------------------------------------------------------------------------------------------------ |
| 函数原型 | void subscribeRobotState(std::function cb); |
| 功能概述 | 订阅接收关于机器人状态的更新。 |
| 参数 | cb：回调函数，当接收到机器人状态更新时将被调用。回调函数参数指向 RobotState 对象的常量指针。 |
| 返回值 | 无 |
备注：RobotState 数据结构原型如下：
```cpp
/**
* @struct RobotState
*
* @brief 代表基于传感器反馈的机器人状态的结构体。
*
* 此结构封装了各种数据点，可用于监控和控制机器人，包括 IMU 数据（加速度计、陀螺仪、四元数）、输出扭矩、当前角度和速度等。
*/
struct RobotState {
// 默认构造函数
RobotState() { }
// 带参数的构造函数，用于初始化向量大小为 motor_num 的 tau、q、dq 向量，初始值均为 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; // 时间戳，通常表示记录或生成这些数据的时间，以纳秒为单位
std::vector tau; // 用于存储当前估计的输出扭矩（以牛顿米为单位）的向量
std::vector q; // 用于存储当前角度（以弧度为单位）的向量
std::vector dq; // 用于存储当前速度（以弧度每秒为单位）的向量
std::vector motor_names; // 用于存储机器人各个关节名称的向量
};
// 智能指针类型别名
typedef std::shared_ptr RobotStatePtr;
typedef std::shared_ptr RobotStateConstPtr;
```
代码示例：
```cpp
#include
// 包含 limxsdk::Humanoid 头文件，用于引入 Humanoid 类
#include "limxsdk/humanoid.h"
// 使用 limxsdk 命名空间，简化对 Humanoid 类的引用
using namespace limxsdk;
int main(int argc, char *argv[]){
// 获取 Humanoid 类的单例实例
Humanoid* robot = Humanoid::getInstance();
// 默认机器人 IP 地址
std::string robot_ip = "127.0.0.1";
if (argc > 1)
{
// 如果提供了命令行参数，则使用命令行参数作为机器人 IP 地址
robot_ip = argv[1];
}
// 初始化运动控制算法程序的通信运行环境
if (!robot->init(robot_ip))
{
// 如果初始化失败，则退出程序
exit(1);
}
// 订阅机器人状态更新，并指定回调函数
robot->subscribeRobotState([&](const RobotStateConstPtr& msg) {
// 在这里处理接收到的 RobotState 数据
// 注意：回调函数会在收到机器人状态更新时被调用
});
// 无限循环以保持程序运行
while (true)
{
// 休眠 1000 毫秒
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.6 publishRobotCmd 接口
| 函数名 | publishRobotCmd |
| -------- | ------------------------------------------------ |
| 函数原型 | bool publishRobotCmd(const RobotCmd& cmd); |
| 功能概述 | 发布一个命令来控制机器人的动作。 |
| 参数 | cmd：表示所需机器人命令的 RobotCmd 对象。 |
| 返回值 | 无 |
备注：RobotCmd 数据结构原型如下：
```cpp
/**
* @struct RobotCmd
*
* @brief 代表控制机器人的命令的结构体。
*
* 这个结构体包含了可以用于控制机器人的各种命令，包括期望的工作模式、期望的角度、期望的速度、期望的输出扭矩、期望的位置刚度和期望的速度刚度。
*/
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; // 时间戳（以纳秒为单位），通常表示记录或生成数据时的时间。
std::vector mode; // 0: 力矩模式控制；1：速度模式控制；2：位置模式控制，默认设置为：0
std::vector q; // 存储期望角度的向量（以弧度为单位）。
std::vector dq; // 存储期望速度的向量（以弧度每秒为单位）。
std::vector tau; // 存储期望输出扭矩的向量（以牛顿米为单位）。
std::vector Kp; // 存储期望位置刚度的向量（以牛顿米每弧度为单位）。
std::vector Kd; // 存储期望速度刚度的向量（以牛顿米每弧度每秒为单位）。
std::vector motor_names; // 存储期望控制的机器人关节名称
};
// 智能指针类型别名
typedef std::shared_ptr RobotCmdPtr;
typedef std::shared_ptr RobotCmdConstPtr;
```
代码示例：
```cpp
#include
// 包含 limxsdk::Humanoid 头文件，用于引入 Humanoid 类
#include "limxsdk/humanoid.h"
// 使用 limxsdk 命名空间，简化对 Humanoid 类的引用
using namespace limxsdk;
int main(int argc, char *argv[]){
// 获取 Humanoid 类的单例实例
Humanoid* robot = Humanoid::getInstance();
// 默认机器人 IP 地址
std::string robot_ip = "127.0.0.1";
if (argc > 1)
{
// 如果提供了命令行参数，则使用命令行参数作为机器人 IP 地址
robot_ip = argv[1];
}
// 初始化运动控制算法程序的通信运行环境
if (!robot->init(robot_ip))
{
// 如果初始化失败，则退出程序
exit(1);
}
// 获取机器人中的电机数量
uint32_t motor_num = robot->getMotorNumber();
// 创建一个包含机器人电机数量的 RobotCmd 对象
RobotCmd cmd(motor_num);
// 发布控制指令
robot->publishRobotCmd(cmd);
// 无限循环以保持程序运行
while (true)
{
// 休眠 1000 毫秒
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.7 subscribeSensorJoy 接口
| 函数名 | subscribeSensorJoy |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 函数原型 | void subscribeSensorJoy(std::function cb); |
| 功能概述 | 在真机部署中，该方法用于订阅来自机器人遥控器的数据。当机器人接收到遥控器的数据时，将会调用指定的回调函数，并传递包含遥控器数据的 SensorJoy 结构体常量指针给回调函数进行处理。 |
| 参数 | cb: 表示回调函数，用于接收机器人遥控器的数据。回调函数的参数类型为 SensorJoyConstPtr，即指向 SensorJoy 结构体常量的共享指针。 |
| 返回值 | 无 |
备注：SensorJoy 数据结构原型如下：
```cpp
/**
* @struct SensorJoy
*
* @brief 机器人遥控器数据的结构体。
*
* 该结构体包含了与遥控器相关的时间戳信息，以及摇杆和按钮值。
*/
struct SensorJoy {
uint64_t stamp; // 与传感器输入相关的时间戳，单位为纳秒。
std::vector axes; // 表示操纵摇杆的值。
std::vector buttons; // 表示操纵按钮状态的值。
};
// SensorJoy 智能指针类型的定义
typedef std::shared_ptr SensorJoyPtr;
typedef std::shared_ptr SensorJoyConstPtr;
```
代码示例：
```cpp
#include
// 包含 limxsdk::Humanoid 头文件，用于引入 Humanoid 类
#include "limxsdk/humanoid.h"
// 使用 limxsdk 命名空间，简化对 Humanoid 类的引用
using namespace limxsdk;
int main(int argc, char *argv[]){
// 获取 Humanoid 类的单例实例
Humanoid* robot = Humanoid::getInstance();
// 默认机器人 IP 地址
std::string robot_ip = "127.0.0.1";
if (argc > 1)
{
// 如果提供了命令行参数，则使用命令行参数作为机器人 IP 地址
robot_ip = argv[1];
}
// 初始化运动控制算法程序的通信运行环境
if (!robot->init(robot_ip))
{
// 如果初始化失败，则退出程序
exit(1);
}
// 订阅机器人遥控器数据
robot->subscribeSensorJoy([&](const limxsdk::SensorJoyConstPtr &joy) {
// L1 & R1 按下
if (joy->buttons[4] == 1 && joy->buttons[7] == 1)
{
// 在这里执行相关操作
}
// 处理摇杆数据
double axes_left_horizontal = joy->axes[0];
double axes_left_vertical = joy->axes[1];
double axes_right_horizontal = joy->axes[2];
double axes_right_vertical = joy->axes[3];
});
// 无限循环以保持程序运行
while (true)
{
// 休眠 1000 毫秒
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.8 subscribeDiagnosticValue 接口
| 函数名 | subscribeDiagnosticValue |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 函数原型 | void subscribeDiagnosticValue(std::function cb); |
| 功能概述 | 在真机部署中，该方法用于订阅机器人的诊断值和状态信息。当机器人发出诊断值时，系统会调用指定的回调函数，并传递包含诊断值的 DiagnosticValue 结构体常量指针给回调函数进行处理。这可以帮助实时监控机器人的健康状态，并及时做出反应以处理可能的问题。 |
| 参数 | cb: 用于接收机器人诊断值的回调函数，其参数类型为 DiagnosticValueConstPtr，即指向 DiagnosticValue 结构体常量的共享指针。DiagnosticValue 结构体包含了机器人诊断值的信息，包括时间戳、级别、名称、代码和消息字段。 |
| 返回值 | 无 |
备注：DiagnosticValue 数据结构原型如下：
```cpp
/**
* @struct DiagnosticValue
*
* @brief 结构体，表示诊断值。
*
* 此结构体包含有关诊断级别、名称、代码和消息的信息。
*/
struct DiagnosticValue {
enum { OK = 0 }; // 正常状态的诊断级别
enum { WARN = 1 }; // 警告状态的诊断级别
enum { ERROR = 2 }; // 错误状态的诊断级别
uint64_t stamp; // 时间戳，单位为纳秒。
int32_t level; // 与诊断值相关联的级别。
std::string name; // 标识诊断值的名称。
int32_t code; // 与诊断值对应的代码。
std::string message; // 与诊断值相关的详细消息。
};
// DiagnosticValue 智能指针类型的定义
typedef std::shared_ptr DiagnosticValuePtr;
typedef std::shared_ptr DiagnosticValueConstPtr;
```
代码示例：
```cpp
#include
// 包含 limxsdk::Humanoid 头文件，用于引入 Humanoid 类
#include "limxsdk/humanoid.h"
// 使用 limxsdk 命名空间，简化对 Humanoid 类的引用
using namespace limxsdk;
int main(int argc, char *argv[]){
// 获取 Humanoid 类的单例实例
Humanoid* robot = Humanoid::getInstance();
// 默认机器人 IP 地址
std::string robot_ip = "127.0.0.1";
if (argc > 1)
{
// 如果提供了命令行参数，则使用命令行参数作为机器人 IP 地址
robot_ip = argv[1];
}
// 初始化运动控制算法程序的通信运行环境
if (!robot->init(robot_ip))
{
// 如果初始化失败，则退出程序
exit(1);
}
// 订阅机器人诊断数据
robot->subscribeDiagnosticValue([&](const DiagnosticValueConstPtr& msg) {
// 在这里处理机器人诊断值
// 例如，可以根据诊断值的级别和消息来采取相应的措施
std::cout << "Diagnostic Value: " << msg->name << std::endl;
std::cout << "Level: " << msg->level << std::endl;
std::cout << "Code: " << msg->code << std::endl;
std::cout << "Message: " << msg->message << std::endl;
});
// 无限循环以保持程序运行
while (true)
{
// 休眠 1000 毫秒
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.9 publishJsonMessage 接口
| 函数名 | **publishJsonMessage** |
| -------- | ------------------------------------------------------------------------------------------------------------------ |
| 函数原型 | void publishJsonMessage(const std::string &json_payload); |
| 功能概述 | 向机器人发送 "上层应用协议接口" 的 JSON 格式消息。 |
| 参数 | json_payload: 符合 "上层应用协议接口" 协议的 JSON 字符串。 示例：{"accid": "xxx", "title": "request_xxx", "timestamp": xxx, "guid": "xxx", "data": {}} |
| 返回值 | 无 |
| 备注 | **高阶开发模式下有效** |
**代码示例**
```cpp
#include
#include "limxsdk/humanoid.h"
using namespace limxsdk;
int main(int argc, char *argv[]) {
Humanoid* robot = Humanoid::getInstance();
std::string robot_ip = "10.192.1.2";
if (argc > 1) {
robot_ip = argv[1];
}
if (!robot->init(robot_ip)) {
exit(1);
}
std::string json_payload = R"({
"accid": "HU_D03_01",
"title": "request_get_joint_state",
"timestamp": 1672373633989,
"guid": "746d937cd8094f6a98c9577aaf213d98",
"data": {}
})";
robot->publishJsonMessage(json_payload);
while (true) {
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.10 subscribeJsonMessage 接口
| 函数名 | **subscribeJsonMessage** |
| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 函数原型 | void subscribeJsonMessage(std::function cb); |
| 功能概述 | 注册一个回调函数，用于处理来自机器人的 "上层应用协议接口" 调用的响应和通知。 该回调函数会在以下两种场景中被调用： 1. 当机器人对之前发送的 JSON 命令（publishJsonMessage）返回响应时 2. 当机器人主动发起通知（未经请求的消息）时 |
| 参数 | cb: 回调函数，原型为 void(const std::string &json_payload) 其中 json_payload 包含： - 命令响应：{"accid": "xxx", "title": "response_xxx", "timestamp": xxx, "guid": "xxx", "data": {}} - 通知：{"accid": "xxx", "title": "notify_xxx", "timestamp": xxx, "guid": "xxx", "data": {}} |
| 返回值 | 无 |
| 备注 | **高阶开发模式下有效** |
**代码示例**：
```cpp
#include
#include "limxsdk/humanoid.h"
using namespace limxsdk;
int main(int argc, char *argv[]) {
Humanoid* robot = Humanoid::getInstance();
std::string robot_ip = "10.192.1.2";
if (argc > 1) {
robot_ip = argv[1];
}
if (!robot->init(robot_ip)) {
exit(1);
}
robot->subscribeJsonMessage([&](const std::string & json_payload) {
std::cout << json_payload << std::endl;
});
while (true) {
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
return 0;
}
```
### 4.1.11 参考例程
Github: [https://github.com/limxdynamics/humanoid-rl-deploy-ros](https://github.com/limxdynamics/humanoid-rl-deploy-ros)
## 4.2 Python 运动控制开发接口
提供与 C++ 相同功能的 [Python 运动控制算法开发接口](https://github.com/limxdynamics/pointfoot-sdk-lowlevel/tree/master/python3)，**使得不熟悉 C++ 编程语言的开发者能够使用 Python 进行运动控制算法的开发。**
### 4.2.1 安装运动控制开发库
- **Linux x86_64 环境**
```bash
pip install python3/amd64/limxsdk-*-py3-none-any.whl
```
- **Linux aarch64 环境**
```bash
pip install python3/aarch64/limxsdk-*-py3-none-any.whl
```
- **Windows 环境**
```bash
pip install python3/win/limxsdk-*-py3-none-any.whl
```
### 4.2.2 __init__ 接口
| 函数名 | __init__ |
| -------- | ------------------------------------------------ |
| 函数原型 | def __init__(self, robot_type: robot.RobotType) |
| 功能概述 | 在初始化时，指定机器人的类型，并创建一个相应类型的本地机器人实例。 |
| 参数 | robot_type：表示机器人类型的枚举值，点足为RobotType.Humanoid。 |
| 返回值 | 无 |
| 备注 | 无 |
**代码示例**：
```python
import sys
import limxsdk.robot.Robot as Robot
import limxsdk.robot.RobotType as RobotType
if __name__ == '__main__':
# 创建一个类型为Humanoid的Robot实例
robot = Robot(RobotType.Humanoid)
```
### 4.2.3 init 接口
| 函数名 | init |
| -------- | ------------------------------------------- |
| 函数原型 | def init(self, robot_ip: str = "127.0.0.1") |
| 功能概述 | 初始化运动控制算法程序的通信运行环境，通常在主函数中调用其它接口之前调用，完成初始化工作。 |
| 参数 | robot_ip：机器人的 IP 地址。对于仿真，通常设置为 "127.0.0.1"，而对于真实机器人，可能设置为 "10.192.1.2"。 |
| 返回值 | 成功：返回True
失败：返回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的字段中描述了每个关节的q、dq、tau取值范围：
- 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
```
## 附件
- [Limx_Oli_EDU_SDK_开发指南.pdf](https://oss.limxdynamics.com/uploads/pdf/2026/11/04/1793779496688_Limx_Oli_EDU_SDK_开发指南.pdf)