ROS2的Launch系统,我用了这么多年,带给我的最深体会是:它不是让你少敲几行命令那么简单,而是彻底改变了你组织机器人软件系统的方式。

在绝大多数ROS2项目里,节点数量一旦超过五个,真正的挑战就出现了。你面对的不再是“如何让某个节点跑起来”,而是“如何把几十个进程组织成一个可靠、可复现、可调试的整体系统”。Launch系统正是为这个目标而生的。它是一张进程编排的蓝图,告诉整个系统要拉起哪些节点、按什么顺序、用什么参数、放进哪个命名空间、在什么事件发生后做出何种响应。

我最早接触Launch时,并没有意识到它的分量,只是把它当作一个“能一次性跑多个节点的工具”。后来在一个多机器人协同项目里,需要同时运行底盘驱动、传感器数据流、SLAM、路径规划、上层决策状态机,这还只是单台机器人。当扩展到两到三台机器人,并且要求每台机器人的节点都跑在独立的命名空间里时,如果还沿用最开始那种“开十几个终端,一个一个source、一个一个 ros2 run”的流程,别说管理,连复现上一次能跑通的启动序列都做不到。从那时起,我才算真正意识到,Launch系统解决的不是“启动便利”问题,而是“系统级可复现性”问题。

这篇文章会围绕Launch系统最实用、最核心的几个维度展开:先理解它的核心概念与配置文件结构,再梳理Launch文件从基础到进阶的编写方式,然后讲透参数替换与条件控制这些容易被新手忽略的细节,最后结合多机器人平台的编排经验,说明事件处理机制在复杂场景下的作用。无论你是刚开始学ROS2的菜鸟,还是已经在用它做项目的开发者,只要能耐下心来把Launch的底层逻辑理清楚,它对你项目效率的提升会是立竿见影的。

1. Launch系统的设计动机与核心概念

Launch系统在ROS2里承载的任务,远远不止“把多个 ros2 run 命令拼在一起执行”这么简单。要理解它的设计动机,你得先知道ROS2节点生命周期管理这件事有多麻烦。

1.1 从多个终端到一张可复现的启动蓝图

先回想一下最原始的方式:手工打开多个终端,在每个终端里 source 环境,然后逐个执行各种形式的启动命令。这种方式在只有两三个节点的时候没什么问题,但是一旦节点多起来,麻烦就立刻暴露出来了:

  • 状态不可复现:下次启动时,你未必记得上次每个终端里执行的准确命令。参数写错一个,整个系统行为就变了,排查起来费时费力。
  • 依赖顺序没法保证:有些节点必须等前置节点起来之后才能正常通信。手工方式下,你只能靠“等几秒再开下一个终端”这种朴素方法,很不稳定。
  • 没有统一视角:每个终端只是各自的输出流,日志散落一地,出了问题很难对应到具体是哪个节点的哪次初始化。

Launch系统就是把这一整套流程固化成一张“启动蓝图”。你写一次Launch文件,之后每次启动都在执行同一套经过验证的顺序和参数配置。这种可复现性,对于做机器人系统集成的人来说,其价值怎么强调都不过分。

1.2 Launch系统与ros2 launch命令的关系

在ROS2里,Launch系统由两个层面组成:一个是底层的 Python 库,提供了Launch描述、执行和事件处理的完整框架;另一个是上层命令工具,它把 Launch 文件的解析和执行过程封装成一个简单易用的接口。

根据我的经验,很多初学者会把 Launch 文件格式和 ros2 launch 命令混淆。实际上,前者只是描述“系统应该如何启动”的静态声明,后者才是真正去解析和执行这份声明的运行时工具。整个流程大致是这样的:

  1. Launch文件被解析为一份描述启动蓝图的数据结构,这个过程会展开变量替换、条件判断等静态逻辑。
  2. 描述结构被交给Launch服务执行,系统开始安排启动任务,期间会持续监控所有启动进程的状态。
  3. 当启动过程中出现特定事件(比如某个节点启动失败、某个进程退出),事件处理机制会触发相应的回调逻辑,决定是继续、重试还是终止。
  4. 整个启动任务运行期间,Launch服务会维护进程级别的状态信息,并提供查询接口,让你能够了解当前系统实际跑起来了哪些节点。

