关于L7
产品介绍
L7是 RobotEra 开发的最新通用人形机器人,具有业界顶尖的 55 个自由度,最大 400Nm 峰值扭矩和 25rad/s 峰值转速的电机,可以实现高速的奔跑,目前已经实现了世界最快的 4m/s 户外全地形奔跑。L7 还搭配有一双 12 个主动自由度的灵巧手,配合上强大的 275TOPS 平台算力,可实现遥操作,模仿学习,机器人大模型等多种算法,在科研,工厂,商业,家庭等场景落地 AGI。 L7目前推出的型号对应配置如下:
| 产品型号 | 产品中文名称 | 产品英文名称 | 产品型号(ERP) | 本体 | 灵巧手 | Jetson Orin算力控制器 | 灵巧手触觉传感器 | 产品编码 |
|---|---|---|---|---|---|---|---|---|
| L7 SE | L7 SE 全尺寸双足人形机器人 | L7 SE Full-size Bipedal Humanoid | L7-N-NN | L7 | 7003000010 | |||
| L7 SE+ | L7 SE+ 全尺寸双足人形机器人 | L7 SE+ Full-size Bipedal Humanoid | L7-A-NN | L7 | 具备 | 7003000009 | ||
| L7 Pro | L7 Pro 全尺寸双足人形机器人 | L7 Pro Full-size Bipedal Humanoid | L7-N-XT | L7 | XHAND | 具备 | 7003000008 | |
| L7 Pro+ | L7 Pro+ 全尺寸双足人形机器人 | L7 Pro+ Full-size Bipedal Humanoid | L7-A-XT | L7 | XHAND | 具备 | 具备 | 7003000007 |
| L7 Pro | L7 Pro 全尺寸双足人形机器人 | L7 Pro Full-size Bipedal Humanoid | L7-N-XN | L7 | XHAND | |||
| L7 Pro+ | L7 Pro+ 全尺寸双足人形机器人 | L7 Pro+ Full-size Bipedal Humanoid | L7-A-XN | L7 | XHAND | 具备 |
概览
机器人整体形态如下

整机参数
规格参数
| **L7 **规格参数 | |
|---|---|
| 尺寸 | 直立尺寸:1706mm580mm320mm,如图所示。 |
| 大腿和小腿总长度 | 720mm x 2 |
| 手臂总长度 | 717mm x 2 |
| 单臂负载: | 10Kg |
| 自由度 | 55个(手臂7自由度 x 2,腿6自由度 x 2,腰部3自由度,脖子2自由度,灵巧手12自由度 x 2) |
| 整机重量 | 约67kg |
| 移动****速度 | 4m/s (理论6m/s) |
| 电池 | 57.6V 15Ah 864Wh |
| 控制和感知能力 | 80 TOPS(x86)+275 TOPS(Orin AGX) |
| 感知传感器配置 | 深度相机 语音模块 |
| 灵巧手 | 具备类人手外形,单手主动12个自由度 |
| 通信接口 | Ethernet、USB 3.0、Wi-Fi 6、4G、USB-C |
关节与电机
2维整机关节位置图:

各关节的坐标轴定义如下

各个关节和电机的零位如下
| Joint Name | Angle (degrees) |
|----------------------------|:---------------:|
| left_hip_pitch_joint | 30 |
| left_knee_joint | -60 |
| left_ankle_pitch_joint | 30 |
| right_hip_pitch_joint | 30 |
| right_knee_joint | -60 |
| right_ankle_pitch_joint | 30 |
| Other joints | 0 |各个关节峰值扭矩和速度如下:
| position | Peak torque (Nm) | speed (rad/s) |
|---|---|---|
| knee | 400 | 25 |
| leg pitch | 400 | 25 |
| leg roll | 255 | 7 |
| leg yaw | 100 | 13 |
| ankle pitch | 50 | 14 |
| ankle roll | ||
| shoulder pitch | 95 | 4 |
| shoulder roll | ||
| shoulder yaw | ||
| elbow pitch | ||
| wrist yaw | 35 | 4 |
| wrist roll | ||
| wrist pitch | ||
| neck pitch | 35 | 4 |
| neck yaw | ||
| waist pitch | 95 | 4 |
| waist roll | ||
| waist yaw |
机载计算资源连接图

机载计算资源的硬件和系统参数表:
| 计算单元名称: | AMD 锐龙 AI 9 HX 370 |
|---|---|
| CPU | 12核 |
| 内存 | 32GB |
| 硬盘 | 1TB SSD |
(选配ORIN)
| 计算单元名称: | Jetson Orin AGX 64GB |
|---|---|
| AI 性能 | 275 TOPS |
| GPU | 搭载 64 个 Tensor Core 的 2048 核 NVIDIA Ampere 架构 GPU |
| GPU 最大频率 | 1.3 GHz |
| CPU | 12 核 Arm® Cortex®-A78AE v8.2 64 位 CPU 3MB L2 + 6MB L3 |
| CPU 最大频率 | 2.2 GHz |
| 显存 | 64GB 256 位 LPDDR5 204.8GB/s |
操作指南
开箱和启动
开箱
机器人的开箱指南通常包括以下几个步骤:
- 检查包装:在开箱前,首先要检查包装盒是否有损坏,以确保产品在运输过程中没有遭到损害 。
- 取出物品:打开包装盒,按照说明书的指导,逐一取出产品及其配件,如电源、工装等 。
- 按照视频指引机器人从包装箱中取出,通过移位机吊起来。
安装电池,并启动机器人
连接到机器人
在机器人的hip roll关节下查找产品的WiFi名:L_v3_BOTXX

在网络中搜索“L_v3_BOTXX”并连接到机身内路由器上。
注意:5G WiFI 出来的时间会更晚。
wifi的默认密码为xbot123456
查看机器人管理后台
打开浏览器,输入地址:http://192.168.8.100:1888 ,打开机器人控制后台,可在控制后台中查看机器人的各项信息内容。
创建访问密码
创建密码

XOS 的初始安全设置界面,用于为一站式机器人控制中心配置访问密码,保障系统与设备的权限安全。
双重认证

XOS 的双重认证设置界面,进一步加固机器人控制中心的访问安全,为系统提供密码之外的第二层防护。
主页

1、通过产品主页展示机器人整机状态信息,实时了解机器人当前状况。
2、展示机器人整机信息:
机器人状态:
INIT:开机启动后的状态
IDLE:机器人硬件连接的状态
READY:机器人初始化的状态
ACTIVE:机器人进入任务接受的状态
ERROR:机器人发生错误的状态
机器人型号:当前机器人的型号
灵巧手型号:当前机器人灵巧手型号
电池电量:以百分比的形式展现
电池状态:待机中(充满电)、充电中、放电中
机器人SN:当前机器人的SN
NUC的IP:当前机器人NUC的IP地址
XOS的版本号:当前机器人XOS的版本
CPU使用率: 当前CPU的总体使用率曲线
机器人模型:当前型号的机器人仿真模型
3、实时错误信息:如果有告警或错误发生,机器人仿真对应告警或错误关节会变成红色。
机器人概览
日志管理

1、日志管理模块具备系统化的日志采集、存储与可视化展示能力。
2、可按系统架构层级对各功能模块的运行日志进行分类归集。
3、通过交互式界面提供展示及结构化解析功能。
4、支持用户根据业务需求手动下载指定模块的日志文件,满足系统调试、问题追溯等日志管理需求。
CPU 频率看板

1、该功能支持实时查看 CPU 总体频率曲线,通过可视化图形界面动态展示cpu所有内核综合频率随时间的变化趋势,横轴为时间,纵轴精确显示频率值(GHz)。支持实时动态刷新,用户直观监控 CPU 性能波动、分析频率调度策略并排查异常状态。
2、CPU:支持cpu、cpu_max、cpu_min、cpu_avg 以及各个cpu内核的选择,可单选、多选,多选支持全选。
3、时间区间,支持24小时区间查看。
4、重置功能:重置页面的查询条件,包括已选择的 CPU、时间,点击重置后,清空查询条件。
5、关闭、开启刷新功能:曲线页面,默认会实时动态刷新,关闭后不刷新,开启后,实时获取最新的数据和绘制曲线。
异常状态

1、支持实时监控机器人各模块的运行异常状态,支持弹窗通知与语音播报,可以快速定位并处理故障。
核心功能:
- 异常通知:支持弹窗通知和语音播报两种提醒方式,默认开启。
- 异常列表:清晰展示异常模块、名称、编码、部位、描述及等级,便于快速识别问题。
- 快速处理:每条异常提供 “查看解决方案” 入口,直接跳转至对应处理指引。
操作说明:
2、开启 / 关闭通知
- 点击 “弹窗通知” 或 “语音播报” 右侧的开关,即可切换开启 / 关闭状态。
3、查看异常详情
- 在列表中查看异常的模块、部位、等级等关键信息。
- 异常等级分为:致命错误,严重错误,错误,警告,提示,信息。
4、处理异常
- 点击异常行右侧操作栏的 “查看解决方案”,获取官方处理步骤。
机器人管理
启动管理

1、启动管理用于设置机器人的启动模式。
启动模式选择:
- 标准模式:SDK进入ACTIVE状态,SDK启动上肢力控、下肢力控,同时启动MPC/RL,同时 RL ready,由遥控器启动RL ACTIVE。
- 快速启动模式:由SDK启动机器人到RL ready状态同时启动MPC,可以由遥控器快速切换到遥操作模式。
- 开发者模式:不启动SDK,不启动遥控器节点。
语音和动作

1、该模块提供添加语音和动作功能,添加完语音和动作可以通过点击播放按钮和遥控手柄组合按键触发让机器人播放动作语音。
2、列表展示语音名称、动作名称、语音时长、动作时长,支持播放、编辑、删除操作。
3、操作按钮:
停止播放:终止当前正在执行的语音 - 动作序列。
添加语音动作:创建新的 “语音指令→设备动作” 。
语音列表 / 动作列表:单独查看所有可用的语音库和动作库。
添加语音动作

