ROS 2 速查手册（进阶）

配套：ROS 2 Jazzy / Ubuntu 24.04

重点：C++ 工程结构、Composable Node、intra-process communication、QoS 实战、自定义 msg、Launch 阅读、TF2 编程、RViz2/Foxglove、Marker、rosbag 离线调试、ROS 环境变量与 systemd 部署。

1. 这份手册和基础版有什么区别？#

基础版主要解决：

1
ROS 2 是什么？
2
怎么创建 Node？
3
怎么发布 Topic？
4
怎么订阅 Topic？
5
怎么编译？
6
怎么 launch？
7
怎么查 TF？

这一份进一步解决：

1
为什么视觉项目要用 Composable Node？
2
为什么图像传来传去会很慢？
3
intra-process 到底是什么？
4
怎么自己定义 msg？
5
怎么看懂一个陌生的 launch？
6
怎么在代码里真正使用 TF2？
7
怎么把算法结果画到 RViz2？
8
Foxglove 和 RViz2 怎么选？
9
怎么用 rosbag 做离线算法开发？
10
机器人开机后如何自动启动 ROS？

2. ROS 2 C++ 工程结构#

一个比较正规的 C++ ROS 2 Package 通常长这样：

1
my_package/
2
├── CMakeLists.txt
3
├── package.xml
4
├── include/
5
│   └── my_package/
6
│       └── detector.hpp
7
├── src/
8
│   ├── detector.cpp
9
│   └── detector_node.cpp
10
├── config/
11
│   └── detector.yaml
12
├── launch/
13
│   └── detector.launch.py
14
└── rviz/
15
    └── detector.rviz

可以把它理解成：

1
package.xml
2
    ↓
3
“我是谁？依赖谁？”
4

5
CMakeLists.txt
6
    ↓
7
“我要怎么编译？”
8

9
include/
10
    ↓
11
“头文件”
12

13
src/
14
    ↓
15
“真正代码”
16

17
config/
18
    ↓
19
“参数”
20

21
launch/
22
    ↓
23
“怎么启动整个系统”
24

25
rviz/
26
    ↓
27
“怎么可视化”

3. `package.xml` 和 `CMakeLists.txt` 的区别#

package.xml#

它更像：

项目的身份证 + 依赖清单

1
<package format="3">
2
  <name>my_detector</name>
3
  <version>0.0.1</version>
4

5
  <buildtool_depend>ament_cmake</buildtool_depend>
6

7
  <depend>rclcpp</depend>
8
  <depend>sensor_msgs</depend>
9
  <depend>geometry_msgs</depend>
10

11
  <export>
12
    <build_type>ament_cmake</build_type>
13
  </export>
14
</package>

CMakeLists.txt#

它更像：

告诉编译器“代码怎么变成程序”

1
cmake_minimum_required(VERSION 3.8)
2
project(my_detector)
3

4
find_package(ament_cmake REQUIRED)
5
find_package(rclcpp REQUIRED)
6
find_package(sensor_msgs REQUIRED)
7
find_package(geometry_msgs REQUIRED)
8

9
add_executable(detector_node
10
  src/detector_node.cpp
11
)
12

13
ament_target_dependencies(
14
  detector_node
15
  rclcpp
16
  sensor_msgs
17
  geometry_msgs
18
)
19

20
install(
21
  TARGETS detector_node
22
  DESTINATION lib/${PROJECT_NAME}
23
)
24

25
install(
26
  DIRECTORY config launch
27
  DESTINATION share/${PROJECT_NAME}
28
)
29

30
ament_package()

记忆：

1
package.xml
2
    = “我需要谁”
3

4
CMakeLists.txt
5
    = “我怎么用这些东西编译”

4. ROS 2 依赖为什么经常报错？#

例如代码：

1
##include <sensor_msgs/msg/image.hpp>

但编译报：

1
fatal error:
2
sensor_msgs/msg/image.hpp: No such file or directory

检查两层。

第一层：package.xml#

1
<depend>sensor_msgs</depend>

第二层：CMakeLists.txt#

1
find_package(sensor_msgs REQUIRED)

并且：

1
ament_target_dependencies(
2
  detector_node
3
  rclcpp
4
  sensor_msgs
5
)

所以：

1
package.xml
2
    ↓
3
声明依赖
4

5
CMakeLists.txt
6
    ↓
7
找到依赖 + 链接依赖

5. `--symlink-install`#

普通：

1
colcon build

开发时推荐：

1
colcon build --symlink-install

普通安装可以理解为：

1
源码
2
 ↓
3
复制
4
 ↓
5
install/

symlink：

1
源码
2
 ↓