这个分层设计带来的直接好处是,你可以在不改变底层执行框架的前提下,用不同方式描述一个系统的启动方式,比如用XML、YAML或者纯Python。不同团队可以根据习惯和场景选择自己最容易维护的格式。

1.3 三种Launch文件格式:XML、YAML与Python

ROS2 Launch系统一共支持三种文件格式,它们底层共享同一个描述模型,但表达方式和适用场景有明显差异:

格式 文件扩展名 可读性 灵活性 主要适用场景
XML .launch.xml 高 中 快速编写静态结构、团队协作、配置声明
YAML .launch.yaml 高 中 喜欢简洁缩进风格、配置较多的场景
Python .launch.py 中 高 复杂逻辑、条件分支、变量计算、动态生成

我的建议是,刚开始不要在这上面纠结太久。如果你只是想让系统跑起来,XML 或者 YAML 就够用了;如果你需要写一些带有循环、条件判断、动态参数计算的复杂启动逻辑,Python 格式会让你轻松得多。

不过要提醒一点,虽然格式不同,但它们转换之后得到的底层描述结构是等价的。这意味着你完全可以在一个项目里混用不同格式的Launch文件,只要通过 ros2 launch 正确指定文件路径即可。

2. 从零开始编写Launch文件:节点启动与参数传递

这一节从最实际的场景出发,教你如何把一个手动的 ros2 run 多节点启动过程改写成一份完整的 Launch 文件。我会以Python格式为主展开,因为它的表达能力强,也最容易理解和排查。

2.1 最简Launch文件的结构

先看一个最基础的示例。假设你有两个节点,一个是摄像头驱动,一个是图像处理节点,原本的启动命令如下:

ros2 run camera_driver camera_node --ros-args -p device_id:=0
ros2 run image_processor processor_node --ros-args -p queue_size:=10

改成Launch文件之后,它的结构长这样:

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        Node(
            package='camera_driver',
            executable='camera_node',
            name='camera_node',
            parameters=[{'device_id': 0}]
        ),
        Node(
            package='image_processor',
            executable='processor_node',
            name='processor_node',
            parameters=[{'queue_size': 10}]
        ),
    ])

简单到几乎不需要解释。每个 Node 动作则对应一次节点启动,你需要告诉它三个最核心的信息:可执行文件位于哪个 package、可执行文件的名字是什么、要不要给节点起一个自定义名称。

2.2 Node动作的常用配置字段

Node 动作在 Launch 文件里起着决定性作用,它支持相当丰富的配置字段,我把平时用得最多的整理成一份速查表:

字段 作用 示例
package 节点所属功能包 package='camera_driver'
executable 功能包内的可执行文件名 executable='camera_node'
name 给节点起的新名称(覆盖原有节点名) name='left_camera'
namespace 把节点放入指定命名空间 namespace='robot1'
parameters 传递参数列表 parameters=[{'device_id': 0}]
remappings 话题/服务的重映射 remappings=[('/image', '/camera/image')]
arguments 传递给节点的命令行参数 arguments=['--ros-args', '-p', 'queue_size:=10']
output 日志输出方式,可选 screen 或 log output='screen'
prefix 节点启动命令前缀,常用于 gdb 或 valgrind 调试 prefix='gdb -ex run --args'
cwd 节点进程的工作目录 cwd='package'
env 自定义环境变量 env={'MY_FLAG': '1'}

其中,parameters 和 remappings 是日常使用里最常写的配置项。命名空间字段在单机器人项目里可能用不到,但如果你做多机器人协同,它几乎是必用的。

2.3 使用ros2 launch执行与调试

写好了Launch文件之后,执行方式很简单:

ros2 launch path/to/my_launch_file.launch.py

