1. 为什么我建议你用一套实训把 launch、rosbag2 和 TF2 一次打通

刚接触 ROS2 的人，几乎都会经历一个很割裂的阶段：节点能跑起来了，但每次开终端敲一堆ros2 run；话题能看了，但数据一关终端就没了；坐标变换听说了，但tf2那套广播监听写起来总觉得云里雾里。这三个东西单独学，每个都能找到教程，可一旦放到一个真实项目里，问题就来了——节点多了启动顺序乱、录包时忘了带某个话题、TF 树断了一环导致 RViz2 里模型飘到天上去。

我自己带过不少刚入门的同学，也踩过这些坑。后来我总结出一套比较高效的实训路径：用 launch 批量启动节点，用 rosbag2 把运行数据录下来回放，再用 TF2 在 C++ 和 Python 里各写一遍坐标广播和监听。这套组合练下来，机器人底层坐标这条链路基本就通了。为什么是这三个凑一起？因为它们本来就是一条线上的东西：launch 负责把系统拉起来，rosbag2 负责把过程留下来，TF2 负责把空间关系串起来。你单独练任何一个，都缺了另外两个提供的上下文。

这篇内容适合谁看？如果你已经装好了 ROS2（Humble 或 Jazzy 都行），能跑通 talker/listener 这种最基础的例子，但还没真正做过一个多节点协同的小项目，那这篇就是给你准备的。我会把每个环节的“为什么这么选”“参数怎么定”“哪里容易翻车”都讲清楚，代码给到能直接抄的程度，C++ 和 Python 两条线并行推进。看完你应该能独立搭出一个带坐标变换、可录可回放的小系统。

先说清楚一个前提：下面所有操作我都是在 Ubuntu 22.04 + ROS2 Humble 上实测的，Jazzy 上大部分命令一致，个别 API 有差异我会单独标出来。工作空间我统一用~/ros2_ws，你换成自己的路径也行，注意后面命令里的路径对应改掉。

2. 整体设计思路：三个模块怎么串成一条链路

2.1 先想清楚要做一个什么样的系统

很多人学 ROS2 的问题是“为了学而学”，敲完命令不知道自己在干嘛。所以我习惯先定一个具体场景，再倒推需要哪些技术点。这次我们做一个简化版的“移动底盘 + 传感器”系统：一个节点模拟底盘里程计并广播odom到base_link的坐标变换，一个节点模拟雷达并广播base_link到laser的固定变换，再来一个监听节点实时打印laser在odom坐标系下的位置。三个节点用 launch 一起拉起来，运行过程中用 rosbag2 录包，录完回放验证 TF 树是否完整。

这个场景虽小，但把标题里的四个关键词全用上了：launch 管启动，rosbag2 管记录回放，TF2 管坐标，C++/Python 双语言各实现一遍。而且它足够真实——真实机器人上 TF 树就是这么一层层搭起来的，odom到base_link是动态的，base_link到传感器是静态的，这个区分非常关键，后面会细讲。

2.2 为什么 launch 要用 Python 写而不是 XML

ROS2 的 launch 文件支持 Python、XML、YAML 三种写法。我强烈建议新手直接从 Python 入手，原因有三个。第一，Python launch 能写逻辑，比如根据参数决定启动哪些节点、循环生成多个节点，XML 做这些很别扭。第二，报错信息更友好，Python 的 traceback 能直接告诉你哪一行出问题，XML 经常只给你一句“解析失败”。第三，社区新项目基本都用 Python launch，你去看 Nav2、MoveIt2 的官方 launch 全是 Python，早点适应没坏处。

XML 也不是没用，它胜在简单直观，适合那种纯静态、不需要任何逻辑的启动场景。但既然我们要练“批量启动”，Python 的LaunchDescription配合循环才是正解。YAML 用得最少，一般只在需要把参数外置的时候配合使用，这里不展开。

2.3 rosbag2 的录制策略：录哪些话题、怎么切分

rosbag2 默认会把所有话题都录下来，听起来很省事，实际上是个坑。真实系统里话题几十上百个，全录下来文件巨大，回放时还容易因为某个高频话题把 CPU 打满。我的习惯是显式指定要录的话题，只录跟当前调试目标相关的。这次我们只关心/odom、/scan和/tf、/tf_static这几个，其他一律不录。