3
软链接
4
 ↓
5
install/

对于 Python、配置文件等开发内容特别方便。

6. CMake Generator 改了为什么要删 build？#

例如：

1
colcon build --cmake-args -G Ninja

之前可能使用：

1
Unix Makefiles

CMake 会把 generator 信息缓存到 build/。

所以切换：

1
Makefiles
2
↔
3
Ninja

建议：

1
rm -rf build install log
2
colcon build

记忆：

CMake 构建系统发生根本变化 → 清理旧缓存。

7. 自定义 Message#

标准消息：

1
sensor_msgs/Image
2
geometry_msgs/Pose
3
geometry_msgs/Point

解决的是通用问题。

视觉项目可能需要：

1
装甲板：
2
    位置
3
    置信度
4
    类型
5
    四角点
6
    ID

于是定义：

1
ArmorDetection.msg

例如：

1
geometry_msgs/Point position
2
float32 confidence
3
uint8 armor_type
4
string text

它相当于：

自己设计一种“数据包格式”。

8. msg 文件语法#

最基本：

1
类型 名字

例如：

1
float32 confidence
2
int32 id
3
bool valid
4
string name

数组：

1
float32[] scores
2
geometry_msgs/Point[] corners

固定长度数组：

1
float32[4] values

引用其他消息：

1
geometry_msgs/Point position
2
sensor_msgs/Image image

9. 自定义 Message 的构建流程#

假设：

1
autoaim_interfaces/
2
└── msg/
3
    └── ArmorDetection.msg

CMake：

1
find_package(rosidl_default_generators REQUIRED)
2
find_package(geometry_msgs REQUIRED)
3

4
rosidl_generate_interfaces(
5
  ${PROJECT_NAME}
6
  "msg/ArmorDetection.msg"
7
  DEPENDENCIES geometry_msgs
8
)

package.xml 中需要对应的接口生成和运行依赖，例如：

1
<buildtool_depend>ament_cmake</buildtool_depend>
2

3
<build_depend>rosidl_default_generators</build_depend>
4
<exec_depend>rosidl_default_runtime</exec_depend>
5

6
<depend>geometry_msgs</depend>
7

8
<member_of_group>
9
  rosidl_interface_packages
10
</member_of_group>

然后：

1
colcon build --packages-select autoaim_interfaces
2
source install/setup.bash

查看：

1
ros2 interface show autoaim_interfaces/msg/ArmorDetection

10. 修改 msg 后为什么必须重新 build？#

例如原来：

1
Point position
2
float confidence

后来增加：

1
uint8 armor_type

如果不重新构建：

1
代码
2
 ↓
3
仍然使用旧生成接口

所以：

1
colcon build --packages-select autoaim_interfaces
2
source install/setup.bash

如果依赖它的包也需要重新构建：

1
colcon build

经验：

改 .msg → 先想到重新 build 接口包。

11. QoS：从“知道”进入“会排查”#

QoS 可以理解成：

消息传输规则。

重要概念：

1
History
2
Depth
3
Reliability
4
Durability

12. History / Depth#

例如：

1
Depth = 1

可以简单理解为：

1
只保留最新的一条消息

实时视觉：

1
Frame 1
2
Frame 2
3
Frame 3
4
Frame 4

如果算法处理很慢，不希望：

1
处理 Frame 1
2
→ Frame 2
3
→ Frame 3
4
→ Frame 4

最后虽然“每帧都处理了”，但处理的其实都是过去很久的数据。

实时视觉往往更关心：

“现在这一帧是什么？”

而不是：

“历史帧一帧都不能丢。”

13. Reliability#

主要模式：

1
RELIABLE
2
BEST_EFFORT

RELIABLE#

1
“尽量保证你收到”

适合：

1
重要控制命令
2
关键状态
3
不能轻易丢的消息

BEST_EFFORT#

1
“能及时收到最好，丢一帧没关系”

视觉图像通常更能接受这种思路。

例如：

1
30 FPS
2

3
Frame 100
4
Frame 101
5
Frame 102
6
Frame 103
7
Frame 104

偶尔：

1
Frame 102 丢了

通常仍然可以：

继续处理。

14. QoS 不匹配是视觉项目经典问题#

例如：

1
Camera Publisher
2
Reliability = BEST_EFFORT

而：

1
Detector Subscriber
2
Reliability = RELIABLE

两边 QoS 不兼容时：

1
Topic 明明存在
2
Node 也存在
3
但是收不到消息

遇到：

“Topic 有，节点也有，但 callback 不触发。”

先检查：

1
ros2 topic info /camera/image_raw --verbose