1、语音和动作支持选只择一个动作或一条语音或者各选择一个。
2、点击保存,保存成功后回放列表新增一条数据。
机器人动作列表

1、列表显示动作名称、文件大小、文件时长、和上传时间。
2、点击选择文件,在本地选择zip格式的机器人动作文件。
3、点击保存,保存成功后列表新增一条数据。
4、该列表数据用于配置语音和动作的时候选择动作。
语音列表

1、列表展示语音名称、文件大小、语音时长、日期、操作支持下载、删除。
2、点击文本转语音,弹出输入窗口,可输入语音名称以及内容,点击提交,成功后音频文件列表新增一条数据。
3、点击上传语音,可以在本地选择一条语音文件上传,上传成功后页面新增一条数据。
4、该列表数据用于配置语音和动作的时候选择语音。
音色和音量

1、支持0-100% 的音量调节区间,用户可通过滑动调节条或加减按键精准控制机器人的发声音量,系统默认记忆上次设置参数,重启后自动恢复用户偏好设置。
2、支持用户自主选择机器人的音频输出设备,系统将自动扫描并列出当前可用的声卡列表(包括内置声卡、外接 USB 声卡等),可通过下拉菜单快速切换输出设备。
机器人数控台
详细使用方式参考xviz 使用说明文档
综合数据中心

XOS 的机器人控制台 - 综合数据中心,是为机器人用户打造的一站式数据可视化与仿真调试平台,可实现机器人关节状态等运行数据的实时监控、故障诊断、数据录制与仿真验证,为机器人调试、运行分析和问题定位提供全流程支撑。
数据监控中心

XOS 的数据监控中心,是机器人运行数据的实时可视化看板,支持以折线图等形式对关节状态(如手臂、肘部关节位置)等关键话题数据进行实时采集与展示,帮助直观掌握机器人运行状态、快速识别数据异常与波动。
录制中心

- 实现 ROS 话题(含 XOS 专属话题)灵活订阅、自定义时段录制 / 导出,支持一键快速导出与精准时段导出,适配 XOS 数据格式与便携设备小屏布局,简化数据采集与导出操作。
仿真中心

XOS 仿真中心-孪生模式,通过将机器人真实运行数据与虚拟模型实时联动,实现 “虚实同态” 的可视化调试与验证,支持关节状态实时映射、运动轨迹复现与物理仿真校验,帮助开发者直观验证控制逻辑、提前排查风险,大幅提升调试效率与安全性。
应用管理

1、该页面提供对系统的拓展应用的上传、安装、以及启动的操作。
2.上传应用的压缩包,支持文件包拖拽到页面,支持系统文件选择,上传成功后,点击"上传并安装"按钮,安装应用。
3、安装成功后应用列表新增一个应用,点击应用后打开应用。
系统升级
- 本功能用于管理机器人系统及手控器的软件版本,支持云端检测更新与手动升级两种方式。
版本信息展示:
1.版本号:查看当前系统版本(RobotOS)。
2.版本详情:点击 【版本详情】可查看每个模块版本号。

升级包获取方式:
- 云端检测:
1.一键从云端服务器检测并获取最新版本。
2.点击 “检查更新” 按钮,系统将重新从云端检测最新版本。

3.下载
点击“下载升级包vX.X.X.X” 按钮开始下载,下载过程中支持删除。


- 手动上传升级包
支持本地升级包上传,用于离线或指定版本升级。

升级
升级前确认事项
- 机器人需处于安全静止状态,并按图示要求完成吊起。
图示:

- 电池电量高于 30%,或已连接外接电源。
- 升级过程中机器人将自动重启,期间请勿操作设备。
确认满足以上条件后,点击 “升级到 vX.X.X” 按钮启动升级。升级进行中请勿断电或操作机器人,防止升级异常。

升级完成判断
- 升级启动后系统将自动执行升级,待界面显示 “升级完成” 字样,即表示本次升级成功。全程请勿关闭电源。

安全中心
具体使用说明请参考说明书——XOS安全部分
设置密码

XOS 安全中心的设置密码功能,支持用户更新登录密码(6-8 位字母或数字),也可关闭密码保护,实现机器人控制中心访问权限的灵活管理。
身份验证器管理

XOS 安全中心的身份验证器管理功能,支持用户添加、重命名、删除 TOTP 验证设备,最多可绑定 5 个,方便用户灵活管理双重认证的备用设备,保障系统访问安全。
登录历史

XOS 安全中心的登录历史功能,可展示最近 50 条登录记录,包含登录 IP、时间、结果与客户端信息,帮助用户追溯访问行为、及时发现异常登录风险。
ROS-IP管理

XOS安全中心的ROS-IP白名单管理功能,用于配置CycloneDDS通信的可信IP地址,支持添加、删除IP,仅允许白名单内设备与机器人系统通信,提升ROS通信的安全性与可控性。
防火墙管理

XOS 安全中心的防火墙管理功能,用于管理 nftables INPUT 链的端口允许规则,支持查看系统内置规则与自定义添加新规则,管控机器人系统的网络端口访问,强化网络安全防护。
机器人内网遥操作
exclamation 请先用升降机将机器人调整至如下站姿。下降过程中,机器人脚尖着地-->机器人脚掌着地-->保证吊绳和吊环之间有肉眼可见的张力,防止机器人歪斜,之后通过游戏手柄切换到遥控模式,让机器人自主站起后启动遥操作应用。


上传遥操作授权文件
1、上传遥操作授权文件,上传并校验成功可以使用遥操作功能
2、支持手动配置摄像头参数

打开遥操作 app
1、打开遥操作 app ,进入主页面,机器人开始启动,启动完成抬起双臂,进入等待连接VR 设备状态
2、VR 设备连接成功后通过星遥App开始遥操作
3、点击退出遥操作,页面返回到 XOS ,机器人退出遥操作状态

连接 MetaQuest
1、开启 Meta Quest 设备,进入系统设置。
2、选择网络连接方式:
有线连接:通过数据线将 Meta Quest 与机器人直接连接。
WiFi 连接:找到机器人对应的 WiFi,输入密码完成连接。
3、在 Meta Quest 应用列表中找到「星遥 App」图标,点击即可启动。
详细使用方式参考:星遥App软件使用说明
+1 完成以上步骤,成功开始遥操作!如下图

遥控机器人行走
- 将机器人从吊架上放下,脚接触地面,用手扶住机器人背后扶手避免机器人摔倒。
- 通过遥控器启动机器人进入站立或行走模式,开始遥控。
遥控器使用说明
- 游戏手柄
遥控器简介
- 图片:

- 打开遥控手柄:按一下 home 键,手柄震动,白灯常亮则表示已连接到机器人
- 关闭遥控手柄:手柄背面切换其他模式,或长时间不使用自动关机
- 遥控手柄参数详情,可以参考手柄的使用说明书
按键定义:
- 按键说明
- 取四个肩键作为 主键,包括:
LT, RT, LB, RB - 取
十字键的上下左右和ABXY功能键作为 副键 - 整体支持 副键单独按下,和 主副键同时按下 的组合键,控制机器人
- 取四个肩键作为 主键,包括:
- 注意
- 主键按下时需要完全按到底才生效
- 组合键使用时,需要先按下主键,再按副键触发
按键功能列表:
| 模式 | 按键 | 说明 |
|---|---|---|
| 遥控模式 | LB+A | 切换到遥控模式 |
| Y | 站高一些 | |
| X | 站矮一些 | |
| 左摇杆 | Y轴行走、X轴横移 | |
| 右摇杆 | X轴转向 | |
| RT+十字键⬅️ | 停止动作语音 | |
| RT+十字键⬇️ | 暂停/恢复 动作语音 | |
| RT+A/B/X/Y/(十字键区⬆️➡️) LT+A/B/X/Y/(十字键区⬆️⬇️⬅️➡️) | 播放动作语音 | |
| 遥操作模式(快速启动模式生效) | LB+X | 可通过遥控组合按键快速切到遥操作模式 |
使用步骤:
- 准备:
- 机器人正常开机,会自启动到 ACTIVE 状态
- 打开遥控器手柄,按一下home 键,手柄白色灯常亮,则说明遥控已连接到机器人
- 在机器人 ACTIVE 状态下,可以使用以下组合键控制机器人
- 组合键
LB + A,切换机器人到 遥控模式,同时播放语音提示
- 组合键
- 机器人在 遥控模式 下,可以使用以下组合键控制机器人
- 滑动
左摇杆的Y轴,即上下滑动,机器人会 前后移动 - 滑动
左摇杆的X轴,即左右滑动,机器人会 左右横移 - 滑动
右摇杆的X轴,即左右滑动,机器人会 左右转向 - 自定义按键,需要在 XOS 页面【机器人管理】->【上肢回放管理】位置,自定义遥控组合键触发的 语音或动作,支持的组合键如下:
- 组合键 RT+A/B/X/Y/(十字键区⬆️➡️) LT+A/B/X/Y/(十字键区⬆️⬇️⬅️➡️) 根据XOS 页面的配置,播放指定语音或执行指定动作
- 滑动
- 注意:遥控器支持开机自动连接,如果使用过程中关机再开机,不会影响机器人状态
ORIN 操作指南
整机功能接口示意图



登录用户名和密码
开机后,进入ubuntu界面
用户名:xbot-orin
密码:xbot_123456
网络配置
启动后,默认的IP地址是:192.168.8.200
设备系统烧录
烧录准备
下载烧录包:https://developer.nvidia.com/embedded/jetson-linux-r3643

底板设备树:ces-Linux_R36.4.3_bsp
链接: https://pan.baidu.com/s/1b_7R4hyPML47WPkr1Afyjg?pwd=cmrb 提取码: cmrb
下载完成后,执行如下命令:
烧录过程
一、搭建烧录环境(x86主机,可用磁盘空间建议>100G)
下载网盘中产品烧录镜像包到Ubuntu18.04/20.04或更高的系统的x86主机中。
在烧录镜像文件夹中执行
二、烧录镜像(Jetson)
点击RCW键不松手,然后连接电源,点击PWR开机,进入Recovery模式。
再将主机USB连接设备Type-c接口。