关于/tf和/tf_static这两个话题，有个特别容易忽略的点：静态变换默认只在启动时发一次，如果你录包时错过了那一瞬间，回放时 TF 树就缺了静态那一环。所以录包一定要把/tf_static带上，而且 rosbag2 对/tf_static有特殊处理，回放时会自动以“锁存”方式重发，这点后面实操会验证。

至于切分，rosbag2 支持按大小或时长自动分片。调试阶段我一般设--max-cache-size控制内存，长时间录制再考虑--max-bag-size。这次实训数据量小，不切分也行，但我会把参数写上让你知道在哪调。

2.4 TF2 双语言实现的价值在哪

有人会问，TF2 用 Python 写一遍不就行了，为什么还要 C++？因为真实项目里这两者经常混用：性能敏感的坐标运算用 C++，快速验证和脚本化用 Python。而且两套 API 的设计思路不一样，Python 的TransformBroadcaster用起来很轻，C++ 的要处理rclcpp::Node的生命周期和tf2_ros::TransformBroadcaster的构造时机。你把两边都写一遍，以后看别人的代码就不会因为语言不同而卡壳。

更重要的是，广播和监听是两套完全不同的 API，广播用TransformBroadcaster，监听用Buffer+TransformListener。很多人只写过广播，一到监听就懵，不知道lookupTransform的参数怎么填、异常怎么处理。这次两边都覆盖，广播和监听在 C++、Python 里各来一遍，四个组合全打通。

3. 环境准备与工作空间搭建

3.1 确认 ROS2 版本和基础依赖

动手之前先确认环境，别急着写代码。打开终端跑一下：

printenv ROS_DISTRO

正常应该输出humble或jazzy。如果没有输出，说明你没 source 环境，执行：

source /opt/ros/humble/setup.bash

把这句话加到~/.bashrc末尾，以后开终端自动生效。接着装几个这次要用的包，rosbag2和tf2相关的一般随桌面版一起装了，但保险起见确认一下：

sudo apt install ros-humble-rosbag2 ros-humble-tf2 ros-humble-tf2-ros ros-humble-tf2-tools

Jazzy 用户把humble换成jazzy。这里有个小坑：tf2-tools里有tf2_echo和view_frames这两个调试神器，很多人没装，到用的时候发现命令找不到，提前装上省事。

3.2 创建功能包：C++ 和 Python 怎么放

ROS2 的ament_cmake和ament_python是两种构建类型，一个包只能选一种。那 C++ 和 Python 代码怎么共存？两种做法：一是建两个包，一个 C++ 一个 Python；二是建一个ament_cmake包，Python 脚本作为可执行文件安装进去。我推荐第一种，职责清晰，构建互不干扰。

cd ~/ros2_ws/src ros2 pkg create --build-type ament_cmake tf_demo_cpp --dependencies rclcpp tf2 tf2_ros geometry_msgs ros2 pkg create --build-type ament_python tf_demo_py --dependencies rclpy tf2_ros geometry_msgs

--dependencies会自动帮你把依赖写进package.xml和CMakeLists.txt，省得手动加。注意tf2和tf2_ros是两个包，前者是核心算法库，后者是 ROS 封装，两个都要依赖。

3.3 目录结构规划

建完之后建议按下面的结构组织，别把所有文件堆在根目录：

tf_demo_cpp/ ├── CMakeLists.txt ├── package.xml ├── include/tf_demo_cpp/ ├── src/ │ ├── odom_broadcaster.cpp │ ├── tf_listener.cpp │ └── static_broadcaster.cpp └── launch/ └── demo.launch.py tf_demo_py/ ├── package.xml ├── setup.py ├── tf_demo_py/ │ ├── __init__.py │ ├── odom_broadcaster.py │ ├── tf_listener.py │ └── static_broadcaster.py └── launch/ └── demo.launch.py

launch目录要手动建，ros2 pkg create不会自动生成。Python 包里的模块名和包名一致是惯例，别改。

4. TF2 坐标广播与监听：C++ 和 Python 逐行拆解

4.1 先搞懂 TF 树和两种变换的本质区别

写代码之前必须把概念理清，否则代码抄了也不知道在干嘛。TF 树是一棵有向树，每个节点是一个坐标系，每条边是一个变换。机器人上常见的坐标系有map（地图）、odom（里程计）、base_link（车体）、laser（雷达）、camera（相机）等。树里每个坐标系只能有一个父节点，但可以有多个子节点。

变换分两种，这个区分是重中之重：