如果你在功能包目录里组织好了 launch 文件夹,也可以用包名直接定位:

ros2 launch my_bringup_package bringup.launch.py

启动过程中,如果你希望看到每个节点的实时输出,可以在 Node 动作里设置 output='screen'。如果你怀疑某个节点参数没有传入生效,可以在运行时用 ros2 param list 和 ros2 param get 检查,这种方式比反复改代码重编译快得多。

3. 参数替换与条件控制:让Launch文件活起来

如果你只是需要把几个固定命令打包启动,前面两节的内容已经够用了。但现实项目里,Launch文件通常需要具备一定的“弹性”,比如在不同场景下启动不同的节点组合、在同一套代码里切换不同的配置参数。这时候就需要理解参数替换和条件控制机制。

3.1 变量的来源与替换机制

ROS2 Launch提供了一类特殊的对象,用来在解析Launch文件时动态地产生字符串值。它们以 launch.substitutions 模块为入口,其中最常用的是:

  • LaunchConfiguration:用来从外部命令行或父级Launch文件读取配置变量。
  • EnvironmentVariable:用来读取系统环境变量的值。
  • PythonExpression:用来执行一段简短的Python表达式并返回计算结果。
  • PathJoinSubstitution:用来把多个路径片段拼接成一个完整的文件路径。

我先重点说一下 LaunchConfiguration,因为它是几乎每个实际项目里都会用到的替代对象。它允许你在Launch文件中声明一个变量名,然后在执行 ros2 launch 时通过命令行传入该变量的值,示例代码如下:

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node

def generate_launch_description():
    device_id = LaunchConfiguration('device_id')
    return LaunchDescription([
        DeclareLaunchArgument(
            'device_id',
            default_value='0',
            description='Camera device index'
        ),
        Node(
            package='camera_driver',
            executable='camera_node',
            name='camera_node',
            parameters=[{'device_id': device_id}]
        ),
    ])

这样,你在启动系统时就可以用下面的命令来覆盖默认值:

ros2 launch camera_bringup camera.launch.py device_id:=2

这种写法比硬编码参数值要舒服得多,尤其是当同一个Launch文件需要适配多套硬件配置时,你只需要维护一份Launch文件,剩下的事情交给命令行参数。

3.2 条件表达式:让启动行为按场景变化

除了变量,Launch系统还支持条件动作。WhenCondition 和 UnlessCondition 是最常用的两个条件类,你可以用它们控制某个节点或者某个动作是否会被执行。来看一个典型场景:在仿真环境里启动传感器数据模拟器,在实机环境里启动真实驱动节点。

from launch.actions import DeclareLaunchArgument, ExecuteProcess
from launch.conditions import IfCondition, UnlessCondition
from launch.substitutions import LaunchConfiguration

def generate_launch_description():
    use_sim_time = LaunchConfiguration('use_sim_time')
    return LaunchDescription([
        DeclareLaunchArgument(
            'use_sim_time',
            default_value='false'
        ),
        Node(
            package='sensor_driver',
            executable='real_sensor_node',
            condition=UnlessCondition(use_sim_time)
        ),
        Node(
            package='sensor_driver',
            executable='sim_sensor_node',
            condition=IfCondition(use_sim_time)
        ),
    ])

这个模式在实际项目中非常常见。它让同一份Launch文件可以同时服务于仿真验证和实机测试,避免维护两套几乎重复的启动配置。

3.3 路径拼接与配置文件加载

机器人项目里,很多节点需要加载YAML参数文件,而参数文件的路径往往依赖环境变量或者安装路径。这时候,PathJoinSubstitution 会派上用场。它可以把功能包的安装路径、相对子目录和文件名组合成一个绝对路径,避免硬编码路径导致的环境迁移问题。例如:

from launch.substitutions import PathJoinSubstitution
from launch_ros.substitutions import FindPackageShare

config_file = PathJoinSubstitution([
    FindPackageShare('my_bringup_package'),
    'config',
    'nav2_params.yaml'
])