判断是否成功进入Recovery模式,在X86主机终端执行

如图所示即表示已进入recovery模式,ID编码:AGX ORIN 为7023或者7223
进行flash.sh的烧录操作
烧录命令: sudo ./flash.sh ces-agx-orin64-dak-01 mmcblk0p1
烧录完成
连接HDMI接口显示器加电验证,系统开机正常。
烧录自己的镜像
备份镜像方法:
sudo ./flash.sh -r -k APP -G backup.img jetson-agx-orin-devkit mmcblk0p1
然后备份生成的backup.img的镜像文件
恢复镜像方法:
将备份的文件名为backup.img的镜像拷贝到Linux_for_Tegra/bootloader/目录下重命名为system.img:
sudo cp backup.img bootloader/system.img
在Linux_for_Tegr目录下执行:
sudo ./flash.sh -r jetson-agx-orin-devkit mmcblk0p1
注:-r参数指使用bootloader目录下的system.img烧录。
注:备份和恢复均需进入RECEOVER模式下。
注意事项
- 接触主板时请佩戴静电手环等静电防护工具(要有良好接地);
- 请勿带电组装、接线等操作;
- 请核对主板接口定义和外设接口定义,不能出现接错、接反;
- 注意 IO 口、串口、使能脚等电平匹配;
- 注意外接屏幕的功率,功率较大的请考虑外部供电;
- 注意产品的整体功率,选择功率足够的电源;
紧急停止
L7 提供紧急停止遥控器,以便在出现意外状况的时候及时切断电源,确保安全。
下图是急停遥控器:

按一次A键会关闭机载电脑的电源,再按一次A键恢复
按一次D键会关闭关节电机电源,再按一次D键恢复
exclamation 重要,请确保在调试时准备好急停遥控器,如果遇到紧急情况请按D,避免异常发生时无法关闭电源
装箱
重新标零
开发指南
整机软件架构