• 动态变换：随时间变化，比如odom到base_link，车一动这个变换就变。用TransformBroadcaster持续发，发到/tf话题。
• 静态变换：一旦确定就不变，比如base_link到laser，传感器装上去位置就固定了。用StaticTransformBroadcaster发一次，发到/tf_static话题。

为什么静态的要单独一个话题？因为静态变换只需要发一次，接收端缓存起来一直用，不用每帧都算。如果你把静态变换也用动态广播器每秒发几十次，纯属浪费带宽和算力。这个设计思路在真实项目里能省不少资源。

4.2 C++ 动态广播器：odom 到 base_link

先看 C++ 版本。核心是构造一个TransformBroadcaster，然后在定时器里不断发送变换。

#include <chrono> #include <memory> #include <cmath> #include "rclcpp/rclcpp.hpp" #include "tf2_ros/transform_broadcaster.h" #include "geometry_msgs/msg/transform_stamped.hpp" using namespace std::chrono_literals; class OdomBroadcaster : public rclcpp::Node { public: OdomBroadcaster() : Node("odom_broadcaster_cpp"), t_(0.0) { broadcaster_ = std::make_unique<tf2_ros::TransformBroadcaster>(*this); timer_ = this->create_wall_timer( 50ms, std::bind(&OdomBroadcaster::broadcast, this)); } private: void broadcast() { geometry_msgs::msg::TransformStamped tf; tf.header.stamp = this->get_clock()->now(); tf.header.frame_id = "odom"; tf.child_frame_id = "base_link"; t_ += 0.05; tf.transform.translation.x = std::cos(t_); tf.transform.translation.y = std::sin(t_); tf.transform.translation.z = 0.0; // 让车头朝向运动方向 double yaw = t_ + M_PI / 2.0; tf.transform.rotation.x = 0.0; tf.transform.rotation.y = 0.0; tf.transform.rotation.z = std::sin(yaw / 2.0); tf.transform.rotation.w = std::cos(yaw / 2.0); broadcaster_->sendTransform(tf); } std::unique_ptr<tf2_ros::TransformBroadcaster> broadcaster_; rclcpp::TimerBase::SharedPtr timer_; double t_; }; int main(int argc, char** argv) { rclcpp::init(argc, argv); rclcpp::spin(std::make_shared<OdomBroadcaster>()); rclcpp::shutdown(); return 0; }

几个关键点解释一下。TransformBroadcaster的构造函数要传*this，也就是节点本身，它内部会创建一个 publisher 发到/tf。定时器用create_wall_timer而不是create_timer，区别是前者用系统时钟，后者用 ROS 时钟，仿真时用 ROS 时钟更合适，这里简单起见用 wall timer。

四元数那块是新手最容易翻车的地方。绕 Z 轴旋转 yaw 角的四元数是(0, 0, sin(yaw/2), cos(yaw/2))，注意是半角，不是sin(yaw)。我第一次写的时候直接填了sin(yaw)，结果 RViz2 里模型转得飞快还乱抖，排查半天才发现是半角问题。如果你不想手算四元数，可以用tf2::Quaternion的setRPY方法，更直观：

#include "tf2/LinearMath/Quaternion.h" tf2::Quaternion q; q.setRPY(0, 0, yaw); tf.transform.rotation.x = q.x(); tf.transform.rotation.y = q.y(); tf.transform.rotation.z = q.z(); tf.transform.rotation.w = q.w();

4.3 Python 动态广播器：同样的逻辑换个写法

Python 版本逻辑一样，但 API 更简洁：

import math import rclpy from rclpy.node import Node from tf2_ros import TransformBroadcaster from geometry_msgs.msg import TransformStamped class OdomBroadcaster(Node): def __init__(self): super().__init__('odom_broadcaster_py') self.broadcaster = TransformBroadcaster(self) self.t = 0.0 self.timer = self.create_timer(0.05, self.broadcast) def broadcast(self): tf = TransformStamped() tf.header.stamp = self.get_clock().now().to_msg() tf.header.frame_id = 'odom' tf.child_frame_id = 'base_link' self.t += 0.05 tf.transform.translation.x = math.cos(self.t) tf.transform.translation.y = math.sin(self.t) tf.transform.translation.z = 0.0 yaw = self.t + math.pi / 2.0 tf.transform.rotation.x = 0.0 tf.transform.rotation.y = 0.0 tf.transform.rotation.z = math.sin(yaw / 2.0) tf.transform.rotation.w = math.cos(yaw / 2.0) self.broadcaster.sendTransform(tf) def main(): rclpy.init() node = OdomBroadcaster() try: rclpy.spin(node) except KeyboardInterrupt: pass finally: node.destroy_node() rclpy.shutdown() if __name__ == '__main__': main()