nav2_node = Node(
    package='nav2_controller',
    executable='controller_server',
    parameters=[config_file]
)

这段代码的含义是:先通过 FindPackageShare 找到 my_bringup_package 在系统里的共享目录,然后拼接上 config 目录和 nav2_params.yaml 文件名,最终得到一个可用的绝对路径。好处是无论你的工作空间安装在什么位置,这个配置文件的路径都能被正确解析,不会因为换了一台机器就报找不到文件。

4. 生命周期与事件管理:应对复杂启动序列

当机器人系统规模变大之后,节点的启动往往不是简单的“一次性全部拉起”就能解决的。比如,导航系统里,地图服务器要先加载地图,局部规划器要等到全局地图发布之后才能正常初始化;又比如多机器人协同场景中,通信中间件节点必须先启动,所有业务节点之后才注册上来。Launch系统的事件机制正是为这类有依赖关系的启动过程设计的。

4.1 注册事件与回调动作

在Launch框架里,事件与回调是核心抽象。你可以注册某些事件(比如进程启动完成、进程退出、定时器触发等),然后绑定对应的回调动作。最常用的注册事件类是 RegisterEventHandler,配合 OnProcessExit 和 OnProcessStart 使用。

举一个实际例子:你希望当某个节点(比如地图服务器)启动成功后,再去启动后续的导航节点。可以用 OnProcessExit 来监听“地图服务器进程退出”这个事件,但更多时候你会用 OnProcessStart 监听“某个进程启动完成”,并在回调里执行下一个动作。

from launch.actions import RegisterEventHandler, TimerAction, LogInfo
from launch.event_handlers import OnProcessStart

def generate_launch_description():
    map_server_node = Node(
        package='nav2_map_server',
        executable='map_server',
        parameters=[map_config]
    )

    lifecycle_manager_node = Node(
        package='nav2_lifecycle_manager',
        executable='lifecycle_manager',
        parameters=[{'autostart': True}]
    )

    start_lifecycle_after_map = RegisterEventHandler(
        OnProcessStart(
            target_action=map_server_node,
            on_start=[lifecycle_manager_node]
        )
    )

    return LaunchDescription([
        map_server_node,
        start_lifecycle_after_map,
    ])

这个模式的意义在于,你不再依赖“sleep几秒”这种粗暴的同步方式,而是利用进程真实状态作为触发信号,系统间的启动顺序因此变得更加可靠。

4.2 定时器与延迟启动

某些场景下,你确实需要人为地延迟某个动作的执行。比如等待硬件设备完成初始化,或者等待某个网络服务变得可用。TimerAction 可以让你实现“在指定时间后执行某个动作”的需求。

from launch.actions import TimerAction, LogInfo

delayed_log = TimerAction(
    period=5.0,
    actions=[
        LogInfo(msg='5 seconds passed, starting delayed node...')
    ]
)

这种延时启动可以作为兜底方案,但我不建议把它作为依赖管理的首选。毕竟,如果上游节点启动慢了,你的定时器并不会感知到这个变化,延迟启动就变成了一个不可靠的“盲等”。更稳健的方案是组合使用事件回调与生命周期管理。

4.3 应对启动失败的恢复策略

Launch系统的事件处理不仅支持正向的“A完成后启动B”,同样支持处理异常状态。例如,你可以在某个节点进程退出时,记录退出码并决定是否重启该节点,或者直接终止整个启动任务,避免系统陷入半启动状态。

from launch.actions import RegisterEventHandler, Shutdown
from launch.event_handlers import OnProcessExit

def on_exit_handler(event):
    return [Shutdown(reason='critical node exited')]

def generate_launch_description():
    critical_node = Node(
        package='critical_pkg',
        executable='critical_node'
    )
    exit_handler = RegisterEventHandler(
        OnProcessExit(
            target_action=critical_node,
            on_exit=on_exit_handler
        )
    )
    return LaunchDescription([critical_node, exit_handler])