SDK调用说明
L3使用Ros2 Humble 和整机进行交互,开发者可以通过有线/无线网络连接到机器人,或者通过登录到开发者容器中编写程序运行和主机系统进行通信。
Ros2 domain: 211
如果希望通过另外一台主机连接机器人,进行控制:
- 通过有线连接机器人,或者直接连接机器人WIFI
- 前提条件:主机有 ros-humble + cyclonedds 环境
- 需要在自己主机部署机器人所使用的消息
git clone https://github.com/roboterax/teleop_client.git
cd teleop_client
colcon build
source install/setup.bash- 设置环境变量
export ROS_DOMAIN_ID=211
export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp- 配置单播,在主机直接执行下面的命令:
sudo mkdir /etc/xbot/
sudo tee /etc/xbot/cyclonedds.xml > /dev/null << 'EOF'
<?xml version="1.0"?>
<CycloneDDS xmlns="https://cdds.io/config">
<Domain id="211">
<General>
<AllowMulticast>false</AllowMulticast>
</General>
<Discovery>
<Peers>
<Peer address="127.0.0.1"/>
<Peer address="192.168.8.100"/>
</Peers>
<ParticipantIndex>auto</ParticipantIndex>
<MaxAutoParticipantIndex>300</MaxAutoParticipantIndex>
</Discovery>
</Domain>
</CycloneDDS>
EOF
export CYCLONEDDS_URI=file:///etc/xbot/cyclonedds.xml
ros2 daemon stop
ros2 daemon start- 在机器人-XOS上设置ROSIP白名单ROSIP设置说明文档
- 将主机 ip 添加进 XOS ros 白名单即可
- 直接跳到
**底层关节控制SDK**章节即可
机器人端口使用规范
禁止使用端口
系统预留端口常用内置端口:
tcp dport { 22, 80, 443, 2222 } accept
tcp dport { 5555, 8888, 1688, 1788, 1888, 1988 } accept
tcp dport { 8765, 8080, 8090 } accept
tcp dport 1788-1888 accept
开发者可用端口
仅限:1024 ~ 65535
进入开发者容器
用户名: developer 初始密码:developer 端口号:2222
ssh developer@192.168.8.100 -p 2222 #ssh连接机器人后端, 进入工作空间底层关节控制SDK
关节控制流程
flowchart TD
A[检查机器人硬件状态<br>(确认Ethercat连接、关节上电<br>绿色电源灯亮起)] --> B{选择模式}
B -->|全身形态(带XHAND)| C[启动底层关节控制服务<br>/dynamic_launch<br>launch_mode: 'pos']
B -->|全身形态(无XHAND)| C2[启动底层关节控制服务<br>/dynamic_launch<br>launch_mode: 'no_hand_pos']
C & C2 --> D[初始化关节控制服务<br>/ready_service<br>(等待约20秒,接口返回成功)]
D --> E[关节到标准起始位置<br>/simple_trajectory]
E -->|使能算法控制| G1[使能算法控制<br>/activate_service]
G1 --> H[发送关节控制命令<br>]
H --> I[停止底层关节控制服务<br>/stop_launch]
整机关节名称
关节列表如下,整机结构参考产品结构图
| Joint Name |
|----------------------------|
| left_shoulder_pitch_joint |
| left_shoulder_roll_joint |
| left_arm_yaw_joint |
| left_elbow_pitch_joint |
| left_elbow_yaw_joint |
| left_wrist_pitch_joint |
| left_wrist_roll_joint |
| neck_yaw_joint |
| neck_pitch_joint |
| right_shoulder_pitch_joint |
| right_shoulder_roll_joint |
| right_arm_yaw_joint |
| right_elbow_pitch_joint |
| right_elbow_yaw_joint |
| right_wrist_pitch_joint |
| right_wrist_roll_joint |
| waist_pitch_joint |
| waist_roll_joint |
| waist_yaw_joint |
| left_hip_roll_joint |
| left_hip_yaw_joint |
| left_hip_pitch_joint |
| left_knee_joint |
| left_ankle_pitch_joint |
| left_ankle_roll_joint |
| right_hip_roll_joint |
| right_hip_yaw_joint |
| right_hip_pitch_joint |
| right_knee_joint |
| right_ankle_pitch_joint |
| right_ankle_roll_joint |
| XHAND Joint Name |
|------------------------------|
| left_hand_thumb_bend_joint |
| left_hand_thumb_rota_joint1 |
| left_hand_thumb_rota_joint2 |
| left_hand_index_bend_joint |
| left_hand_index_joint1 |
| left_hand_index_joint2 |
| left_hand_mid_joint1 |
| left_hand_mid_joint2 |
| left_hand_ring_joint1 |
| left_hand_ring_joint2 |
| left_hand_pinky_joint1 |
| left_hand_pinky_joint2 |
| right_hand_thumb_bend_joint |
| right_hand_thumb_rota_joint1 |
| right_hand_thumb_rota_joint2 |
| right_hand_index_bend_joint |
| right_hand_index_joint1 |
| right_hand_index_joint2 |
| right_hand_mid_joint1 |
| right_hand_mid_joint2 |
| right_hand_ring_joint1 |
| right_hand_ring_joint2 |
| right_hand_pinky_joint1 |
| right_hand_pinky_joint2 |关节控制说明
控制模式
当前系统下肢仅支持力矩控制模式,包括腰部在内的上肢支持力矩控制模式和位置控制模式。通过不同的启动方式来进行区分
在不同的启动模式下
- 对于力矩控制的关节仅可设置参数如下:
- velocity:关节目标速度
- position:关节目标位置
- feedforward:前馈力
- kp:比例增益
- kd:微分增益
- 对于位置控制的关节仅需设置 position(每个关节的目标位置)参数。其余参数包括:
- velocity:关节目标速度
- feedforward:前馈力或力矩
- kp:比例增益
- kd:微分增益
上述参数在位置控制模式下不生效,无需配置。请确保仅填写 position 字段,以避免冗余数据或接口误用。
控制频率
L3的关节控制频率可以达到500Hz,灵巧手的控制频率是83Hz(串行数据)
底层关节控制接口
1. 关节控制命令接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/hybrid_body_controller/commands | ROS2 Topic | 发布关节控制命令 | xbot_common_interfaces/msg/HybridJointCommand |
xbot_common_interfaces/msg/HybridJointCommand参数说明:- header:标准消息头(含时间戳和 frame_id)
- joint_name:string[],关节名称列表,对应每个控制关节
- position:float64[],每个关节的目标位置(rad)
- velocity:float64[],每个关节的目标速度(rad/s)
- feedforward:float64[],前馈力或力矩(N·m)
- kp:float64[],每个关节的比例增益
- kd:float64[],每个关节的微分增益当前力/力矩
2. 手关节控制命令接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/hand_controller/commands | ROS2 Topic | 发布关节控制命令 | xbot_common_interfaces/msg/HybridJointCommand |
xbot_common_interfaces/msg/HybridJointCommand参数说明:- header:标准消息头(含时间戳和 frame_id)
- joint_name:string[],关节名称列表,对应每个控制关节
- position:float64[],每个关节的目标位置(rad)
- velocity:float64[],每个关节的目标速度(rad/s)
- feedforward:float64[],前馈力或力矩(N·m)
- kp:float64[],每个关节的比例增益
- kd:float64[],每个关节的微分增益当前力/力矩
3. 关节状态接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/joint_states | ROS2 Topic | 发布关节控制命令 | sensor_msgs/msg/JointState |
sensor_msgs/msg/JointState参数说明:- header:标准消息头(含时间戳和 frame_id)
- name:string[],所有关节名称
- position:float64[],每个关节的目标位置(rad)
- velocity:float64[],每个关节的目标速度(rad/s)
- effort:float64[],关节力矩(N·m)
4. Hand Sensor状态接口
XHAND
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/hand_sensor | ROS2 Topic | 发布关节状态命令 | xbot_common_interfaces::msg::XhandHandSensor |
xbot_common_interfaces::msg::XhandHandSensor参数说明:- header:标准消息头(含时间戳和 frame_id)
- hand_type:string[],手类型
- fx:int8[],手指在x方向的力,单位 0.1N
- fy:int8[],手指在y方向的力,单位 0.1N
- fz:int8[],手指在z方向的力,单位 0.1N
- temperature:uint8[],手指温度,摄氏度
- calc_temperature:uint8,计算得到的温度,摄氏度
每个 Sensor 包含 121 组 fx、fy、fz 数据:第一组是合力,剩余 120 组是分力,按 10 * 12 排列。
总共 5 个 Sensor,ID 为 0x11、0x12、0x13、0x14、0x15。
5. 读取IMU信息
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/imu_feedback | ROS2 Topic | 发布关节控制命令 | xbot_common_interfaces/msg/Imu |
xbot_common_interfaces/msg/Imu参数说明:- orientation_x:float64 四元数 x 分量
- orientation_y:float64 四元数 y 分量
- orientation_z:float64 四元数 z 分量
- orientation_w:float64 四元数 w 分量
- roll:float64 绕 X 轴旋转角(弧度)
- pitch:float64 绕 Y 轴旋转角(弧度)
- yaw:float64 绕 Z 轴旋转角(弧度)
- angular_vel_x:float64 X 轴角速度(rad/s)
- angular_vel_y:float64 Y 轴角速度(rad/s)
- angular_vel_z:float64 Z 轴角速度(rad/s)
- linear_acc_x:float64 X 轴线加速度(m/s²)
- linear_acc_y:float64 Y 轴线加速度(m/s²)
- linear_acc_z:float64 Z 轴线加速度(m/s²)
底层关节控制示例
通过命令行进行控制
L3整机关节使用Ethercat进行通信,因此在启动前,请先确认机器人硬件状态。当前L3支持如下模式:
# 带有左右两只XHAND的全身形态 位置模式
launch_mode: 'pos'
# 未安装XHAND的全身形态 位置模式
launch_mode: 'no_hand_pos'
# 带有左右两只XHAND的全身形态 力矩模式
launch_mode: 'pd'
# 未安装XHAND的全身形态 力矩模式
launch_mode: 'no_hand_pd'以启动带有左右两只XHAND的全身形态为例,启动脚本如下:
#ssh连接机器人后端, 进入工作空间
ssh developer@192.168.8.100 -p 2222
# 启动关节服务
ros2 service call /dynamic_launch xbot_common_interfaces/srv/DynamicLaunch "app_name: ''
sync_control: false
launch_mode: 'pos'"
# 初始化关节模组,此过程需要大概20秒
ros2 service call /ready_service std_srvs/srv/Trigger {}
# 将关节设置到标准起始位置,此过程需要大概4秒
ros2 action send_goal /simple_actions xbot_common_interfaces/action/SimpleActions "{action_name: 'initpose_handsdown', time_cost: 4.0}"
# 小臂抬起
ros2 action send_goal /simple_actions xbot_common_interfaces/action/SimpleActions "{action_name: 'lift_up', time_cost: 4.0}"
# Xhand 双手微微握住(注意执行前需执行上一步骤,以抬起手臂)
ros2 topic pub /hand_controller/commands xbot_common_interfaces/msg/HybridJointCommand "header:
stamp:
sec: 0
nanosec: 0
frame_id: ''
joint_name: ['left_hand_thumb_bend_joint', 'left_hand_thumb_rota_joint1', 'left_hand_thumb_rota_joint2', 'left_hand_index_bend_joint', 'left_hand_index_joint1', 'left_hand_index_joint2',
'left_hand_mid_joint1', 'left_hand_mid_joint2', 'left_hand_ring_joint1', 'left_hand_ring_joint2', 'left_hand_pinky_joint1', 'left_hand_pinky_joint2',
'right_hand_thumb_bend_joint', 'right_hand_thumb_rota_joint1', 'right_hand_thumb_rota_joint2', 'right_hand_index_bend_joint', 'right_hand_index_joint1', 'right_hand_index_joint2',
'right_hand_mid_joint1', 'right_hand_mid_joint2', 'right_hand_ring_joint1', 'right_hand_ring_joint2', 'right_hand_pinky_joint1', 'right_hand_pinky_joint2']
position: [0.5, 0.5, 1.0, 0.3, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
0.5, 0.5, 1.0, 0.3, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
velocity: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
feedforward: [350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0,
350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0, 350.0]
kp: [100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0,
100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]
kd: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]"
#开启算法控制权限
ros2 service call /activate_service std_srvs/srv/Trigger {}
# 读取关节信息
ros2 topic echo /joint_states --once
# 读取IMU信息
ros2 topic echo /imu_feedback --once
# 停止底层关节控制服务
ros2 service call /stop_launch std_srvs/srv/Trigger {}python示例代码:
import rclpy
from rclpy.node import Node
from xbot_common_interfaces.srv import DynamicLaunch, SwitchController
from std_srvs.srv import Trigger
from xbot_common_interfaces.action import SimpleTrajectory
from rclpy.action import ActionClient
from sensor_msgs.msg import JointState
from xbot_common_interfaces.msg import Imu
import time
class RobotStartupDemo(Node):
def __init__(self):
super().__init__('robot_startup_demo')
# Service clients
self.dynamic_launch_cli = self.create_client(DynamicLaunch, '/dynamic_launch')
self.ready_service_cli = self.create_client(Trigger, '/ready_service')
self.activate_cli = self.create_client(Trigger, '/activate_service')
self.stop_launch_cli = self.create_client(Trigger, '/stop_launch')
# Action client
self.traj_client = ActionClient(self, SimpleTrajectory, '/simple_trajectory')
# 状态读取相关
self.joint_state_sub = None
self.imu_sub = None
self.joint_state_msg = None
self.imu_msg = None
def call_service(self, client, request):
future = client.call_async(request)
rclpy.spin_until_future_complete(self, future)
return future.result()
def wait_for_services(self):
self.get_logger().info('等待服务...')
self.dynamic_launch_cli.wait_for_service()
self.ready_service_cli.wait_for_service()
self.activate_cli.wait_for_service()
self.stop_launch_cli.wait_for_service()
def run_startup_sequence(self):
self.wait_for_services()
# 1. 启动关节服务
self.get_logger().info('启动关节服务...')
dyn_launch_req = DynamicLaunch.Request()
dyn_launch_req.app_name = ''
dyn_launch_req.sync_control = False
dyn_launch_req.launch_mode = 'pos'
self.call_service(self.dynamic_launch_cli, dyn_launch_req)
# 2. 初始化关节模组
self.get_logger().info('初始化关节模组...')
self.call_service(self.ready_service_cli, Trigger.Request())
time.sleep(20) # 按文档建议,实际部署时可优化等待逻辑
# 3. 关节归零(发送action goal)
self.get_logger().info('关节设置到标准起始位置...')
goal_msg = SimpleTrajectory.Goal()
goal_msg.traj_type = 0
goal_msg.duration = 4.0
self.traj_client.wait_for_server()
send_goal_future = self.traj_client.send_goal_async(goal_msg)
rclpy.spin_until_future_complete(self, send_goal_future)
goal_handle = send_goal_future.result()
if not goal_handle.accepted:
self.get_logger().error('轨迹Action Goal未被接受')
return
get_result_future = goal_handle.get_result_async()
rclpy.spin_until_future_complete(self, get_result_future)
time.sleep(2) # 等待归零过程完成
# 4. 开启算法控制权限
self.call_service(self.activate_cli, Trigger.Request())
# 5. 读取关节信息
self.get_logger().info('读取一条关节状态...')
self.joint_state_msg = None
self.joint_state_sub = self.create_subscription(
JointState, '/joint_states', self.joint_state_callback, 10
)
self.wait_for_msg('joint_state_msg')
# 6. 读取IMU信息
self.get_logger().info('读取一条IMU状态...')
self.imu_msg = None
self.imu_sub = self.create_subscription(
Imu, '/imu_feedback', self.imu_callback, 10
)
self.wait_for_msg('imu_msg')
# 7. 停止底层关节控制服务
self.get_logger().info('停止底层关节控制服务...')
self.call_service(self.stop_launch_cli, Trigger.Request())
self.get_logger().info('流程结束。')
def joint_state_callback(self, msg):
if self.joint_state_msg is None:
self.joint_state_msg = msg
self.get_logger().info(f'收到关节状态: {msg}')
self.joint_state_sub.destroy()
def imu_callback(self, msg):
if self.imu_msg is None:
self.imu_msg = msg
self.get_logger().info(f'收到IMU状态: {msg}')
self.imu_sub.destroy()
def wait_for_msg(self, attr_name, timeout=5.0):
start = time.time()
while getattr(self, attr_name) is None and rclpy.ok():
if time.time() - start > timeout:
self.get_logger().warning(f'{attr_name} 获取超时')
break
rclpy.spin_once(self, timeout_sec=0.1)
def main(args=None):
rclpy.init(args=args)
node = RobotStartupDemo()
node.run_startup_sequence()
node.destroy_node()
rclpy.shutdown()
if __name__ == '__main__':
main()整机标零
- 取出标定工装,按标定工装规范将机器固定在标定工装加上
- 确认完成机器人在标定工装上的安装后,启动启动机器e
#ssh连接机器人后端, 进入工作空间
ssh developer@192.168.8.100 -p 2222
# 以PD模式启动关节服务
ros2 service call /dynamic_launch xbot_common_interfaces/srv/DynamicLaunch "app_name: ''
sync_control: false
launch_mode: 'pd'"
# 初始化关节模组,此过程需要大概20秒
ros2 service call /ready_service std_srvs/srv/Trigger {}
# 调用标零服务
ros2 service call /set_zero_pos std_srvs/srv/Trigger {}
# 返回 True 后,停止底层关节控制服务
ros2 service call /stop_launch std_srvs/srv/Trigger {}
# 使用急停遥控器,按“D”键两次,将关节重新上下电
# 再次启动关节服务
ros2 service call /dynamic_launch xbot_common_interfaces/srv/DynamicLaunch "app_name: ''
sync_control: false
launch_mode: 'pd'"
# 初始化关节模组,此过程需要大概20秒
ros2 service call /ready_service std_srvs/srv/Trigger {}
# 标定结果验证
ros2 topic echo /joint_states
# 查看 position 数值,若须知绝对值低于 0.02 ,即表示标定成功;
# 否则,查看关节位置是否到位,确定到位后,再重新执行以上步骤上层控制SDK
注意:上层控制SDK的运行依赖于下层控制,请先完成底层关节控制服务再调用上层控制。
Locomotion接口说明
Locomotion是基于强化学习的双足机器人运动控制程序,通过强化学习,调用下层SDK实现机器人的行走和移动。
1. setMode 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/locomotion/set_contoller_mode | ROS2 Service | 设置运动模式 | xbot_common_interfaces/srv/SetRLMode |
xbot_common_interfaces/srv/SetRLMode定义如下:yaml# 请求部分:输入目标模式 int16 controller_mode #切换不同的policy int16 sub_mode #同一policy内部不同的模式 --- # 响应部分:返回执行结果 bool success string message其中,controller_mode 和 sub_mode 数值对应关系如下:
controller_mode: 4:行走
2. move 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/locomotion/move | ROS2 Topic | 控制机器人移动 | xbot_common_interfaces/msg/LowMoveCmdsMsg |
move接口将会控制机器人移动,需要连续发送以确保机器人连续行走,发送停止后1秒机器人将会停止移动。
xbot_common_interfaces/msg/LowMoveCmdsMsg 消息定义如下:
- float32[] move
其中,move 数组结构说明:
move[0]:前后移动,范围[-1, 1],1表示向前最大速度move[1]:左右移动,范围[-1, 1],1表示向右最大速度move[2]:左右旋转,范围[-1, 1],1表示右转最大速度move[3]:高度,归一化float值
3 get_status接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/locomotion/get_status | ROS2 Topic | 实时微调当前姿态 | xbot_common_interfaces/msg/RLStatus |
获取当前Locomotion的所有命令和状态.
xbot_common_interfaces/msg/RLStatus 消息定义如下:
int16 controller_mode_status #当前处于的policy状态
int16 sub_mode_status #同一policy内部不同的模式的状态
string controller_mode_name_str #当前处于的policy名字
LocoStatus loco_status
MimicStatus mimic_statusLocoStatus类型定义如下:- float32[] sub_move_cmds(表示当前速度)
sub_move_cmds数组含义如下:sub_move_cmds[0]:前后当前移动速度sub_move_cmds[1]:左右当前移动速度sub_move_cmds[2]:当前 yawsub_move_cmds[3]:当前高度
mimic_status类型定义如下:- 预留动作的执行状态,可不关注
使用Locomotion
exclamation 如需使用,请先启动机器人完成“初始化关节模组”这一步再继续。
通过命令行使用
如果使用内置的行走、上肢控制算法,需调用此接口,接通算法控制
#ssh连接机器人后端, 进入工作空间
ssh developer@192.168.8.100 -p 2222
# 通过下层SDK启动机器人关节电机
# 让机器人进入零位
# 将机器人从吊架上放下
# 此处省略,请参考底层关节控制部分
# 下载 l3_pub_client.py
git clone https://github.com/roboterax/teleop_client.git
cd teleop_client
colcon build
cp ~/teleop_client/l3_pub_client.py ~/
cd ~/
# 开启算法控制权限
ros2 service call /activate_service std_srvs/srv/Trigger {}
python l3_pub_client.py --type webxr --cmd start --camera-type realsense
python l3_pub_client.py --type retargetx --cmd start --mocap gamepad --hand xhand
# 启动 mpc 算法
python l3_pub_client.py --type mpc --cmd start
# 启动Locomotion算法
python l3_pub_client.py --type rl --cmd start
# rl 进入 ready 状态,让机器人双脚站地
ros2 service call /locomotion/set_contoller_mode xbot_common_interfaces/srv/SetRLMode "controller_mode: 2
sub_mode: 0"
# 启动行走模式
ros2 service call /locomotion/set_contoller_mode xbot_common_interfaces/srv/SetRLMode "controller_mode: 4
sub_mode: 0"
# 机器人向前移动。-r 表示消息频率是 5hz,不能小于 2hz,否则就会有卡顿现象。ctrl C 停止发送数据,机器人会停止运行
ros2 topic pub -r 5 /locomotion/move xbot_common_interfaces/msg/LowMoveCmdsMsg "move: [0.5,0.0,0.0,0.97]"
# 机器人向后移动。-r 表示消息频率是 5hz,不能小于 2hz,否则就会有卡顿现象。ctrl C 停止发送数据,机器人会停止运行
ros2 topic pub -r 5 /locomotion/move xbot_common_interfaces/msg/LowMoveCmdsMsg "{move: [-0.5,0.0,0.0,0.97]}"
# 机器人向左移动。-r 表示消息频率是 5hz,不能小于 2hz,否则就会有卡顿现象。ctrl C 停止发送数据,机器人会停止运行
ros2 topic pub -r 5 /locomotion/move xbot_common_interfaces/msg/LowMoveCmdsMsg "move: [0.0,0.2,0.0,0.97]"
# 机器人向右移动。-r 表示消息频率是 5hz,不能小于 2hz,否则就会有卡顿现象。ctrl C 停止发送数据,机器人会停止运行
ros2 topic pub -r 5 /locomotion/move xbot_common_interfaces/msg/LowMoveCmdsMsg "move: [0.0,-0.2,0.0,0.97]"
# 机器人基于当前位置转动。-r 表示消息频率是 5hz,不能小于 2hz,否则就会有卡顿现象。ctrl C 停止发送数据,机器人会停止运行
ros2 topic pub -r 5 /locomotion/move xbot_common_interfaces/msg/LowMoveCmdsMsg "move: [0.0,0.0,0.2,0.97]"
# 此后应该将机器人吊起,并关闭控制SDK,请参考底层关节控制部分python代码示例:
#!/usr/bin/env python3
import subprocess
import time
import rclpy
from rclpy.node import Node
from std_srvs.srv import Trigger
from xbot_common_interfaces.srv import SetRLMode
from xbot_common_interfaces.msg import LowMoveCmdsMsg
class LocomotionDemo(Node):
def __init__(self):
super().__init__('locomotion_demo')
self.cli_activate = self.create_client(Trigger, '/activate_service')
self.cli_set_rl_mode = self.create_client(SetRLMode, '/locomotion/set_contoller_mode')
self.move_pub = self.create_publisher(LowMoveCmdsMsg, '/locomotion/move', 10)
self.get_logger().info('等待各服务...')
self.cli_activate.wait_for_service()
self.cli_set_rl_mode.wait_for_service()
def call_service(self, client, request):
future = client.call_async(request)
rclpy.spin_until_future_complete(self, future)
return future.result()
def set_rl_mode(self, controller_mode: int, sub_mode: int = 0):
req = SetRLMode.Request()
req.controller_mode = controller_mode
req.sub_mode = sub_mode
return self.call_service(self.cli_set_rl_mode, req)
def publish_move_at_hz(self, move_msg: LowMoveCmdsMsg, hz: float, duration_sec: float):
"""按固定频率发布 move;频率需 ≥2Hz,否则易卡顿。"""
if hz < 2.0:
self.get_logger().warn(f'发布频率 {hz} Hz 低于 2 Hz,可能出现卡顿')
period = 1.0 / hz
deadline = time.monotonic() + duration_sec
while time.monotonic() < deadline:
self.move_pub.publish(move_msg)
time.sleep(period)
def run_sequence(self):
# 开启 Locomotion 算法控制权限
self.get_logger().info('开启 Locomotion 算法控制权限...')
self.call_service(self.cli_activate, Trigger.Request())
time.sleep(1)
# 启动 Locomotion 算法(需在可找到 l3_pub_client.py 的工作目录下运行本节点)
self.get_logger().info('启动 Locomotion 算法...')
subprocess.run(
['python', 'l3_pub_client.py', '--type', 'rl', '--cmd', 'start'],
check=False,
)
time.sleep(1)
# RL ready:双脚站地
self.get_logger().info('设置为 RL ready(controller_mode=2, sub_mode=0)...')
self.set_rl_mode(2, 0)
time.sleep(1)
# 行走模式
self.get_logger().info('设置为行走模式(controller_mode=4, sub_mode=0)...')
self.set_rl_mode(4, 0)
time.sleep(1)
# 持续以 5Hz 发布 move;停止发布后机器人会停下
self.get_logger().info('以 5Hz 发布 move(向前 0.5,第四维 0.97),持续 1 秒...')
move_msg = LowMoveCmdsMsg()
move_msg.move = [0.5, 0.0, 0.0, 0.97]
self.publish_move_at_hz(move_msg, hz=5.0, duration_sec=1.0)
# 回到站立 / ready
self.get_logger().info('设置为 RL ready(站立)...')
self.set_rl_mode(2, 0)
time.sleep(1)
self.get_logger().info('停止算法程序...')
subprocess.run(
['python', 'l3_pub_client.py', '--type', 'rl', '--cmd', 'stop'],
check=False,
)
self.get_logger().info('操作流程结束。')
def main(args=None):
rclpy.init(args=args)
node = LocomotionDemo()
try:
node.run_sequence()
finally:
node.destroy_node()
rclpy.shutdown()
if __name__ == '__main__':
main()MPC接口说明
exclamation 使用此接口时,请遵循以下步骤和注意事项以确保操作的稳定性和安全性:
- 读取当前位姿:在发送控制指令前,应先读取当前的机械臂位姿,以作为轨迹控制的起点。
- 逐步接近目标:推荐以较小的增量连续发送目标位姿,逐步引导机械臂到达目标位置。
- 避免剧烈动作:请避免一次性发送跨度过大的位姿变换。快速或大范围移动可能导致机械臂运动不稳定或引发安全风险。
- 建议结合轨迹规划:此接口适用于连续控制,建议结合外部轨迹生成器或平滑算法,以提高控制精度与安全性。
1. servoPose 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/servo_poses | ROS2 Topic | 控制左右手目标位姿 | xbot_common_interfaces/msg/ServoPose |
ServoPose.msg包括三个字段:- geometry_msgs/PoseStamped left_pose
- geometry_msgs/PoseStamped right_pose
- geometry_msgs/PoseStamped head_pose
geometry_msgs/PoseStamped结构:- std_msgs/Header header
- geometry_msgs/Pose pose
2. getPose 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/get_pose | ROS2 Topic | 获取左右手当前位姿 | xbot_common_interfaces/msg/ServoPose |
ServoPose.msg包括两个字段:- geometry_msgs/PoseStamped left_pose
- geometry_msgs/PoseStamped right_pose
- geometry_msgs/PoseStamped head_pose
geometry_msgs/PoseStamped结构:- std_msgs/Header header
- geometry_msgs/Pose pose
使用MPC
exclamation 上肢控制是针对腰部,头部和双臂操作的控制程序,通过dynamic精确控制手臂末端到设定位置。如需使用,请先启动机器人到“初始化关节模组”这一步再继续。
通过命令行使用
#ssh连接机器人后端, 进入工作空间
ssh developer@192.168.8.100 -p 2222
# 通过下层SDK启动机器人关节电机
# 让机器人进入零位
# 将机器人从吊架上放下
# 此处省略,请参考底层关节控制部分
# 开启算法控制权限
ros2 service call /activate_service std_srvs/srv/Trigger {}
# 下载 l3_pub_client.py,用于启动 mpc
git clone https://github.com/roboterax/teleop_client.git
cd teleop_client
colcon build
source install/setup.bash
# 启动MPC算法
python l3_pub_client.py --type mpc --cmd start
# 查看 MPC 状态,status返回值为1表示已启动,0为未启动
python l3_pub_client.py --type mpc --cmd query
#上肢摆动开启
ros2 service call /set_rl_ctrl_upperlimb std_srvs/srv/SetBool "data: true"
#上肢摆动关闭
ros2 service call /set_rl_ctrl_upperlimb std_srvs/srv/SetBool "data: false"
# reset mpc 0抬手 1 放手
# --mode 0 也是开启 mpc 后机器人的初始位置
python l3_pub_client.py --type mpc --cmd reset --mode 0 | 1
# 单独 ros 命令控制抬手。-r 后面表示消息发送频率,-r 100 就表示 100hz,这个参数可以控制速度
ros2 topic pub -r 100 /servo_poses xbot_common_interfaces/msg/ServoPose "{
left_pose: {
header: {frame_id: 'base_link'},
pose: {position: {x: 0.425, y: 0.3, z: 0.292}, orientation: {x: 0.612, y: -0.016, z: 0.79, w: -0.006}}
},
right_pose: {
header: {frame_id: 'base_link'},
pose: {position: {x: 0.417, y: -0.146, z: 0.382}, orientation: {x: 0.521, y: 0.1, z: 0.842, w: -0.096}}
},
head_pose: {
header: {frame_id: 'base_link'},
pose: {position: {x: 0.0, y: 0.0, z: 0.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}
}
}"
# 录制动作
ros2 bag record /hand_controller/commands /servo_poses -o mpc_demo
# 停止MPC算法
python l3_pub_client.py --type mpc --cmd stoppython代码示例
import rclpy
from rclpy.node import Node
from std_srvs.srv import Trigger
import subprocess
import time
import textwrap
class MPCStartupDemo(Node):
def __init__(self):
super().__init__('mpc_startup_demo')
self.cli_activate = self.create_client(Trigger, '/activate_service')
self.cli_activate.wait_for_service()
def call_activate_service(self):
self.get_logger().info('开启算法控制权限...')
req = Trigger.Request()
future = self.cli_activate.call_async(req)
rclpy.spin_until_future_complete(self, future)
resp = future.result()
if resp.success:
self.get_logger().info('算法控制权限开启成功')
else:
self.get_logger().error(f'开启失败: {resp.message}')
def launch_mpc(self):
self.get_logger().info('启动MPC算法...')
# 启动ros2 launch进程(注意:如需交互终端请用shell=True,或使用subprocess.Popen异步模式)
# 这里用Popen,可Ctrl+C终止
subprocess.run(["python", "l3_pub_client.py", "--type", "mpc", "--cmd", "start"])
self.get_logger().info('MPC算法已启动(如需停止请手动Ctrl+C终止此脚本)')
def publish_servo_pose_rate(self, rate_hz: int = 10):
"""以指定频率连续发布抬手位姿到 /servo_poses(默认 10Hz)"""
message = textwrap.dedent(
"""
{
left_pose: {
header: {frame_id: 'base_link'},
pose: {position: {x: 0.425, y: 0.3, z: 0.292}, orientation: {x: 0.612, y: -0.016, z: 0.79, w: -0.006}}
},
right_pose: {
header: {frame_id: 'base_link'},
pose: {position: {x: 0.417, y: -0.146, z: 0.382}, orientation: {x: 0.521, y: 0.1, z: 0.842, w: -0.096}}
},
head_pose: {
header: {frame_id: 'base_link'},
pose: {position: {x: 0.0, y: 0.0, z: 0.0}, orientation: {x: 0.0, y: 0.0, z: 0.0, w: 1.0}}
}
}
"""
).strip()
self.get_logger().info(f'以 {rate_hz}Hz 频率发布 /servo_poses 抬手指令...')
subprocess.run([
'ros2', 'topic', 'pub', '-r', str(rate_hz),
'/servo_poses', 'xbot_common_interfaces/msg/ServoPose',
message
], check=True)
def main(args=None):
rclpy.init(args=args)
node = MPCStartupDemo()
node.call_activate_service()
# 暂停1秒确保服务完全生效
time.sleep(1)
node.launch_mpc()
node.publish_servo_pose_rate()
node.destroy_node()
rclpy.spin(node)
rclpy.shutdown()
subprocess.run(["python", "l3_pub_client.py", "--type", "mpc", "--cmd", "stop"])
if __name__ == '__main__':
main()控制机器人播放录制好的动作
在播放动作前,请将录制好的动作通过XOS界面上传到机器人内。
动作录制请使用遥操作。
接口说明:
1. upper_limb_play 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/gesture/upper_limb_play | ROS2 Topic | 播放内置的动作 | std_msgs/msg/String |
std_msgs/msg/String:内置动作的名称
2. is_play 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/gesture/is_play | ROS2 Service | 查询是否有动作正在播放 | std_srvs/srv/Trigger |
std_srvs/srv/Trigger:返回是否正在播放
3. stop_play 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/gesture/stop_play | ROS2 Service | 停止播放 | std_srvs/srv/Trigger |
std_srvs/srv/Trigger:返回是否正在播放
4. rosbag_list 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/gesture/rosbag_list | ROS2 Service | 查询动作列表 | xbot_common_interfaces/srv/StringMessage |
xbot_common_interfaces/srv/StringMessage- string data # 不用传
Result
- bool result # 查询成功或失败
- string message # 列表的数组转成的字符串
示例:
ros2 service call /gesture/rosbag_list xbot_common_interfaces/srv/StringMessage {}
requester: making request: xbot_common_interfaces.srv.StringMessage_Request(data='')
response:
xbot_common_interfaces.srv.StringMessage_Response(result=True, message='[{"rosbag_name": "run2", "create_time": "2025-05-09 10:20:21", "size": 40633852, "file_size": "38.75 MB", "action_type": "交互动作", "duration_ms": 96825.59, "duration_s": 96.82558999999999, "is_playing": false, "is_paused": false}, {"rosbag_name": "run3", "create_time": "2025-05-09 10:20:06", "size": 40875516, "file_size": "38.98 MB", "action_type": "交互动作", "duration_ms": 97372.486, "duration_s": 97.37248600000001, "is_playing": false, "is_paused": false}]')使用动作播放
通过命令行使用
#ssh连接机器人后端, 进入工作空间
ssh developer@192.168.8.100 -p 2222
# 通过下层SDK启动机器人关节电机
# 让机器人进入零位
# 将机器人从吊架上放下
# 此处省略,请参考底层关节控制部分
# 开启算法控制权限
ros2 service call /activate_service std_srvs/srv/Trigger {}
# 启动MPC算法
python l3_pub_client.py --type mpc --cmd start
# 等待MPC启动完成
sleep 3
# 例如播放一个名称叫做hello的动作,命令如下
# 注意,动作需要提前上传到XOS系统中,请参考XOS操作文档
ros2 topic pub -1 /gesture/upper_limb_play std_msgs/msg/String "data: 'hello'"
# 查询rosbag是否正在播放
# 返回示例:
# std_srvs.srv.Trigger_Response(success=False, message='No rosbag is playing.')
ros2 service call /gesture/is_play std_srvs/srv/Trigger {}
# 等待动作播放
sleep 3
# 停止rosbag播放
# 返回示例:
# std_srvs.srv.Trigger_Response(success=True, message='Rosbag playback stopped.')
ros2 service call /gesture/stop_play std_srvs/srv/Trigger {}
# 查询 rosbag 列表
ros2 service call /gesture/rosbag_list xbot_common_interfaces/srv/StringMessage {}python代码示例
import rclpy
from rclpy.node import Node
from std_srvs.srv import Trigger
from std_msgs.msg import String
from xbot_common_interfaces.srv import StringMessage
import subprocess
import time, json
class GestureDemo(Node):
def __init__(self):
super().__init__('gesture_demo')
# Service clients
self.cli_activate = self.create_client(Trigger, '/activate_service')
self.cli_is_play = self.create_client(Trigger, '/gesture/is_play')
self.cli_stop_play = self.create_client(Trigger, '/gesture/stop_play')
self.cli_rosbag_list = self.create_client(StringMessage, '/gesture/rosbag_list')
# Publisher
self.gesture_pub = self.create_publisher(String, '/gesture/upper_limb_play', 10)
# 等待service接口可用
self.get_logger().info('等待服务...')
self.cli_activate.wait_for_service()
self.cli_is_play.wait_for_service()
self.cli_stop_play.wait_for_service()
self.cli_rosbag_list.wait_for_service()
def call_service(self, client, request):
future = client.call_async(request)
rclpy.spin_until_future_complete(self, future)
return future.result()
def run_sequence(self):
# # 通过下层SDK启动机器人关节电机
# # 让机器人进入零位
# # 将机器人从吊架上放下
# # 此处省略,请参考底层关节控制部分
# # 开启算法控制权限
self.get_logger().info('开启算法控制权限...')
self.call_service(self.cli_activate, Trigger.Request())
# # 启动MPC算法
self.get_logger().info('启动MPC算法...')
subprocess.run(["python", "l3_pub_client.py --type mpc --cmd start"])
# # 等待MPC启动完成
self.get_logger().info('等待MPC算法启动...')
time.sleep(3)
# # 播放名为 hello 的动作
self.get_logger().info("播放动作 'hello' ...")
gesture_msg = String()
gesture_msg.data = 'hello'
self.gesture_pub.publish(gesture_msg)
# # 查询rosbag是否正在播放
self.get_logger().info("查询rosbag是否正在播放 ...")
resp = self.call_service(self.cli_is_play, Trigger.Request())
self.get_logger().info(f'播放状态: success={resp.success}, message="{resp.message}"')
# # 等待动作播放
self.get_logger().info('等待动作播放...')
time.sleep(3)
# # 停止rosbag播放
self.get_logger().info('停止rosbag播放 ...')
resp = self.call_service(self.cli_stop_play, Trigger.Request())
self.get_logger().info(f'停止播放: success={resp.success}, message="{resp.message}"')
# # 终止MPC算法
self.get_logger().info('准备终止MPC算法...')
subprocess.run(["python", "l3_pub_client.py --type mpc --cmd stop"])
self.get_logger().info('MPC算法已终止')
# 查询动作列表
self.get_logger().info('查询动作列表...')
list_req = StringMessage.Request()
list_req.data = ''
resp = self.call_service(self.cli_rosbag_list, list_req)
self.get_logger().info(f'动作列表返回: success={resp.result}, list_str="{resp.message}"')
if resp.result and resp.message:
audio_list = json.loads(resp.message)
def main(args=None):
rclpy.init(args=args)
node = GestureDemo()
node.run_sequence()
node.destroy_node()
rclpy.shutdown()
if __name__ == '__main__':
main()控制机器人播放音频
在播放音频前,请将准备好的音频通过XOS界面上传到机器人内。
接口说明:
1. play 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/audio_player/play | ROS2 Action | 播放内置的音频 | xbot_common_interfaces/action/AudioPlay |
xbot_common_interfaces/action/AudioPlay- int32 ID=0
- int32 PATH=1
- int32 ITEM=2
- int32 mode # 1: 使用 path, 2: 使用 item(JSON 或字典格式字符串)3:使用文件名file_name
- bool force_play # true: 强制播放,中断正在播放的音频;false:默认逻辑
- int32 id # 当 mode==0 时使用, 暂不支持
- string path # 当 mode==1 时使用
- string item # 当 mode==2 时使用;例如:
- string file_name #当 mode==3 时使用;例如:
- int32 timeout # 播放超时时间(单位秒) Result
- bool success # 成功或失败
- string message # 成功或失败原因 Feedback
- float64 progress # 播放进度
2. is_play 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/audio_player/is_play | ROS2 Service | 查询是否正在播放 | std_srvs/srv/Trigger |
std_srvs/srv/Trigger :返回是否正在播放
3. stop_play 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/audio_player/stop_play | ROS2 Service | 停止音频播放 | std_srvs/srv/Trigger |
std_srvs/srv/Trigger :返回是停止播放结果
4. set_volume 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/audio_player/set_volume | ROS2 Service | 音量设置 | xbot_common_interfaces/srv/SetVolume |
xbot_common_interfaces/srv/SetVolume- int32 volume # 支持 0~100 之间的整数值
Result
- bool success # 调整成功或失败
- string message # 成功或失败原因
5. audio_list 接口
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/audio_player/audio_list | ROS2 Service | 查询音频列表 | xbot_common_interfaces/srv/StringMessage |
xbot_common_interfaces/srv/StringMessage- string data # 不用传
Result
- bool result # 查询成功或失败
- string message # 音频列表的数组转成的字符串
示例:
ros2 service call /audio_player/audio_list xbot_common_interfaces/srv/StringMessage {}
requester: making request: xbot_common_interfaces.srv.StringMessage_Request(data='')
response:
xbot_common_interfaces.srv.StringMessage_Response(result=True, message='[{"audio_name": "我是小星.wav", "create_time": "2026-04-08 12:12:18", "size": 257742, "file_size": "251.70 KB", "duration_ms": 8053, "duration_s": 8.053}, {"audio_name": "欢迎各位领导.wav", "create_time": "2025-05-15 18:27:38", "size": 101690, "file_size": "99.31 KB", "duration_ms": 3176, "duration_s": 3.176}]')使用方法
通过命令行使用
# 设置音量为50
ros2 service call /audio_player/set_volume xbot_common_interfaces/srv/SetVolume "volume: 50"
# 通过文件名播放指定音频文件
ros2 action send_goal /audio_player/play xbot_common_interfaces/action/AudioPlay "{mode: 3, force_play: true, file_name: 'hello.wav', timeout: 0}"
# 查询音频是否正在播放
ros2 service call /audio_player/is_play std_srvs/srv/Trigger {}
# 等待音频播放
sleep 3
# 停止音频播放
ros2 service call /audio_player/stop_play std_srvs/srv/Trigger {}
# 音频列表查询
ros2 service call /audio_player/audio_list xbot_common_interfaces/srv/StringMessage {}python代码示例
import rclpy
from rclpy.node import Node
from std_srvs.srv import Trigger
from xbot_common_interfaces.srv import SetVolume
from xbot_common_interfaces.srv import StringMessage
from xbot_common_interfaces.action import AudioPlay
from rclpy.action import ActionClient
import time, json
class AudioPlayerDemo(Node):
def __init__(self):
super().__init__('audio_player_demo')
# Service clients
self.cli_set_volume = self.create_client(SetVolume, '/audio_player/set_volume')
self.cli_is_play = self.create_client(Trigger, '/audio_player/is_play')
self.cli_stop_play = self.create_client(Trigger, '/audio_player/stop_play')
self.cli_audio_list = self.create_client(StringMessage, '/audio_player/audio_list')
# 等待service/action可用
self.get_logger().info('等待服务和action...')
self.cli_set_volume.wait_for_service()
self.cli_is_play.wait_for_service()
self.cli_stop_play.wait_for_service()
self.cli_audio_list.wait_for_service()
def call_service(self, client, request):
future = client.call_async(request)
rclpy.spin_until_future_complete(self, future)
return future.result()
def play_audio(self, mode=0, force_play=False, id=5, path='', timeout=0):
goal = AudioPlay.Goal()
goal.mode = mode
goal.force_play = force_play
goal.id = id
goal.path = path
goal.timeout = timeout
send_goal_future = self.audio_play_client.send_goal_async(goal)
rclpy.spin_until_future_complete(self, send_goal_future)
goal_handle = send_goal_future.result()
if not goal_handle.accepted:
self.get_logger().error('音频播放请求未被接受')
return
# 等待播放完成(也可以读取反馈,见下)
get_result_future = goal_handle.get_result_async()
rclpy.spin_until_future_complete(self, get_result_future)
result = get_result_future.result().result
self.get_logger().info(f'音频播放结果: success={result.success}, message={result.message}')
def run_sequence(self):
# 1. 设置音量为50
self.get_logger().info('设置音量为50...')
vol_req = SetVolume.Request()
vol_req.volume = 50
resp = self.call_service(self.cli_set_volume, vol_req)
self.get_logger().info(f'音量设置: success={resp.success}, message="{resp.message}"')
# # 如需通过路径播放音频,取消下行注释
# self.get_logger().info('通过路径播放指定音频...')
# self.play_audio(mode=1, force_play=True, id=0, path='/XOS/XOS/data/audio/replay_wav/hello.wav', timeout=0)
# 2. 查询音频是否正在播放
self.get_logger().info('查询音频是否正在播放...')
resp = self.call_service(self.cli_is_play, Trigger.Request())
self.get_logger().info(f'是否正在播放: success={resp.success}, message="{resp.message}"')
# 3. 等待音频播放
self.get_logger().info('等待音频播放...')
time.sleep(3)
# 4. 停止音频播放
self.get_logger().info('停止音频播放...')
resp = self.call_service(self.cli_stop_play, Trigger.Request())
self.get_logger().info(f'停止播放: success={resp.success}, message="{resp.message}"')
# 5. 查询音频列表
self.get_logger().info('查询音频列表...')
list_req = StringMessage.Request()
list_req.data = ''
resp = self.call_service(self.cli_audio_list, list_req)
self.get_logger().info(f'音频列表返回: success={resp.result}, list_str="{resp.message}"')
if resp.result and resp.message:
audio_list = json.loads(resp.message)
def main(args=None):
rclpy.init(args=args)
node = AudioPlayerDemo()
node.run_sequence()
node.destroy_node()
rclpy.shutdown()
if __name__ == '__main__':
main()在开发者环境下直接使用音频设备
机器人集成了麦克风和扬声器,可在系统中直接使用
exclamation 在使用音频设备前,请确保在XOS中关闭了对话功能,避免无法打开音频设备
使用方法
通过命令行测试设备是否正常
# 登录到开发者环境 密码为developer
ssh developer@192.168.8.100 -p 2222 #ssh连接机器人后端, 进入工作空间
# 安装音频库
sudo apt update
sudo apt install libportaudio2 python3-pyaudio portaudio19-dev
# 安装虚拟环境
curl -L -A "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36" \
-o python3-pip-whl_22.0.2+dfsg-1_all.deb \
"https://mirrors.ustc.edu.cn/ubuntu/pool/universe/p/python-pip/python3-pip-whl_22.0.2+dfsg-1_all.deb"
sudo dpkg -i python3-pip-whl_22.0.2+dfsg-1_all.deb
sudo apt-get install --fix-broken python3.10-venv
# 创建虚拟环境
python3 -m venv venv
source venv/bin/activate
# 安装依赖 (如果无法安装,可以指定源)
# 阿里源示例: pip install sounddevice scipy -i https://mirrors.aliyun.com/pypi/simple/
# 清华源示例: pip install sounddevice scipy -i https://pypi.tuna.tsinghua.edu.cn/simple/ --trusted-host pypi.tuna.tsinghua.edu.cn
pip install sounddevice scipy
# 给snd设备附加权限避免问题
sudo chmod 777 /dev/snd/*
# 读取声卡信息:
python3 -c "import sounddevice as sd; print(sd.query_devices())"
#如果正常可以看到类似如下内容:
developer@xbot-NUC:~$ python3 -c "import sounddevice as sd; print(sd.query_devices())"
< 0 HD-Audio Generic: HDMI 0 (hw:0,3), ALSA (0 in, 8 out)
1 HD-Audio Generic: HDMI 1 (hw:0,7), ALSA (0 in, 8 out)
2 HD-Audio Generic: HDMI 2 (hw:0,8), ALSA (0 in, 8 out)
3 HD-Audio Generic: HDMI 3 (hw:0,9), ALSA (0 in, 8 out)
> 4 POROSVOC: USB Audio (hw:1,0), ALSA (1 in, 0 out)
5 HD-Audio Generic: ALC897 Analog (hw:2,0), ALSA (2 in, 2 out)
6 USB Audio Device: - (hw:3,0), ALSA (1 in, 2 out)
7 hdmi, ALSA (0 in, 8 out)python代码示例
import sounddevice as sd
import numpy as np
from scipy.signal import resample
duration = 2.0 # 秒
# 根据需求调整输入和输出设备
sd.default.device = (6, 6) # L3默认的音频设备是6号
# 获取默认设备索引
input_device, output_device = sd.default.device
# 获取设备参数
input_info = sd.query_devices(input_device)
output_info = sd.query_devices(output_device)
input_samplerate = int(input_info['default_samplerate'])
output_samplerate = int(output_info['default_samplerate'])
channels = input_info['max_input_channels']
print(f"🎤 正在从默认输入设备(设备 {input_device})录音 {duration} 秒 @ {input_samplerate} Hz, 通道数: {channels}")
sd.default.device = (input_device, output_device)
# 录音
recording = sd.rec(int(input_samplerate * duration), samplerate=input_samplerate, channels=channels, dtype='int16')
sd.wait()
# 音量放大,请根据实际情况调整
amplified = recording * 1
amplified = np.clip(amplified, -32768, 32767).astype(np.int16)
# 如果播放采样率和录音不同,则升/降采样
if input_samplerate != output_samplerate:
print(f"🔁 正在将录音采样率从 {input_samplerate} Hz 转为 {output_samplerate} Hz 以便播放")
num_samples = int(output_samplerate * duration)
amplified = resample(amplified, num_samples).astype(np.int16)
print(f"🔊 正在从默认输出设备(设备 {output_device})播放...")
sd.play(amplified, samplerate=output_samplerate)
sd.wait()
print("✅ 播放完成")在开发者环境下获取电池信息
机器人安装了电池,可在系统中查看电池信息
使用方法
通过命令行获取电池信息
| 接口名称 | 类型 | 功能说明 | 消息类型 |
|---|---|---|---|
/battery_state | ROS2 Topic | 获取电池信息 | sensor_msgs/msg/BatteryState |
BatteryState.msg 是 ROS2 标准接口,主要使用到以下字段:
voltage:电池电压,单位Vtemperature:电池温度,单位℃current:电池电流,单位Acharge:电池当前容量,单位Ahdesign_capacity:电池额定容量,单位Ahpercentage:电池当前电量,单位%power_supply_status:充电状态,0=待机,1=充电,2=放电
ros2 topic echo --once /battery_state在开发者环境下使用深度相机
L3机器人realsense相机,可在开发者环境中直接使用
打开 realsense-viewer 查看设备
- Windows 环境下载mobaxterm访问:https://mobaxterm.mobatek.net/
ssh -X developer@192.168.8.100 -p 2222- Linux 环境重新进入环境:
ssh -X developer@192.168.8.100 -p 2222- 终端下启动 realsense-viewer 可以打开GUI操作
realsense-viewer- 启动 realsense2_camera,可以通过 ros 实时外发图像相关数据
ros2 launch realsense2_camera rs_launch.py
# 如果想设置分辨率
ros2 launch realsense2_camera rs_align_depth_launch.py depth_module.depth_profile:=848x480x60 rgb_camera.color_profile:=848x480x60- 使用 ros2 topic list,查看图像消息
/camera/camera/color/camera_info
/camera/camera/color/image_raw
/camera/camera/color/metadata
/camera/camera/depth/camera_info
/camera/camera/depth/image_rect_raw
/camera/camera/depth/metadata
/camera/camera/extrinsics/depth_to_color
/tf_static| topic 名称 | 数据类型 | 含义 |
|---|---|---|
| /camera/camera/color/camera_info | sensor_msgs/msg/CameraInfo | 彩色相机的内参(K矩阵、畸变参数等) |
| /camera/camera/color/image_raw | sensor_msgs/msg/Image | RGB 彩色图像原始数据 |
| /camera/camera/color/metadata | realsense2_camera_msgs/msg/Metadata | 帧元数据(时间戳、曝光、增益等) |
| /camera/camera/depth/camera_info | sensor_msgs/msg/CameraInfo | 深度相机的内参 |
| /camera/camera/depth/image_rect_raw | sensor_msgs/msg/Image | 对齐或矫正后的深度图 |
| /camera/camera/depth/metadata | realsense2_camera_msgs/msg/Metadata | 帧元数据(时间戳、曝光、增益等) |
| /camera/camera/extrinsics/depth_to_color | realsense2_camera_msgs/msg/Extrinsics | 深度→彩色相机的外参矩阵 |
| /tf_static | tf2_msgs/msg/TFMessage | 静态坐标变换(相机坐标系等) |
在开发者环境下机器人动作的录制和播放
- 启动遥操作
⚠️ 遥操作需两个人同时配合,在停止mpc之前,头显操作人员切勿乱动
- 录制机器人动作
⚠️ 注意:人的动作必须和机器人的动作保持一致后开启遥操作。
#进入develeoper
ssh developer@192.168.8.100 -p 2222 #密码:developer
#如果已经拉取teleop_client
cd teleop_client
colcon build
source install/setup.bash
#如果没有teleop_client目录请执行{遥操作服务启动说明中第一步}
#拉取 teleop_client
git clone https://github.com/roboterax/teleop_client
#录制
ros2 bag record /hand_controller/commands /servo_poses -o [bag package name]
#-o 后面定义保存的包名
#保存录制内容:在录制机器人动作的终端下使用ctrl-c停止录制- 播放机器人动作
#启动sdk 如果sdk已经启动,请不要重复启动
python l3_pub_client.py --cmd start_sdk
# 启动MPC算法
python l3_pub_client.py --type mpc --cmd start
#切换mpc
python l3_pub_client.py --cmd enable_rl --mode 0
#play
ros2 bag play [bag package name]
#[bag package name] 保存的机器人动作
# 停止MPC算法
python l3_pub_client.py --type mpc --cmd stop
# 停止
Ctrl-C mpc终端
python l3_pub_client.py --cmd stop_sdk在开发者环境下配置程序自启动
在开发者环境中,可以通过修改 /ros_entrypoint.sh 配置容器启动时自动运行的程序。该脚本会在开发者环境启动时执行,适合用于添加需要随环境启动的后台服务或用户程序。
打开并编辑
/ros_entrypoint.sh文件。在最后一行
exec "$@"前添加需要自启动的程序命令。例如:
#!/bin/bash
set -e
# setup ros2 environment
source "/opt/ros/$ROS_DISTRO/setup.bash"
sudo /usr/sbin/sshd -D &
sudo bash /usr/local/bin/maps/video.sh &
exec "$@"注意:添加的进程命令末尾需要带上 & 符号,表示后台运行。
维护与保养
电池充电与更换
为保证机器人的电池性能和使用寿命,请在适当温度下进行充电和使用,避免过度充电和放电,并定期进行检查和维护。电池应存放在干燥、通风良好的环境中,避免阳光直射和极端温度发现电池性能下降或损坏时,应及时更换。遵循这些维护建议可以有效延长电池的使用寿命,确保机器人安全。
日常保养
机器人电池的日常保养非常重要,它能够确保机器人的正常运行并延长电池的使用寿命。以下是一些基本的保养技巧和注意事项:
- 电池充电:新电池在第一次使用前应完全充电。即使长时间不使用,也应每月至少完全充电一次,以避免电池老化 ;
- 电池更换:机器人的后备电池应定期更换,例如机器人的保养周期可以是一年半,并且当电池电压下降报警时也应及时更换 ;
- 电池使用:电池充电通常只需3-4小时,使用时间根据使用情况可从45分钟到4小时不等。建议电池充电状态保持在30%到70-80%之间,避免长时间保持电量100%或电量低于30%,这会加速电池老化 ;
- 电池存储:如果机器人长时间不使用,应将电池存储在适当的条件下,避免深度放电,并至少每1个月充电一次 ;
- 电池维护:日常维护中,应注意检查电池电压,及时更换显示电压下降报警的电池,并在更换电池时注意关闭机器人的电力、气压、液压供给 ;
- 安全操作:在进行电池更换或维护时,应确保机器人已经断电并处于停止状态,避免发生意外伤害 ;
- 环境因素:电池的维护和保养还应考虑到环境因素,例如温度和湿度,以确保电池性能的稳定性和安全性 ;