ROS 2边学边练（25）-- 将多个节点组合到一个进程

前言

在ROS 2中，将多个节点（Nodes）组合到一个单独的进程（Process）中通常指的是使用“Composable Nodes”的特性。这个特性允许你定义可复用的组件（Components），然后将这些组件加载到一个或多个ROS 2节点中，而这些节点可以运行在同一个进程中。

这样做有几个好处：

资源优化：通过将多个节点组合到一个进程中，可以减少进程间通信的开销，并更有效地利用系统资源。
简化部署：对于需要多个节点协同工作的应用程序，将它们组合到一个进程中可以简化部署和配置。
代码重用：组件化的设计使得代码重用变得更加容易，因为你可以在不同的节点或应用程序中重用相同的组件。

在ROS 2中实现这一功能，通常涉及以下步骤：

定义组件：使用ROS 2的组件API定义可复用的组件。每个组件都封装了特定的功能，并且可以在运行时加载到节点中。
创建节点：创建一个或多个ROS 2节点，这些节点将作为组件的容器。这些节点可以配置为接受组件的加载。
加载组件：使用ROS 2的组件加载器（Component Loader）将组件加载到节点中。这通常涉及指定组件的类型和参数，并告诉ROS 2在何处找到这些组件的实现。
运行节点：启动包含组件的节点，这些节点现在将在一个共同的进程中运行，并共享相同的资源。

需要注意的是，尽管将多个节点组合到一个进程中可以提高效率和简化部署，但这也可能引入额外的复杂性。例如，需要确保进程内的所有节点都能够正确地处理并发操作和资源共享。因此，在决定是否将节点组合到一个进程时，应该仔细考虑应用程序的具体需求和约束。

简而言之，ROS 2中的“Composable Nodes”特性提供了一种灵活的方式来构建和管理ROS 2应用程序，通过组件化和进程内组合的方式，可以实现更高效、可重用和可配置的机器人和自动化系统。

动动手

运行例子

这些例子使用了rclcpp_components、ros2component和composition包中的可执行文件，并且可以使用以下命令运行。

发现可用的组件

想要查看当前工作空间中已注册且能用的组件列表，我们可以利用下面的命令进行查看：

$ros2 component types

返回符合条件的组件列表：

mike@mike-virtual-machine:~/Desktop/ros2_ws$ ros2 component types
examples_rclcpp_wait_set
  Talker
  Listener
examples_rclcpp_minimal_subscriber
  WaitSetSubscriber
  StaticWaitSetSubscriber
  TimeTriggeredWaitSetSubscriber
custom_action_cpp
  custom_action_cpp::FibonacciActionServer
  custom_action_cpp::FibonacciActionClient
logging_demo
  logging_demo::LoggerConfig
  logging_demo::LoggerUsage
composition
  composition::Talker
  composition::Listener
  composition::NodeLikeListener
  composition::Server
  composition::Client
demo_nodes_cpp_native
  demo_nodes_cpp_native::Talker
robot_state_publisher
  robot_state_publisher::RobotStatePublisher
quality_of_service_demo_cpp
  quality_of_service_demo::MessageLostListener
  quality_of_service_demo::MessageLostTalker
  quality_of_service_demo::QosOverridesListener
  quality_of_service_demo::QosOverridesTalker
teleop_twist_joy
  teleop_twist_joy::TeleopTwistJoy
demo_nodes_cpp
  demo_nodes_cpp::OneOffTimerNode
  demo_nodes_cpp::ReuseTimerNode
  demo_nodes_cpp::ServerNode
  demo_nodes_cpp::ClientNode
  demo_nodes_cpp::IntrospectionServiceNode
  demo_nodes_cpp::IntrospectionClientNode
  demo_nodes_cpp::ListParameters
  demo_nodes_cpp::ParameterBlackboard
  demo_nodes_cpp::SetAndGetParameters
  demo_nodes_cpp::ParameterEventsAsyncNode
  demo_nodes_cpp::EvenParameterNode
  demo_nodes_cpp::SetParametersCallback
  demo_nodes_cpp::ContentFilteringPublisher
  demo_nodes_cpp::ContentFilteringSubscriber
  demo_nodes_cpp::Talker
  demo_nodes_cpp::LoanedMessageTalker
  demo_nodes_cpp::SerializedMessageTalker
  demo_nodes_cpp::Listener
  demo_nodes_cpp::SerializedMessageListener
  demo_nodes_cpp::ListenerBestEffort