不要第一时间怀疑 OpenCV。

15. Composable Node：为什么视觉项目特别喜欢它？#

普通 ROS 2：

1
camera_node
2
    ↓
3
一个进程
4

5
detector_node
6
    ↓
7
一个进程
8

9
locator_node
10
    ↓
11
一个进程

也就是：

1
Process A
2
Process B
3
Process C
4
Process D
5
...

每个进程都有：

1
自己的内存
2
自己的运行环境
3
自己的进程开销

16. 图像为什么尤其怕进程间复制？#

假设：

1
1280 × 1024 × 3

约：

1
4 MB / frame

如果：

1
Camera
2
 ↓
3
Detector
4
 ↓
5
Locator
6
 ↓
7
Tracker

每经过一个进程，可能涉及：

1
序列化
2
 ↓
3
复制
4
 ↓
5
反序列化
6
 ↓
7
下一进程

如果：

1
30 FPS

数据复制量很快就非常大。

所以视觉项目会特别关心：

不要无意义地复制图像。

17. Composable Node 是什么？#

普通 Node：

1
Node
2
 ↓
3
可执行文件
4
 ↓
5
独立进程

Composable Node：

1
Node
2
 ↓
3
可动态加载的类
4
 ↓
5
Container

多个 Node：

1
                 Container Process
2
        ┌──────────────────────────┐
3
        │                          │
4
        │ CameraNode               │
5
        │ DetectorNode             │
6
        │ LocatorNode              │
7
        │ TrackerNode              │
8
        │                          │
9
        └──────────────────────────┘

类比：

1
普通模式：
2
每个功能 = 一个 App
3

4
组件模式：
5
一个 App = 一个容器
6
功能 = App 里的插件

18. 普通 Node 和组件 Node 的区别#

普通：

1
int main(int argc, char** argv)
2
{
3
    rclcpp::init(argc, argv);
4

5
    rclcpp::spin(
6
        std::make_shared<CameraNode>()
7
    );
8

9
    rclcpp::shutdown();
10
}

组件：

1
class CameraNode : public rclcpp::Node
2
{
3
public:
4
    explicit CameraNode(
5
        const rclcpp::NodeOptions& options)
6
        : Node("camera", options)
7
    {
8
    }
9
};

然后：

1
RCLCPP_COMPONENTS_REGISTER_NODE(
2
    CameraNode
3
)

重点：

组件通常没有自己的 main()。

19. CMake 如何注册组件？#

普通：

1
add_executable(camera_node
2
  src/camera_node.cpp
3
)

组件：

1
find_package(rclcpp_components REQUIRED)
2

3
add_library(
4
  camera_node_component
5
  SHARED
6
  src/camera_node.cpp
7
)
8

9
ament_target_dependencies(
10
  camera_node_component
11
  rclcpp
12
  rclcpp_components
13
)
14

15
rclcpp_components_register_nodes(
16
  camera_node_component
17
  "autoaim_camera::CameraNode"
18
)

本质：

1
.cpp
2
 ↓
3
Shared Library
4
 ↓
5
注册插件
6
 ↓
7
Container 动态加载

20. Container#

常见：

1
component_container
2
component_container_mt

区别：

1
component_container
2
    ↓
3
单线程
4

5
component_container_mt
6
    ↓
7
多线程

视觉项目通常更关注：

1
component_container_mt

21. 为什么多线程 Container 对视觉有帮助？#

假设：

1
Camera callback
2
    ↓
3
Detector callback
4
    ↓
5
Locator callback

如果单线程：

1
Detector 推理 20ms
2

3
其他 callback
4
    ↓
5
全部排队

可能造成：

1
Camera
2
 ↓
3
等待
4
 ↓
5
Detector
6
 ↓
7
等待
8
 ↓
9
Locator

多线程：

1
Thread 1 → Camera
2
Thread 2 → Detector
3
Thread 3 → Locator

可以更充分地并行执行。

注意：

多线程不等于自动变快。共享资源仍然需要考虑线程安全、锁和执行器行为。

22. intra-process communication#

仅仅：

1
多个 Node
2
 ↓
3
同一个进程

并不意味着所有数据都完全不复制。

可以开启：

1
extra_arguments=[
2
    {
3
        'use_intra_process_comms': True
4
    }
5
]

核心思想：

1
普通通信：
2

3
Node A
4
 ↓
5
序列化
6
 ↓
7
复制
8
 ↓
9
Node B
10

11
intra-process：
12

13
Node A
14
 ↓
15
进程内部通信
16
 ↓
17
减少序列化/复制
18
 ↓
19
Node B

对于：

1
4 MB 图像 × 高频率