注意tf.header.stamp这里用了self.get_clock().now().to_msg()，把 ROS 时间转成消息类型。Python 里时间类型转换是个常见坑，now()返回的是Time对象，必须.to_msg()才能赋给 header。

4.4 静态广播器：base_link 到 laser

静态广播器两边都很短。C++ 版：

#include <memory> #include "rclcpp/rclcpp.hpp" #include "tf2_ros/static_transform_broadcaster.h" #include "geometry_msgs/msg/transform_stamped.hpp" class StaticBroadcaster : public rclcpp::Node { public: StaticBroadcaster() : Node("static_broadcaster_cpp") { broadcaster_ = std::make_shared<tf2_ros::StaticTransformBroadcaster>(this); geometry_msgs::msg::TransformStamped tf; tf.header.stamp = this->get_clock()->now(); tf.header.frame_id = "base_link"; tf.child_frame_id = "laser"; tf.transform.translation.x = 0.2; tf.transform.translation.y = 0.0; tf.transform.translation.z = 0.3; tf.transform.rotation.w = 1.0; broadcaster_->sendTransform(tf); } private: std::shared_ptr<tf2_ros::StaticTransformBroadcaster> broadcaster_; }; int main(int argc, char** argv) { rclcpp::init(argc, argv); rclcpp::spin(std::make_shared<StaticBroadcaster>()); rclcpp::shutdown(); return 0; }

静态广播器发一次就够了，不需要定时器。这里雷达装在车体前方 0.2 米、上方 0.3 米处，朝向和车体一致，所以四元数是单位四元数(0,0,0,1)。Python 版对应：

import rclpy from rclpy.node import Node from tf2_ros import StaticTransformBroadcaster from geometry_msgs.msg import TransformStamped class StaticBroadcaster(Node): def __init__(self): super().__init__('static_broadcaster_py') self.broadcaster = StaticTransformBroadcaster(self) tf = TransformStamped() tf.header.stamp = self.get_clock().now().to_msg() tf.header.frame_id = 'base_link' tf.child_frame_id = 'laser' tf.transform.translation.x = 0.2 tf.transform.translation.y = 0.0 tf.transform.translation.z = 0.3 tf.transform.rotation.w = 1.0 self.broadcaster.sendTransform(tf) def main(): rclpy.init() node = StaticBroadcaster() try: rclpy.spin(node) except KeyboardInterrupt: pass finally: node.destroy_node() rclpy.shutdown() if __name__ == '__main__': main()

4.5 监听器：查询 laser 在 odom 下的位姿

监听是另一套 API，核心是Buffer和TransformListener。C++ 版：

#include <chrono> #include <memory> #include "rclcpp/rclcpp.hpp" #include "tf2_ros/buffer.h" #include "tf2_ros/transform_listener.h" #include "tf2/exceptions.h" using namespace std::chrono_literals; class TfListener : public rclcpp::Node { public: TfListener() : Node("tf_listener_cpp") { buffer_ = std::make_unique<tf2_ros::Buffer>(this->get_clock()); listener_ = std::make_shared<tf2_ros::TransformListener>(*buffer_); timer_ = this->create_wall_timer( 500ms, std::bind(&TfListener::lookup, this)); } private: void lookup() { try { auto tf = buffer_->lookupTransform("odom", "laser", tf2::TimePointZero); RCLCPP_INFO(this->get_logger(), "laser in odom: x=%.3f y=%.3f z=%.3f", tf.transform.translation.x, tf.transform.translation.y, tf.transform.translation.z); } catch (const tf2::TransformException& ex) { RCLCPP_WARN(this->get_logger(), "lookup failed: %s", ex.what()); } } std::unique_ptr<tf2_ros::Buffer> buffer_; std::shared_ptr<tf2_ros::TransformListener> listener_; rclcpp::TimerBase::SharedPtr timer_; }; int main(int argc, char** argv) { rclcpp::init(argc, argv); rclcpp::spin(std::make_shared<TfListener>()); rclcpp::shutdown(); return 0; }