这种“当关键节点意外退出时,自动关闭整个Launch任务”的策略,在无人值守场景里非常实用。它至少保证系统在异常情况下不会带着残缺状态继续运行,给上层监控和恢复机制留出判断空间。

5. 多机器人与命名空间编排实践经验

前面四节的内容偏通用,这一节我结合自己的实际项目经验,说说Launch系统在“多机器人平台”这种复杂场景下的具体用法。这里的核心挑战不在于“启动多少节点”,而在于“同一段代码如何在多个机器人实例上复用”。

5.1 用namespace隔离多个实例

在多机器人系统里,如果两台机器人运行着同样的导航节点,话题名一定会冲突——因为它们发布和订阅的是同名话题。Launch系统给出的答案是命名空间。你只需要给每个机器人的节点组设置不同的 namespace,所有话题和服务就会自动带上命名空间前缀。

def generate_robot_node(namespace):
    return Node(
        package='robot_bringup',
        executable='robot_engine_node',
        namespace=namespace,
        name='engine_node',
        parameters=[{'robot_id': namespace}]
    )

def generate_launch_description():
    return LaunchDescription([
        generate_robot_node('robot1'),
        generate_robot_node('robot2'),
        generate_robot_node('robot3'),
    ])

这个函数式写法的妙处在于,你完全可以用一个列表生成式去生成任意数量的机器人实例,只需要维护一个机器人清单即可。代码重复量大幅降低,也排除了手写复制粘贴时容易出现的低级错误。

5.2 分组启动与资源隔离

ROS2 Launch还提供了 GroupAction,你可以把若干个动作放到一个组里,并对整个组整体设置命名空间、环境变量或参数文件。这种分组方式不仅让 Launch 文件结构更清晰,还能在同一个启动任务里实现不同组的配置差异化。

from launch.actions import GroupAction
from launch_ros.actions import PushRosNamespace

robot1_group = GroupAction(
    actions=[
        PushRosNamespace('robot1'),
        Node(package='lidar_driver', executable='lidar_node'),
        Node(package='slam_toolbox', executable='slam_toolbox_node'),
    ]
)

注意这里用到了 PushRosNamespace 动作,它的作用是把当前作用域内的节点统一推送到指定命名空间,避免了在每个 Node 动作里重复写 namespace 字段。

5.3 复用Launch文件:include机制

当一个项目包含多个子系统时,比如底盘子系统、感知子系统、导航子系统,每个子系统都有自己独立的Launch文件,那么根Launch文件的主要工作就变成了“把它们按正确顺序组合起来”。include机制让这种组合变成了一件很自然的事。

from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource
from launch_ros.substitutions import FindPackageShare

def generate_launch_description():
    navigation_launch = IncludeLaunchDescription(
        PythonLaunchDescriptionSource([
            PathJoinSubstitution([
                FindPackageShare('navigation_bringup'),
                'launch',
                'navigation.launch.py'
            ])
        ]),
        launch_arguments={
            'map': 'warehouse_map.yaml',
            'use_sim_time': 'false'
        }.items()
    )

    perception_launch = IncludeLaunchDescription(
        PythonLaunchDescriptionSource([
            PathJoinSubstitution([
                FindPackageShare('perception_bringup'),
                'launch',
                'perception.launch.py'
            ])
        ]),
        launch_arguments={
            'camera_id': '2',
            'enable_detection': 'true'
        }.items()
    )

    return LaunchDescription([
        navigation_launch,
        perception_launch,
    ])

这种组合式设计让大型项目的启动配置变得像乐高积木一样可拼接。每个子系统的Launch文件独立演进,交给不同的人维护,根文件只负责整体编排。这个模式在量产级机器人和大型自动驾驶项目中几乎是标配做法。

6. 高频踩坑与排查思路

无论你对Launch系统多熟悉,日常开发中总会碰到一些让人头疼的问题。这一节我整理了几个高频的场景,并给出完整的排查链路,而不是直接告诉你答案。因为排查思路本身才是真正能复用的能力。