尤其有意义。

23. Composable Node + intra-process#

可以记成：

1
Composable Node
2
    ↓
3
解决“进程太多”
4

5
intra-process communication
6
    ↓
7
减少同进程 Node 之间的数据复制

组合起来：

1
Camera
2
   │
3
   │ image
4
   ▼
5
Detector
6
   │
7
   │ detection
8
   ▼
9
Locator
10
   │
11
   ▼
12
Tracker
13

14
全部在同一个 Container

24. Component CLI#

查看组件：

1
ros2 component list

查看系统支持的组件类型：

1
ros2 component types

手动加载：

1
ros2 component load   /autoaim_container   autoaim_camera   autoaim_camera::CameraNode

适合：

1
启动 Container
2
        ↓
3
不重启整个系统
4
        ↓
5
临时加载某个 Node
6
        ↓
7
测试

25. 如何阅读一个陌生 Launch？#

拿到：

1
autoaim_launcher.py

推荐顺序：

1
① 找 Node / ComposableNode
2

3
② 看 package
4

5
③ 看 executable / plugin
6

7
④ 看 name
8

9
⑤ 看 parameters
10

11
⑥ 看 remappings
12

13
⑦ 看 namespace
14

15
⑧ 看 container
16

17
⑨ 画出 Topic 数据流

最终把代码脑补成：

1
Camera
2
  │
3
  ├── image_raw ──→ Detector
4
  │
5
  ▼
6
Detector
7
  │
8
  └── detections ──→ Locator
9
                         │
10
                         ▼
11
                      Tracker

26. `ComposableNode` Launch 结构#

典型：

1
ComposableNode(
2
    package='autoaim_camera',
3

4
    plugin='autoaim_camera::CameraNode',
5

6
    name='autoaim_camera',
7

8
    parameters=[
9
        camera_params_yaml
10
    ],
11

12
    extra_arguments=[
13
        {
14
            'use_intra_process_comms': True
15
        }
16
    ],
17
)

重点看：

1
package
2
    ↓
3
来自哪个 ROS Package
4

5
plugin
6
    ↓
7
加载哪个 C++ 组件类
8

9
name
10
    ↓
11
运行时 Node 名字
12

13
parameters
14
    ↓
15
加载什么配置
16

17
extra_arguments
18
    ↓
19
额外运行选项

27. TF2：进入代码层#

TF2 最核心的四个类：

类	用途
`tf2_ros::Buffer`	保存 / 查询 TF
`tf2_ros::TransformListener`	接收 TF
`tf2_ros::TransformBroadcaster`	发布动态 TF
`tf2_ros::StaticTransformBroadcaster`	发布静态 TF

常见初始化：

1
tf_buffer_ =
2
    std::make_shared<tf2_ros::Buffer>(
3
        get_clock()
4
    );
5

6
tf_listener_ =
7
    std::make_unique<tf2_ros::TransformListener>(
8
        *tf_buffer_
9
    );

28. `lookupTransform`#

例如：

1
auto transform =
2
    tf_buffer_->lookupTransform(
3
        "gimbal_link",
4
        "camera_link",
5
        tf2::TimePointZero
6
    );

最重要的是理解：

1
lookupTransform(
2
    target_frame,
3
    source_frame,
4
    time
5
)

也就是：

“我要把 source_frame 中的东西转换到 target_frame。”

29. `TimePointZero`#

1
tf2::TimePointZero

可以简单理解成：

使用最近可用的 TF。

视觉程序里经常：

1
lookupTransform(
2
    "gimbal_link",
3
    "camera_link",
4
    tf2::TimePointZero
5
);

如果任务严格依赖某一时刻的传感器数据，则应该认真处理时间戳，而不是永远使用最新 TF。

30. 查询前先 `canTransform`#

直接：

1
lookupTransform(...)

如果 TF 不存在可能抛异常。

更安全：

1
if (tf_buffer_->canTransform(
2
        "gimbal_link",
3
        "camera_link",
4
        tf2::TimePointZero))
5
{
6
    auto t =
7
        tf_buffer_->lookupTransform(
8
            "gimbal_link",
9
            "camera_link",
10
            tf2::TimePointZero
11
        );
12
}

实际工程还应考虑：

1
TF 是否刚刚启动
2
TF 是否暂时还没收到
3
时间戳是否匹配

31. 直接变换一个 Point#

例如相机检测到了：

1
camera_link:
2

3
x = 1.0
4
y = 0.0
5
z = 2.0

建立：

1
geometry_msgs::msg::PointStamped camera_point;
2

3
camera_point.header.frame_id =
4
    "camera_link";
5