lookupTransform的第三个参数tf2::TimePointZero表示“取最新可用的变换”。如果你想查某个历史时刻的变换，就传具体时间戳。这里有个大坑：如果传了具体时间戳但那个时刻的数据还没到，会抛异常。所以调试阶段一律用TimePointZero，等系统稳定了再考虑历史查询。

异常处理必须写，不写的话 TF 树还没建好时程序直接崩。TransformException是基类，能捕获所有 TF 相关异常。Python 版：

import rclpy from rclpy.node import Node from tf2_ros import Buffer, TransformListener, TransformException class TfListener(Node): def __init__(self): super().__init__('tf_listener_py') self.buffer = Buffer() self.listener = TransformListener(self.buffer, self) self.timer = self.create_timer(0.5, self.lookup) def lookup(self): try: tf = self.buffer.lookup_transform('odom', 'laser', rclpy.time.Time()) t = tf.transform.translation self.get_logger().info( f'laser in odom: x={t.x:.3f} y={t.y:.3f} z={t.z:.3f}') except TransformException as ex: self.get_logger().warn(f'lookup failed: {ex}') def main(): rclpy.init() node = TfListener() try: rclpy.spin(node) except KeyboardInterrupt: pass finally: node.destroy_node() rclpy.shutdown() if __name__ == '__main__': main()

Python 里rclpy.time.Time()默认就是零时刻，等价于 C++ 的TimePointZero。注意Buffer的构造在 Python 里不需要传时钟，这是和 C++ 的一个差异。

5. launch 批量启动：从手敲命令到一键拉起

5.1 为什么不用 ros2 run 一个个开

三个节点，开三个终端敲三条ros2 run，听起来还行。但真实项目里节点十几个，还要传参数、设命名空间、控制启动顺序，手敲根本管不过来。launch 的价值就在这：把启动逻辑代码化，一次写好，以后一条命令拉起整个系统。

而且 launch 能做的事远不止启动节点。它能启动其他 launch 文件、能执行命令、能设环境变量、能根据条件决定启不启动某个节点。这些能力在调试时特别有用，比如你想临时关掉某个节点看影响，加个参数控制就行，不用改代码。

5.2 Python launch 文件的基本骨架

先看 C++ 包的 launch 文件：

from launch import LaunchDescription from launch_ros.actions import Node def generate_launch_description(): return LaunchDescription([ Node( package='tf_demo_cpp', executable='odom_broadcaster', name='odom_broadcaster', output='screen', ), Node( package='tf_demo_cpp', executable='static_broadcaster', name='static_broadcaster', output='screen', ), Node( package='tf_demo_cpp', executable='tf_listener', name='tf_listener', output='screen', ), ])

generate_launch_description是固定入口函数，必须返回一个LaunchDescription。每个Node描述一个要启动的节点，package是包名，executable是可执行文件名（C++ 里就是 CMake 里add_executable的名字），name是运行时节点名，output='screen'让日志打到终端而不是被吞掉。

5.3 用循环批量生成节点：真正的“批量启动”

上面三个节点是手写的，如果我要启动 10 个传感器节点呢？手写十遍太蠢。Python launch 的优势就在这，可以用循环：

from launch import LaunchDescription from launch_ros.actions import Node def generate_launch_description(): nodes = [] for i in range(3): nodes.append(Node( package='tf_demo_py', executable='odom_broadcaster', name=f'odom_broadcaster_{i}', namespace=f'robot{i}', output='screen', )) return LaunchDescription(nodes)

这里用了namespace，每个节点放到独立的命名空间下，话题自动变成/robot0/tf、/robot1/tf这样。多机器人场景就是这么搞的。注意name必须唯一，否则 ROS2 会警告节点名冲突。

5.4 传参数和重映射话题

节点经常需要参数，launch 里用parameters传：

Node( package='tf_demo_py', executable='odom_broadcaster', name='odom_broadcaster', parameters=[{'publish_rate': 20.0, 'frame_prefix': 'robot_'}], remappings=[('/tf', '/robot0/tf'), ('/tf_static', '/robot0/tf_static')], output='screen', )

parameters是个列表，可以传字典，也可以传 YAML 文件路径。remappings把话题改名，多机器人时特别有用，每个机器人的 TF 发到自己的话题，互不干扰。这里有个细节：重映射/tf的时候别忘了/tf_static，很多人只改了前者，结果静态变换还是发到全局话题，导致 TF 树混乱。

5.5 CMakeLists 和 setup.py 的安装配置