6.1 节点启动提示找不到可执行文件

表现:执行 ros2 launch 后,终端报错类似 “executable not found” 或者 “Failed to find executable”。

排查链路:

  1. 先直接在终端里尝试 ros2 run 对应包名和可执行名,如果能跑起来,说明包本身没问题,问题出在Launch文件的可执行名与包内实际名称不一致。
  2. 使用 ros2 pkg executables 命令查看包内实际注册的可执行文件清单,重点核对拼写和大小写。
  3. 如果 ros2 run 也报找不到可执行文件,说明这个包根本没有被构建出来。回到工作空间重新执行 colcon build --packages-select 指定包名。
  4. 构建完成后,务必检查当前终端环境是否已经 source 过 install/setup.bash,这是初学者最容易忽略的一步。
  5. 最后检查工作空间是否同时存在多个版本的同一功能包,它们在环境中互相覆盖也可能导致找不到可执行文件。

6.2 参数传入后节点读不到

表现:Launch文件里明明设置了 parameters,但是节点运行后,用 ros2 param get 查看参数时,发现值还是默认值。

排查链路:

  1. 先确认节点是否真的以你设置的 name 启动了,因为参数会与节点名绑定,如果你在Launch文件里覆盖了name,但节点内部读取参数的逻辑基于原节点名,就会出现参数“没生效”的错觉。
  2. 检查节点代码中参数声明部分,ROS2节点的参数通常需要先 declare_parameter 才能在运行时被Launch传入的参数覆盖,未声明的参数即使传入也会被忽略。
  3. 使用 ros2 param list 查看当前节点实际加载了哪些参数,以及它们的当前值。这能区分是“参数没传进去”还是“传进去了但代码没读取”。
  4. 如果参数值本身包含特殊字符(比如负号或分号),要检查Launch文件里的参数值类型是否与节点声明一致,有时整数和字符串类型不匹配也会导致设置失败。

6.3 资源路径解析失败

表现:Launch文件里明明写了配置文件路径,运行时却报“file not found”或者“No such file or directory”。

排查链路:

  1. 最直接的方法是打印最终解析出的实际路径。如果路径里带有 ~ 符号,注意Launch系统不会自动展开用户主目录,你需要使用 ReplaceSubstitution 或显式的绝对路径。
  2. 检查是否使用了 FindPackageShare,并确认对应的 package 已经构建且安装了 share 目录。可以手动到 install/ 目录下确认同名share目录是否存在。
  3. 如果你在 Launch 文件中使用了相对路径,它默认是相对于当前工作目录解析的,而不是相对于Launch文件所在目录。这是一个非常容易踩的坑,建议所有文件路径都使用 PathJoinSubstitution 拼接出绝对路径。
  4. 确认配置文件的权限是否可读,某些情况下文件存在但读取权限不足,也会报类似错误。

6.4 多机器人命名空间下话题连不上

表现:所有机器人都启动正常,各自的话题也在发布,但跨机器人的消息就是无法互通。

排查链路:

  1. 先使用 ros2 topic list 查看所有话题名,确认每台机器人的话题是否都已经带上了正确的命名空间前缀。
  2. 检查订阅方和发布方的话题名是否完全一致,不要忽略命名空间前缀的差异。
  3. 如果使用了 DDS 的域隔离,确认所有机器人都在同一个 DDS 域中。ROS_DOMAIN_ID 环境变量不一致会导致节点虽然在同一网络上,但彼此完全不可见。
  4. 最后查看每台机器人的节点图 ros2 node list,确认双方节点都在线,且没有被重复的节点名覆盖。

7. 进阶实践:启动流程的状态观测与日志管理

这一节的出发点很直接:当你的Launch文件已经复杂到一定程度后,光靠“启动成功”这个最终结果来判断系统是否正常,是远远不够的。你需要知道整个启动过程中发生了什么、哪些节点在什么时候起来了、哪个环节耗时最长。

7.1 日志输出与节点输出流转