6
camera_point.point.x = 1.0;
7
camera_point.point.y = 0.0;
8
camera_point.point.z = 2.0;

然后：

1
auto gimbal_point =
2
    tf_buffer_->transform(
3
        camera_point,
4
        "gimbal_link"
5
    );

现在：

1
camera_point
2
    ↓
3
TF2
4
    ↓
5
gimbal_point

这就是视觉项目中“相机系位置 → 云台系位置”的核心操作。

32. 广播动态 TF#

如果两个坐标系的关系会变化：

1
云台旋转
2
    ↓
3
camera 相对于 gimbal 的姿态变化

可以：

1
tf2_ros::TransformBroadcaster broadcaster(this);
2

3
geometry_msgs::msg::TransformStamped t;
4

5
t.header.stamp = now();
6

7
t.header.frame_id =
8
    "gimbal_link";
9

10
t.child_frame_id =
11
    "camera_link";
12

13
t.transform.translation.x = 0.05;
14

15
t.transform.rotation.w = 1.0;
16

17
broadcaster.sendTransform(t);

核心关系：

1
parent
2
  ↓
3
child

33. 广播静态 TF#

例如相机牢牢安装在云台上：

1
gimbal
2
   │
3
   │ 固定
4
   ▼
5
camera

命令：

1
ros2 run tf2_ros static_transform_publisher   0.05 0 0.1   0 0 0   gimbal_link   camera_link

可以理解为：

1
x y z
2
+
3
yaw pitch roll
4
+
5
parent
6
+
7
child

34. TF2 排错#

Unknown frame#

1
Unknown frame "camera_link"

检查：

1
ros2 run tf2_ros tf2_echo   camera_link   gimbal_link

如果都找不到：

1
frame 名字可能写错
2
或者
3
没人发布这个 frame

刚启动就 TF 报错#

可能只是：

1
Node 启动
2
 ↓
3
TF broadcaster 还没启动完成
4
 ↓
5
查询过早

解决思路：

1
canTransform
2
+
3
重试

TF Tree 断了#

查看：

1
ros2 run tf2_tools view_frames

寻找断开的 frame：

1
谁应该发布它？
2
那个 Node 启动了吗？
3
静态 TF 发布了吗？

35. RViz2：把抽象数据变成可观察对象#

启动：

1
rviz2

核心价值：

把 ROS 中的坐标、图像、点云、轨迹、算法结果直接画出来。

36. Fixed Frame#

RViz2：

1
Global Options
2
    ↓
3
Fixed Frame

例如：

1
gimbal_link

可以理解成：

“我要站在哪个坐标系里观察整个机器人世界？”

如果 Fixed Frame 错了：

1
TF
2
Point
3
Marker
4
Robot

可能：

1
不显示
2
乱飞
3
报 TF 错误

37. RViz2 常用 Display#

Display	用途
`Image`	查看相机图像
`TF`	查看所有坐标系
`Marker`	查看单个 Marker
`MarkerArray`	查看多个调试对象
`PointCloud2`	查看点云
`LaserScan`	查看激光雷达
`RobotModel`	查看机器人模型
`Path`	查看轨迹
`Axes`	查看坐标轴
`Grid`	查看参考网格

视觉开发最常用：

1
Image
2
TF
3
MarkerArray
4
PointCloud2

38. Marker：给算法结果“画出来”#

假设算法算出来：

1
目标位置：
2

3
x = 2.0
4
y = 0.3
5
z = 0.1

单纯：

1
std::cout << x << y << z;

很难直观看出：

到底算对没有？

如果画成 Marker：

1
机器人
2
  │
3
  │       ● ← 算法认为的目标
4
  │
5
  └────────────

一眼就知道。

39. Marker 最重要的字段#

1
visualization_msgs::msg::Marker m;

Frame：

1
m.header.frame_id =
2
    "gimbal_link";

命名空间：

1
m.ns = "locator";

ID：

1
m.id = 0;

类型：

1
m.type =
2
    visualization_msgs::msg::Marker::SPHERE;

位置：

1
m.pose.position.x = 1.0;
2
m.pose.position.y = 0.2;
3
m.pose.position.z = 0.1;

大小：

1
m.scale.x = 0.1;
2
m.scale.y = 0.1;
3
m.scale.z = 0.1;

40. 常用 Marker 类型#

1
ARROW
2
CUBE
3
SPHERE
4
CYLINDER
5
LINE_STRIP
6
LINE_LIST
7
TEXT_VIEW_FACING

例如：

1
SPHERE
2
    ↓
3
画一个目标点
4

5
ARROW
6
    ↓
7
画方向
8