C++ 包要在CMakeLists.txt里加：

add_executable(odom_broadcaster src/odom_broadcaster.cpp) ament_target_dependencies(odom_broadcaster rclcpp tf2 tf2_ros geometry_msgs) add_executable(static_broadcaster src/static_broadcaster.cpp) ament_target_dependencies(static_broadcaster rclcpp tf2 tf2_ros geometry_msgs) add_executable(tf_listener src/tf_listener.cpp) ament_target_dependencies(tf_listener rclcpp tf2 tf2_ros geometry_msgs) install(TARGETS odom_broadcaster static_broadcaster tf_listener DESTINATION lib/${PROJECT_NAME} ) install(DIRECTORY launch DESTINATION share/${PROJECT_NAME} )

install(DIRECTORY launch ...)这行千万别漏，否则ros2 launch找不到 launch 文件。Python 包在setup.py里配：

entry_points={ 'console_scripts': [ 'odom_broadcaster = tf_demo_py.odom_broadcaster:main', 'static_broadcaster = tf_demo_py.static_broadcaster:main', 'tf_listener = tf_demo_py.tf_listener:main', ], }, data_files=[ ('share/ament_index/resource_index/packages', ['resource/' + package_name]), ('share/' + package_name, ['package.xml']), (os.path.join('share', package_name, 'launch'), glob('launch/*.launch.py')), ],

data_files里那行glob('launch/*.launch.py')就是安装 launch 文件的，同样别漏。改完setup.py记得colcon build重新构建。

6. rosbag2 录包与回放：把运行过程留下来

6.1 录制：只录该录的，别贪多

系统跑起来后，另开终端录包：

ros2 bag record -o demo_bag /odom /scan /tf /tf_static

-o指定输出目录名，后面跟话题列表。录完 Ctrl+C 停止，会在当前目录生成demo_bag文件夹，里面是.db3数据库文件和metadata.yaml。

几个实用参数：

我一般不用-a，显式列话题更可控。录之前先用ros2 topic list确认话题名对不对，别录了半天发现话题名拼错了。

6.2 回放：验证 TF 树是否完整

回放命令很简单：

ros2 bag play demo_bag

但回放 TF 有个关键点：/tf_static的回放行为。rosbag2 对静态话题做了特殊处理，回放时会以锁存方式重发，所以即使你回放时监听器启动晚了，也能收到静态变换。这个特性是 rosbag2 内置的，不用你手动处理。

回放时开个终端跑监听节点，看能不能正常打印laser在odom下的位姿。如果能打印，说明录包时 TF 树是完整的；如果报lookup failed，八成是录包时漏了/tf_static。

回放还有几个常用参数：

ros2 bag play demo_bag --rate 0.5 # 半速回放，方便观察 ros2 bag play demo_bag --loop # 循环回放 ros2 bag play demo_bag --start-offset 5.0 # 从第5秒开始

--rate 0.5在调试时特别好用，数据变化慢下来，你能看清每一帧的坐标变化。

6.3 查看包信息：录完先确认再回放

录完包别急着回放，先看看里面有什么：

ros2 bag info demo_bag

输出会列出话题、消息数、时长、大小。重点看话题列表里有没有/tf和/tf_static，消息数是不是合理。如果/tf_static消息数是 0，说明录的时候静态广播器没启动或者已经退出了，这个包就是废的，得重录。

ros2 bag info还能看到每个话题的消息类型和频率，如果某个话题频率异常低，可能是节点出问题了。这个命令我每次录完必跑，花两秒钟能省很多排查时间。

7. 常见问题与排查技巧实录

7.1 TF 相关的高频问题

问题一：RViz2 里模型乱飘或者不显示。九成是 TF 树断了。用ros2 run tf2_tools view_frames生成 TF 树图，看看是不是缺了某一环。常见原因是静态变换没发，或者动态变换的frame_id和child_frame_id写反了。记住：frame_id是父，child_frame_id是子，写反了树就倒过来了。

问题二：lookupTransform一直抛异常。先确认要查的两个坐标系在不在同一棵树里。TF 树是树不是图，两个坐标系必须有共同的祖先才能查变换。如果odom和laser分属两棵独立的树，永远查不到。用view_frames一看便知。

问题三：时间戳对不上。回放旧包时，如果监听节点用的是系统时间，而包里的时间戳是过去的，lookupTransform用TimePointZero能查到最新，但用具体时间戳就会失败。解决办法是回放时加--clock参数发布模拟时钟，监听节点用 ROS 时钟而不是系统时钟。