tf2_ros
  tf2_ros::StaticTransformBroadcasterNode
action_tutorials_cpp
  action_tutorials_cpp::FibonacciActionClient
  action_tutorials_cpp::FibonacciActionServer
image_tools
  image_tools::Cam2Image
  image_tools::ShowImage
joy
  joy::Joy
  joy::GameController
depthimage_to_laserscan
  depthimage_to_laserscan::DepthImageToLaserScanROS

运行时组合示例（ROS的发布者/订阅者）

应用程序运行时动态加载/卸载组件，灵活性好。

打开第一个终端，启动组件容器：

$ros2 run rclcpp_components component_container

打开第二个终端，检查确认组件容器是否正常运行中：

$ros2 component list

如果返回了/ComponentManager，则说明OK。再在此终端中加载talker组件（源码）：

$ros2 component load /ComponentManager composition composition::Talker

返回的结果中包含了该组件的名称以及其对应的ID号：

Loaded component 1 into '/ComponentManager' container node as '/talker'

现在我们再切换到第一个终端窗口（加载组件容器），看看里面有些什么内容出来：

可以看到，talker组件加载成功并且在不断发布消息。

我们再在第二个终端加载listener组件（源码），命令类似于talker,如下：

$ros2 component load /ComponentManager composition composition::Listener

也返回了类似的内容，组件名称listener以及ID号码：

Loaded component 2 into '/ComponentManager' container node as '/listener'

我们再检查一下当前的组件列表：

$ros2 component list

运行时组合示例（ROS的服务端和客户端）

同上面的发布者/订阅者例子，先开启一个终端加载组件容器：

$ros2 run rclcpp_components component_container

在第二个终端依次加载服务端组件（源码）和客户端组件（源码）：

$ros2 component load /ComponentManager composition composition::Server
$ros2 component load /ComponentManager composition composition::Client

我们看看第一个终端会有什么内容：

编译时组合示例（硬编码）

编译ROS 2应用程序时，通过硬编码的方式将节点组合在一起，编译时组合通常意味着在源代码中直接定义和实例化节点对象，并将它们组合成一个或多个进程。这种方式的优点包括简单性和确定性——编译后的应用程序结构是固定的，没有运行时的不确定性。然而，它也降低了灵活性，因为一旦应用程序被编译，节点的组合方式就不能轻易改变。

这个示例显示，可以复用相同的共享库来编译运行多个组件的单个可执行文件，而无需使用ROS接口。可执行文件包含上面的所有四个组件：发送器和侦听器以及服务器和客户端，它们在主函数中进行了硬编码。

我们可以通过下面的命令调用：

$ros2 run composition manual_composition

我们可以看看终端返回的内容：

编译组合的方式的组件是没法通过ros2 component list命令查看的。

运行时组合示例（使用dlopen）

在运行时组合示例中，当我们运行组件容器后并启动服务端/客户端时，可以看到在容器的终端输出中有打印出加载对应的so库并且找到对应的类最终实例化。

这个利用dlopen的示例通过创建一个通用容器进程并显式地传递库以加载而不使用ROS接口，提供了一种运行时组合的替代方案。该进程将打开每个库，并在库中创建每个“rclcpp:：Node”类的一个实例（源码），与前面的流程大同小异，只不过不用那么麻烦开启好几个终端而已。