9
LINE_STRIP
10
    ↓
11
画轨迹
12

13
TEXT_VIEW_FACING
14
    ↓
15
显示文字

41. Marker 生命周期#

如果不断 ADD：

1
Marker 1
2
Marker 2
3
Marker 3
4
Marker 4
5
...

可能留下大量历史残影。

可以设置：

1
m.lifetime =
2
    rclcpp::Duration(
3
        0,
4
        100 * 1000000
5
    );

类似：

1
100 ms 后自动消失

实时视觉中很实用。

42. MarkerArray#

如果一次要画：

1
20 个目标
2
100 个轨迹点
3
多个坐标轴

可以：

1
visualization_msgs::msg::MarkerArray arr;
2

3
arr.markers.push_back(marker);
4

5
marker_pub_->publish(arr);

适合批量发布调试信息。

43. 推荐的视觉调试习惯#

不要只画：

1
算法最终结果

最好同时画：

1
原始检测
2
    ↓
3
解算结果
4
    ↓
5
滤波结果
6
    ↓
7
预测结果

例如：

1
点
2
 ↓
3
检测位置
4

5
另一个点
6
 ↓
7
滤波位置
8

9
箭头
10
 ↓
11
速度方向
12

13
线
14
 ↓
15
预测轨迹

这样可以快速定位：

1
Detector 错？
2
Locator 错？
3
TF 错？
4
Filter 错？

44. Foxglove：现代化 ROS 可视化#

Foxglove 可以理解成：

一个更现代、更适合数据分析的 ROS 可视化工具。

架构：

1
ROS 2
2
 │
3
 │ Topics
4
 ▼
5
foxglove_bridge
6
 │
7
 │ WebSocket
8
 ▼
9
浏览器 / Foxglove App

所以：

1
机器人上
2
    ↓
3
bridge
4

5
你的电脑
6
    ↓
7
Foxglove

45. Foxglove Bridge#

Ubuntu 24.04 + Jazzy：

1
sudo apt install -y   ros-jazzy-foxglove-bridge

启动：

1
ros2 launch   foxglove_bridge   foxglove_bridge_launch.xml   port:=8765

常用端口：

1
8765

46. Foxglove 常用面板#

3D#

看：

1
TF
2
Marker
3
PointCloud
4
机器人空间数据

Image#

看：

1
相机
2
检测图像
3
视觉处理结果

Raw Messages#

适合：

1
“这个 msg 到底发了什么？”

直接查看完整字段。

Topic Metrics#

适合查：

1
频率
2
延迟
3
数据流

47. RViz2 vs Foxglove#

	RViz2	Foxglove
安装	ROS 环境常自带	独立客户端/网页
3D	强	强
TF	强	强
Image	强	强
Raw Message	一般	很方便
Topic Metrics	基础	很方便
布局	本地配置	更适合保存/分享
远程观察	不够方便	很方便
适合	ROS 本机调试	综合数据分析

简单记：

1
本机快速调 ROS
2
    → RViz2
3

4
远程 / 数据分析 / 布局
5
    → Foxglove

48. rosbag：机器人开发的“录像机”#

现场测试：

1
机器人
2
 ↓
3
相机
4
 ↓
5
Detector
6
 ↓
7
真实数据

如果每次改算法都重新跑机器人：

1
非常慢

所以录制：

1
ros2 bag record   -o bag/test01   /camera/image_raw   /camera/camera_info   /detections

保存下来。

49. rosbag 回放#

1
ros2 bag play bag/test01

循环：

1
ros2 bag play bag/test01 --loop

于是：

1
真实机器人
2
    ↓
3
一次录制
4
    ↓
5
rosbag
6
    ↓
7
无限回放
8
    ↓
9
你的算法

这意味着：

可以在没有机器人、没有相机的情况下反复调算法。

50. 推荐的视觉开发模式#

第一阶段：

1
实车
2
 ↓
3
录制 rosbag
4
 ↓
5
保存测试数据

之后：

1
修改 Detector
2
 ↓
3
rosbag play
4
 ↓
5
测试

再：

1
修改 Locator
2
 ↓
3
rosbag play
4
 ↓
5
测试

再：

1
修改 Tracker
2
 ↓
3
rosbag play
4
 ↓
5
测试

最终：

1
全部通过
2
 ↓
3
上真实机器人

51. `ROS_DOMAIN_ID`#

如果多台机器人同时运行：

1
Robot A
2
Robot B
3
Robot C

不同机器人可以使用不同 Domain：

1
export ROS_DOMAIN_ID=10

另一台：

1
export ROS_DOMAIN_ID=11

理解为：