在Launch文件里,几乎所有节点都建议设置 output='screen',这样节点的标准输出会直接显示在启动终端里,方便实时观察。但如果你运行的是一个持续数十个小时的巡检任务,屏幕输出反而会带来日志堆积问题。

更合理的方式是让输出同时保留两份:一份进入ROS2的日志系统,一份写入独立的日志文件。你可以在启动时用 ros2 launch 配合系统输出重定向,也可以在节点内部通过 rclcpp 或 rclpy 的日志配置实现文件输出。实测下来,在节点内部统一配置日志输出是最可控的方案,因为它不依赖外部重定向,也不会因为容器环境缺少 shell 功能而失效。

7.2 使用命令工具检查当前启动状态

Launch运行期间,你可以打开另一个终端,使用 ros2 node list 查看当前所有活跃节点。这个命令的输出可以直接与 Launch 文件里的 Node 动作做一一对应,是排查“某个节点是否真的被拉起”的最快途径。

另外,ros2 param list 和 ros2 interface list 也经常配合使用。前者可以验证参数是否按预期传入,后者可以快速查看当前可用的消息接口,尤其在调试自定义消息类型时非常有用。

7.3 把Launch与系统自启动结合

在机器人产品化过程中,Launch文件最终往往要接入系统的开机自启动机制。一个稳妥的做法是写一个 systemd 服务单元,在服务里执行 source 环境与 ros2 launch 命令。这样做的好处是,即使程序异常退出,systemd 也能按你配置的策略拉起新的实例,实现基本的高可用保障。

不过这里有一个容易被忽略的细节:很多机器人系统里,用户环境变量(比如 ROS_DOMAIN_ID、RMW_IMPLEMENTATION)都配置在 ~/.bashrc 里,而 systemd 服务默认不加载交互式shell的配置文件。所以,在 systemd 服务文件里,你需要明确指定这些环境变量,或者在服务启动命令前手动 source 环境文件,否则你可能会得到一套“手动启动正常,系统自启动始终异常”的诡异状态。我在多台设备上都踩过这个坑,写出来给各位提个醒。

8. 我对Launch系统的一些体会

用了几年Launch系统之后,回头看,它最打动我的地方其实不是“批量启动”这个表象,而是它把启动过程从一门“手艺”变成了一套“工程规范”。过去,启动一套多节点系统依赖的是个人经验:哪个终端先开、等多少秒、参数怎么填,全靠记忆。现在,这些全部沉淀在Launch文件里,代码评审的时候可以看,交付队友的时候可以直接复用,换一台新设备也只需要保证环境一致,剩下的行为完全可预期。

我记得有一次在外场调试,机器人系统突然无法正常启动。排查了半天最后发现是Launch文件里一个命名空间拼写错误,导致两个子系统的节点互相找不到话题。当时我就在想,这种问题如果出在传统的“手工终端启动”时代,恐怕要花上一整天才能定位。而有了结构化的 Launch 文件,你只需要对照节点名和话题名差异,几分钟就能判断出问题范围。这就是工程化带来的确定性红利。

如果你正准备在项目里引入Launch系统,我建议从一个小范围开始:挑选一个依赖关系最清晰的子系统,把它的手工启动流程固化成Launch文件,然后逐步扩大范围。不用一开始就想把所有功能包都写进一个巨型Launch文件里,那样的文件维护起来未必比手工启动轻松多少。合理的粒度应该是:每个子系统一个Launch文件,总系统一个根Launch文件,把所有子系统 include 进来。层次清晰,排查问题时也能逐级定位。

最后分享一个小技巧:在写Launch文件时,给你的节点命名尽量加上“模块前缀”,比如 navigation_controller、sensor_fusion_node。当系统规模变大以后,ros2 node list 的输出会变得非常长,良好的命名习惯能让你一眼扫过去就快速分辨出节点归属,省下的时间远比你当初命名时花掉的那一分钟要多得多。

Logo

聚焦RDK与具身智能,汇集机器人开发教程、开源案例和技术交流

更多推荐