$ros2 run composition dlopen_composition `ros2 pkg prefix composition`/lib/libtalker_component.so `ros2 pkg prefix composition`/lib/liblistener_component.so

可以与上面的截图比较一下，是不是差不多。

dlopen-composed组件通过ros2 component list命令也是发现不了的。

launch方式启动组合

上面的例子都是逐个命令运行组合，可以比较方便地对过程进行调试、诊断，但是我们也可以一条命令启动多个组件(源码)：

$ros2 launch composition composition_demo_launch.py

mike@mike-virtual-machine:~/Desktop/ros2_ws$ ros2 launch composition composition_demo_launch.py
[INFO] [launch]: All log files can be found below /home/mike/.ros/log/2024-04-15-21-18-04-617692-mike-virtual-machine-30402
[INFO] [launch]: Default logging verbosity is set to INFO
[INFO] [component_container-1]: process started with pid [30417]
[component_container-1] [INFO] [1713187085.127445213] [my_container]: Load Library: /opt/ros/iron/lib/libtalker_component.so
[component_container-1] [INFO] [1713187085.128648991] [my_container]: Found class: rclcpp_components::NodeFactoryTemplate<composition::Talker>
[component_container-1] [INFO] [1713187085.128759649] [my_container]: Instantiate class: rclcpp_components::NodeFactoryTemplate<composition::Talker>
[INFO] [launch_ros.actions.load_composable_nodes]: Loaded node '/talker' in container '/my_container'
[component_container-1] [INFO] [1713187085.143832047] [my_container]: Load Library: /opt/ros/iron/lib/liblistener_component.so
[component_container-1] [INFO] [1713187085.144882187] [my_container]: Found class: rclcpp_components::NodeFactoryTemplate<composition::Listener>
[component_container-1] [INFO] [1713187085.144981253] [my_container]: Instantiate class: rclcpp_components::NodeFactoryTemplate<composition::Listener>
[INFO] [launch_ros.actions.load_composable_nodes]: Loaded node '/listener' in container '/my_container'
[component_container-1] [INFO] [1713187086.141280013] [talker]: Publishing: 'Hello World: 1'
[component_container-1] [INFO] [1713187086.141662411] [listener]: I heard: [Hello World: 1]
[component_container-1] [INFO] [1713187087.141013738] [talker]: Publishing: 'Hello World: 2'
[component_container-1] [INFO] [1713187087.141367812] [listener]: I heard: [Hello World: 2]
[component_container-1] [INFO] [1713187088.141100795] [talker]: Publishing: 'Hello World: 3'
[component_container-1] [INFO] [1713187088.141427367] [listener]: I heard: [Hello World: 3]
[component_container-1] [INFO] [1713187089.141335387] [talker]: Publishing: 'Hello World: 4'
[component_container-1] [INFO] [1713187089.141511508] [listener]: I heard: [Hello World: 4]

作为共享库的组合节点

如果要从包中将可组合节点导出为共享库，并在另一个进行链接时组合的包中使用该节点，请将代码添加到CMake文件中，该文件将导入下游包中的实际目标。然后安装生成的文件并导出生成的文件。一个参考例子：ROS Discourse - Ament best practice for sharing libraries

合成非节点衍生组件

在ROS 2中，组件允许更有效地使用系统资源，并提供了一个强大的功能，使您能够创建不与特定节点绑定的可重用功能。

使用组件的一个优点是，它们允许我们将非节点派生的功能创建为独立的可执行文件或共享库，这些可执行文件可根据需要加载到ROS系统中。

要创建不是从节点派生的组件，我们要遵循以下准则：
构造函数带const rclcpp::NodeOptions&参数；
实现get_node_base_interface（）方法，该方法应返回NodeBaseInterface:：SharedPtr。我们可以使用在构造函数中创建的节点的get_node_base_interface（）方法来提供此接口。

可以参考这个不是从节点派生的组件示例，该组件侦听ROS主题：node_like_listener_component。

内容有点多，慢慢消化。

本篇完。