1
Domain 10
2
    Robot A
3

4
Domain 11
5
    Robot B

达到网络隔离效果。

52. `RMW_IMPLEMENTATION`#

ROS 2 通过 RMW 层连接底层通信实现。

查看：

1
echo $RMW_IMPLEMENTATION

例如可能看到：

1
rmw_fastrtps_cpp

不要为了“优化”就随意切换。

真实机器人系统通常应该：

1
团队统一
2
    ↓
3
RMW
4
    ↓
5
统一部署

53. 日志环境变量#

例如：

1
echo $RCUTILS_CONSOLE_OUTPUT_FORMAT

可以控制 ROS 日志输出格式。

部署时可能统一：

1
时间
2
节点
3
日志级别
4
消息

方便分析机器人运行日志。

54. systemd：让机器人开机自动运行#

开发阶段：

1
ros2 launch ...

每次手动运行。

真正部署机器人：

1
机器人上电
2
    ↓
3
Linux 启动
4
    ↓
5
systemd
6
    ↓
7
ROS 2 launch
8
    ↓
9
整套机器人程序自动启动

55. systemd 服务的核心思想#

典型：

1
[Unit]
2
Description=AutoAim ROS2
3

4
[Service]
5
User=robot
6
Group=dialout
7
EnvironmentFile=/path/to/robot.env
8

9
ExecStart=/path/to/start.sh
10

11
Restart=always
12

13
[Install]
14
WantedBy=multi-user.target

理解：

1
User
2
    ↓
3
用谁运行
4

5
Group
6
    ↓
7
例如串口权限
8

9
EnvironmentFile
10
    ↓
11
读取机器人配置
12

13
ExecStart
14
    ↓
15
启动命令
16

17
Restart=always
18
    ↓
19
程序崩了自动重启

56. systemd 常用命令#

查看：

1
systemctl status autoaim.service

启动：

1
sudo systemctl start autoaim.service

停止：

1
sudo systemctl stop autoaim.service

开机启动：

1
sudo systemctl enable autoaim.service

取消：

1
sudo systemctl disable autoaim.service

查看日志：

1
journalctl -u autoaim.service

实时：

1
journalctl -u autoaim.service -f

57. 一个完整的机器人系统#

成熟 ROS 2 视觉系统可以理解为：

1
                    systemd
2
                       │
3
                       ▼
4
                ROS 2 launch
5
                       │
6
             ┌─────────┴─────────┐
7
             │                   │
8
       Component Container      Other Node
9
             │
10
      ┌──────┼─────────┐
11
      │      │         │
12
   Camera Detector  Locator
13
      │      │         │
14
      └──────┴─────────┘
15
             │
16
             ▼
17
            TF2
18
             │
19
             ▼
20
          Tracker
21
             │
22
             ▼
23
         Controller
24
             │
25
             ▼
26
         Hardware

同时：

1
Topics
2
  ↓
3
rosbag
4
  ↓
5
离线回放

以及：

1
Topics
2
  ↓
3
RViz2 / Foxglove
4
  ↓
5
可视化调试

58. 一张“工程化 ROS 2”心智地图#

1
ROS 2 项目
2
│
3
├── Workspace
4
│   ├── src
5
│   ├── build
6
│   ├── install
7
│   └── log
8
│
9
├── Package
10
│   ├── package.xml
11
│   ├── CMakeLists.txt
12
│   ├── src
13
│   ├── include
14
│   ├── config
15
│   └── launch
16
│
17
├── Communication
18
│   ├── Topic
19
│   ├── Service
20
│   └── Action
21
│
22
├── Configuration
23
│   └── Parameter / YAML
24
│
25
├── Interface
26
│   ├── msg
27
│   ├── srv
28
│   └── action
29
│
30
├── Performance
31
│   ├── QoS
32
│   ├── Component
33
│   ├── Multi-thread
34
│   └── Intra-process
35
│
36
├── Coordinate
37
│   └── TF2
38
│
39
├── Visualization
40
│   ├── RViz2
41
│   ├── Foxglove
42
│   └── Marker
43
│
44
├── Data
45
│   └── rosbag
46
│
47
└── Deployment
48
    ├── Environment
49
    ├── ROS_DOMAIN_ID
50
    ├── RMW
51
    └── systemd

59. 视觉项目排错顺序#

没有图像#

1
ros2 node list
2
ros2 topic list
3
ros2 topic type /camera/image_raw
4
ros2 topic info /camera/image_raw --verbose
5
ros2 topic hz /camera/image_raw

顺序：

1
Node
2
 ↓
3
Topic
4
 ↓
5
Type
6
 ↓
7
Publisher
8
 ↓