7.2 launch 相关的坑

问题一：ros2 launch报找不到 launch 文件。检查CMakeLists.txt或setup.py里有没有安装 launch 目录，改完有没有重新colcon build。launch 文件是安装到install/目录下的，源码目录改了不重新构建，运行的还是旧的。

问题二：节点启动了但立刻退出。看output='screen'有没有加，没加的话日志被吞了看不到报错。加了之后如果看到what(): failed to initialize之类的，多半是依赖没装全或者参数类型不对。

问题三：节点名冲突警告。同一个 launch 里两个节点用了相同的name，ROS2 会警告并可能行为异常。批量生成节点时用循环变量拼名字，保证唯一。

7.3 rosbag2 的注意事项

注意一：录包时磁盘空间。高频话题录久了文件巨大，录之前df -h看一眼剩余空间。我见过有人录了一晚上把根分区录满导致系统起不来的。

注意二：回放时不要同时录包。边放边录容易把回放的数据又录进去，形成套娃。要录回放过程的话，明确指定话题，别用-a。

注意三：metadata.yaml别乱改。这个文件记录了包的结构信息，手动改容易导致包损坏。要裁剪包用ros2 bag convert或者重新录。

7.4 双语言混用的经验

C++ 和 Python 节点混在一个系统里跑完全没问题，ROS2 的通信是语言无关的。但有两个细节要注意。一是消息定义必须一致，都用geometry_msgs/msg/TransformStamped，别一个用自定义消息一个用标准消息。二是时间同步，如果 C++ 节点用系统时钟、Python 节点用 ROS 时钟，回放时会出现时间戳对不上的问题，统一用get_clock()->now()最稳妥。

8. 几个能直接抄的调试命令和参数速查

调试 TF 最常用的三个命令，我基本每次都要用：

# 实时查看两个坐标系之间的变换 ros2 run tf2_ros tf2_echo odom laser # 生成 TF 树结构图（会在当前目录生成 frames.pdf） ros2 run tf2_tools view_frames # 查看当前所有话题及其频率 ros2 topic hz /tf

tf2_echo会持续打印两个坐标系之间的平移和旋转，如果一直显示Waiting for transform，说明树里查不到这两个坐标系的关系。view_frames生成的 PDF 能直观看到整棵树的结构，哪一环断了清清楚楚。

关于参数，我把这次用到的关键参数整理成表，方便你对照调整：

广播频率不是越高越好。20Hz 对大多数场景够用，设太高反而增加 CPU 负担和网络流量。真实机器人上里程计广播一般 10 到 50Hz，传感器静态变换发一次就够。

9. 我踩过的几个坑，你大概率也会遇到

第一个坑是四元数半角，前面提过了，这里再强调一遍。手写四元数的时候，绕 Z 轴 yaw 角对应的是sin(yaw/2)和cos(yaw/2)，不是sin(yaw)。这个错误不会报错，只会让旋转看起来不对劲，特别难排查。我的建议是能用setRPY就用setRPY，别手算。

第二个坑是静态变换录包丢失。我第一次录包时只录了/tf没录/tf_static，回放时动态变换正常，静态变换全没了，RViz2 里雷达坐标系直接消失。后来养成习惯，录包话题列表里/tf_static永远排在前面。

第三个坑是launch 文件改了不重新构建。有次我改了 launch 里的参数，ros2 launch跑出来还是旧行为，折腾了半小时才发现是没colcon build。launch 文件是安装到install/目录的，源码改了必须重新构建才生效。这个坑新手几乎必踩。

第四个坑是回放时时钟问题。回放旧包时监听节点用系统时间，导致lookupTransform查不到数据。解决办法是回放加--clock，监听节点用self.get_clock().now()而不是time.time()。ROS2 里时间相关的操作一律走 ROS 时钟，别用系统时间。

第五个坑是命名空间和话题重映射搞混。命名空间是给节点加前缀，话题重映射是改话题名，两者作用范围不一样。多机器人场景下，用命名空间更省事，因为节点名、话题名、服务名全都会自动加前缀，不用一个个重映射。

这套实训做完，你应该对 ROS2 的启动管理、数据记录和坐标变换有了完整的认识。后面想深入的话，可以试试把 TF 树接到真实的 URDF 模型上，用robot_state_publisher自动发布关节变换，那又是另一个层面的东西了。