9
QoS
10
 ↓
11
Frequency

检测结果没有#

检查：

1
Camera
2
 ↓
3
image_raw
4
 ↓
5
Detector
6
 ↓
7
detections

分别：

1
ros2 topic hz /image_raw
2
ros2 topic hz /detections

如果：

1
image_raw 正常
2
detections 没有

重点查：

1
Detector
2
QoS
3
callback
4
算法

坐标位置不对#

检查：

1
1. frame_id
2
2. TF tree
3
3. parent / child
4
4. 相机外参
5
5. 时间戳
6
6. 坐标轴定义

先：

1
ros2 run tf2_tools view_frames

再：

1
ros2 run tf2_ros tf2_echo   gimbal_link   camera_link

最后用 Marker 在 RViz2 里画出来。

60. 最重要的进阶命令#

1
## Component
2
ros2 component list
3
ros2 component types
4

5
## TF
6
ros2 run tf2_ros tf2_echo base_link camera_link
7
ros2 run tf2_tools view_frames
8
ros2 run tf2_ros tf2_monitor
9

10
## Visualization
11
rviz2
12
rqt_graph
13

14
## Bag
15
ros2 bag record -a
16
ros2 bag info <bag>
17
ros2 bag play <bag>
18

19
## Parameter
20
ros2 param list
21
ros2 param get <node> <param>
22
ros2 param dump <node>
23

24
## QoS
25
ros2 topic info /topic --verbose
26

27
## System
28
systemctl status <service>
29
journalctl -u <service> -f

61. 必须真正理解的 8 个关键词#

① Composable Node#

1
把 Node 变成可加载组件

② Container#

1
加载多个组件的进程

③ Intra-process#

1
减少同进程 Node 之间的数据复制

④ QoS#

1
规定消息怎么传

⑤ Custom Message#

1
定义属于自己项目的数据格式

⑥ TF2#

1
管理并转换坐标系

⑦ Marker#

1
把算法结果画出来

⑧ rosbag#

1
把机器人现场录下来，之后离线反复播放

62. 最终把整个知识体系串起来#

一个真实视觉项目可以是：

1
相机
2
 │
3
 │ Image
4
 ▼
5
Camera Node
6
 │
7
 │ /image_raw
8
 ▼
9
Detector
10
 │
11
 │ Custom Message
12
 ▼
13
Locator
14
 │
15
 │ camera frame
16
 ▼
17
TF2
18
 │
19
 │ gimbal frame
20
 ▼
21
Tracker
22
 │
23
 │ prediction
24
 ▼
25
Controller

与此同时：

1
所有 Topic
2
    │
3
    ├────────→ rosbag
4
    │
5
    ├────────→ RViz2
6
    │
7
    └────────→ Foxglove

性能方面：

1
Camera
2
Detector
3
Locator
4
Tracker
5
    │
6
    ▼
7
Composable Container
8
    │
9
    ▼
10
Multi-thread
11
    │
12
    ▼
13
Intra-process communication

部署方面：

1
Linux
2
  ↓
3
systemd
4
  ↓
5
launch
6
  ↓
7
ROS 2 system

63. 一句话总结#

基础 ROS 2 是“让节点通信起来”；进阶 ROS 2 是“让整个机器人系统跑得快、看得见、调得动、部署稳”。

对于机器人视觉，最重要的一条链是：

1
Topic
2
  ↓
3
Custom Message
4
  ↓
5
Composable Node
6
  ↓
7
Intra-process
8
  ↓
9
TF2
10
  ↓
11
Marker / RViz2 / Foxglove
12
  ↓
13
rosbag
14
  ↓
15
systemd

这条链基本覆盖了从“写出一个 ROS 节点”到“把视觉算法部署到真实机器人”的关键工程能力。

参考资料#

本手册根据浙江大学 RoboMaster Vision 的 ROS 2 基础培训页面整理，并刻意避开上一份基础速查手册已经详细介绍的内容：

ROS 2 基础培训原文： https://hello-world-vision.github.io/Vision_Website/induction-training/07-ros2%E5%9F%BA%E7%A1%80/
ROS 2 Jazzy 官方文档： https://docs.ros.org/en/jazzy/
ROS 2 Composition： https://docs.ros.org/en/jazzy/Tutorials/Intermediate/Composition.html
ROS 2 TF2： https://docs.ros.org/en/jazzy/Tutorials/Intermediate/Tf2/Tf2-Main.html
ROS 2 RViz2： https://docs.ros.org/en/jazzy/Tutorials/Intermediate/RViz/RViz-User-Guide.html
Foxglove： https://foxglove.dev/