ROS2 源码详细分析

2026-04-02 约 9555 字预计阅读 20 分钟

ROS2 源码详细分析（基于Humble LTS 稳定版）

本文基于ROS2 Humble LTS官方源码，从分层架构、核心模块源码实现、全链路通信流程三个维度，对ROS2核心源码进行深度拆解，同时补充关键设计思想与源码阅读路径。

一、ROS2 源码整体设计与分层架构

ROS2彻底重构了ROS1的中心化架构，采用严格的分层解耦设计，将通信、核心逻辑、语言封装完全隔离，源码不再是单体仓库，而是拆分为数百个独立Git仓库，通过vcs工具聚合管理。

1.1 核心分层架构（从下到上）

ROS2的核心栈采用五层架构，每一层仅依赖下一层的标准化接口，实现了中间件无关、语言无关的设计目标：

层级	核心仓库	核心职责	语言
底层中间件层	Fast DDS/Cyclone DDS/RTI Connext	实现DDS标准，提供去中心化发现、发布-订阅、请求-响应、序列化能力	C++
RMW中间件抽象层	rmw、rmw_fastrtps_cpp、rmw_cyclonedds_cpp	定义ROS2通信标准C接口，屏蔽不同DDS实现差异，实现中间件可插拔	C/C++
RCL核心公共层	rcl、rcutils、rosidl	实现ROS2核心概念（节点、话题、服务、参数、时钟）的通用逻辑，语言无关，为上层客户端库提供统一C接口	C
客户端库层	rclcpp(C++)、rclpy(Python)、rclc(嵌入式C)	提供面向用户的语言原生API，封装RCL层的C接口，实现执行器、回调调度、进程内通信等高级特性	对应语言
应用层	用户节点、功能包	实现机器人业务逻辑，仅依赖客户端库API	对应语言

1.2 核心源码仓库索引

ROS2的核心功能集中在以下关键仓库，也是源码阅读的核心目标：

仓库名	核心定位	源码阅读优先级
rcl	ROS2核心C库，所有核心概念的通用实现	最高
rclcpp	C++客户端库，用户最常用的API实现	最高
rmw	中间件抽象接口定义	高
rmw_fastrtps	默认DDS(Fast DDS)的适配实现	高
rosidl	接口定义与代码生成系统，消息/服务/动作的类型支持	高
rcutils	通用工具库（内存、字符串、日志、错误处理）	中
rclpy	Python客户端库实现	中

二、基础工具层源码分析

2.1 rcutils：底层工具库

rcutils是ROS2的底层工具库，纯C实现，无任何外部依赖，为上层所有模块提供跨平台的基础能力，核心模块包括：

内存管理：allocator.h 定义了统一的内存分配器接口，支持自定义分配器，所有ROS2核心结构的内存分配均通过此接口，避免内存泄漏
字符串处理：string_array.h、string_utils.h 提供跨平台的字符串操作，解决C语言原生字符串的安全问题
日志系统：logging.h 实现了分级日志、输出重定向、日志过滤，是RCLCPP_INFO等宏的底层实现
错误处理：error_handling.h 提供线程安全的错误码与错误信息存储机制
时间与同步：time.h、shared_mutex.h 提供跨平台的时间操作与线程同步原语

2.2 rosidl：接口定义与类型系统

rosidl是ROS2的接口定义与代码生成系统，负责将.msg/.srv/.action接口文件，转换为各语言的类型结构体、序列化/反序列化函数、类型支持句柄，是ROS2类型安全的核心。

2.2.1 完整代码生成流水线

接口解析：rosidl_parser 解析用户定义的.msg/.srv/.action文件，验证类型合法性，生成抽象语法树(AST)
IDL转换：rosidl_adapter 将ROS接口定义转换为标准DDS IDL文件，适配底层DDS的类型系统
语言代码生成：
- rosidl_generator_c：生成C语言的消息结构体、类型定义
- rosidl_generator_cpp：生成C++的消息类、模板特化代码
- rosidl_generator_py：生成Python的消息类与C扩展绑定
类型支持生成：rosidl_typesupport 为每个消息生成类型支持句柄，包含序列化/反序列化函数指针、类型哈希、名称等元信息，是RMW层识别消息类型的核心
DDS厂商适配：rosidl_typesupport_fastrtps_cpp 等厂商专属包，生成适配对应DDS实现的类型支持代码，完成ROS消息到DDS主题的映射

2.2.2 核心设计：类型擦除与运行时类型识别

ROS2通过rosidl_message_type_support_t结构体实现了类型擦除，上层RCL/RMW层无需感知具体消息类型，仅通过类型支持句柄即可完成序列化、发布、订阅等操作：

        
        
        
    
// 核心类型支持结构体（简化版）
typedef struct rosidl_message_type_support_t {
  const char * typesupport_identifier; // 类型支持标识（如"rosidl_typesupport_fastrtps_cpp"）
  const void * data; // 指向具体类型的元数据、序列化函数表
  const void * (*get_const_message_type_support_handle)(); // 获取类型句柄的函数指针
} rosidl_message_type_support_t;

三、RMW中间件抽象层源码分析

RMW（ROS Middleware Interface）是ROS2实现中间件可插拔的核心，纯C接口定义，完全屏蔽了底层DDS的实现细节，所有上层代码仅依赖RMW接口，不直接调用任何DDS厂商API。

3.1 核心接口设计

RMW接口遵循最小公共特性原则，仅定义所有中间件都能支持的通用能力，核心接口分为六大类：

全局生命周期：rmw_init()、rmw_shutdown()，初始化/销毁DDS域参与者（DomainParticipant）
节点管理：rmw_create_node()、rmw_destroy_node()，创建/销毁DDS级别的节点实体
发布-订阅：
- 发布者：rmw_create_publisher()、rmw_publish()、rmw_destroy_publisher()
- 订阅者：rmw_create_subscription()、rmw_take()、rmw_destroy_subscription()
服务-客户端：
- 服务端：rmw_create_service()、rmw_send_response()
- 客户端：rmw_create_client()、rmw_send_request()、rmw_take_response()
等待与事件机制：rmw_create_wait_set()、rmw_wait()，是ROS2回调驱动的核心，对应DDS的WaitSet机制
发现与图事件：rmw_get_topic_names_and_types()、rmw_create_guard_condition()，提供节点/话题发现、图变化通知能力

3.2 运行时中间件选择机制

ROS2在运行时动态加载对应的RMW实现，无需重新编译用户代码，核心实现逻辑：

编译期：上层代码仅链接rmw接口库，不链接任何具体DDS实现
运行期：
- 启动时通过环境变量RMW_IMPLEMENTATION读取用户指定的RMW实现（如rmw_fastrtps_cpp）
- 通过动态链接库加载机制（dlopen）加载对应RMW实现的共享库
- 解析库中的符号，将RMW接口的函数指针指向具体实现
厂商适配：每个DDS厂商只需实现RMW定义的所有C接口，即可无缝接入ROS2生态，无需修改上层任何代码

3.3 典型实现：rmw_fastrtps源码解析

rmw_fastrtps_cpp是ROS2默认的RMW实现，基于eProsima Fast DDS开发，核心分为三个模块：

rmw_fastrtps_shared_cpp：两个实现版本共享的通用逻辑，如类型支持转换、QoS映射、节点管理
rmw_fastrtps_cpp：静态类型支持版本，编译期生成消息到DDS类型的映射，性能最优，默认使用
rmw_fastrtps_dynamic_cpp：动态类型支持版本，运行时通过类型内省完成序列化，支持动态消息类型

核心实现要点：

QoS映射：将ROS2的rmw_qos_profile_t转换为Fast DDS的QoS策略，处理兼容性降级（如DDS不支持的QoS自动适配）
类型支持适配：将rosidl生成的类型支持句柄，转换为Fast DDS的TopicDataType，实现ROS消息与DDS数据的序列化/反序列化
发布者实现：rmw_create_publisher()内部创建Fast DDS的Publisher和DataWriter，绑定对应Topic与QoS；rmw_publish()直接调用DataWriter::write()完成数据发送
订阅者实现：rmw_create_subscription()内部创建Fast DDS的Subscriber和DataReader，注册数据监听器；rmw_take()从DataReader的历史缓存中取出数据
等待集实现：rmw_wait()封装Fast DDS的WaitSet::wait()，监听所有DataReader、定时器、条件变量的事件，唤醒上层执行器

四、RCL核心层源码分析

RCL（ROS Client Library）是ROS2的核心灵魂，纯C实现，基于RMW接口封装了ROS2所有核心概念的通用逻辑，为所有上层客户端库提供统一、无差别的基础能力，避免了不同语言客户端库的重复开发。

4.1 全局初始化：rcl_init()

rcl_init()是ROS2程序的入口，对应上层rclcpp::init()/rclpy.init()，完成整个ROS2实例的全局初始化，核心源码流程如下：

        
        
        
    
// 源码位置：rcl/src/rcl/init.c
rcl_ret_t rcl_init(
  int argc,
  char const * const * argv,
  const rcl_init_options_t * options,
  rcl_context_t * context)
{
  // 1. 参数合法性校验
  RCUTILS_CHECK_ARGUMENT_FOR_NULL(options, RCL_RET_INVALID_ARGUMENT);
  RCUTILS_CHECK_ARGUMENT_FOR_NULL(context, RCL_RET_INVALID_ARGUMENT);

  // 2. 初始化全局上下文context（ROS2实例的全局状态容器）
  context->impl = (rcl_context_impl_t *)rmw_allocate(sizeof(rcl_context_impl_t));
  memset(context->impl, 0, sizeof(rcl_context_impl_t));

  // 3. 解析命令行参数（--ros-args、--remap、--param、--log-level等）
  rcl_ret_t ret = rcl_parse_arguments(argc, argv, &context->impl->allocator, &context->global_arguments);

  // 4. 初始化日志系统，配置日志级别、输出处理器
  ret = rcl_logging_configure_with_output_handler(
    &context->global_arguments,
    &context->impl->allocator,
    rcl_logging_default_output_handler);

  // 5. 调用RMW层初始化，创建DDS DomainParticipant（通信根对象）
  rmw_init_options_t * init_options = rcl_init_options_get_rmw_init_options(options);
  ret = rmw_init(init_options, &context->impl->rmw_context);

  // 6. 标记上下文为有效，初始化完成
  context->instance_id = rcl_next_instance_id++;
  context->impl->is_shutdown = false;
  return RCL_RET_OK;
}

核心要点：rcl_context_t是ROS2实例的全局状态根，每个rcl_init()对应一个context，对应底层一个DDS域参与者，实现了多ROS2实例的隔离。

4.2 节点创建：rcl_node_init()

节点是ROS2的基本执行单元，rcl_node_init()完成节点的底层创建，对应上层rclcpp::Node的构造，核心源码流程：

        
        
        
    
// 源码位置：rcl/src/rcl/node.c
rcl_ret_t rcl_node_init(
  rcl_node_t * node,
  const char * name,
  const char * namespace_,
  rcl_context_t * context,
  const rcl_node_options_t * options)
{
  // 1. 节点名与命名空间合法性校验
  ret = rcl_validate_node_name(name, &validation_result, &invalid_index);
  if (RCL_RET_OK != ret) return ret;

  // 2. 构造完全限定节点名（namespace + "/" + name）
  node->impl->fq_name = rcutils_join_path(namespace_, name, &context->impl->allocator);

  // 3. 调用RMW层创建节点，对应DDS的子实体容器
  node->impl->rmw_node_handle = rmw_create_node(
    &context->impl->rmw_context, name, namespace_);

  // 4. 创建图变化守护条件，用于话题/节点变化时唤醒等待线程
  node->impl->graph_guard_condition = rmw_create_guard_condition(&context->impl->rmw_context);

  // 5. 初始化节点参数系统，解析命令行传入的参数覆盖
  if (options->use_global_arguments) {
    ret = rcl_arguments_get_param_overrides(
      &options->arguments, &node->impl->parameter_overrides);
  }

  // 6. 初始化节点名称重映射、日志器等附属组件
  return RCL_RET_OK;
}

4.3 发布者核心实现

发布者的核心逻辑集中在rcl_publisher_init()和rcl_publish()，是话题发布的底层核心：

发布者初始化：

        
        
        
    
// 源码位置：rcl/src/rcl/publisher.c
rcl_ret_t rcl_publisher_init(
  rcl_publisher_t * publisher,
  const rcl_node_t * node,
  const rosidl_message_type_support_t * type_support,
  const char * topic_name,
  const rcl_publisher_options_t * options)
{
  // 1. 话题名重映射与规范化（处理相对/绝对/私有命名空间）
  char * remapped_topic_name = NULL;
  ret = rcl_remap_topic_name(
    &node->impl->options.arguments,
    &node->context->global_arguments,
    topic_name,
    rcl_node_get_name(node),
    rcl_node_get_namespace(node),
    &allocator,
    &remapped_topic_name);

  // 2. 调用RMW层创建发布者，底层创建DDS DataWriter
  publisher->impl->rmw_handle = rmw_create_publisher(
    rcl_node_get_rmw_handle(node),
    type_support,
    remapped_topic_name,
    &options->qos,
    &options->rmw_publisher_options);

  // 3. 保存发布者元信息（话题名、类型支持、节点上下文）
  publisher->impl->topic_name = remapped_topic_name;
  publisher->impl->type_support = type_support;
  publisher->impl->context = node->context;
  return RCL_RET_OK;
}

消息发布：

        
        
        
    
rcl_ret_t rcl_publish(
  const rcl_publisher_t * publisher,
  const void * ros_message,
  rmw_publisher_allocation_t * allocation)
{
  // 直接透传给RMW层，底层完成序列化、DDS发送
  return rmw_publish(publisher->impl->rmw_handle, ros_message, allocation);
}

4.4 订阅者核心实现

订阅者的核心逻辑集中在rcl_subscription_init()和rcl_take()，是话题接收的底层核心：

订阅者初始化：与发布者逻辑对称，调用rmw_create_subscription()创建DDS DataReader，绑定话题、类型支持、QoS
消息接收：

        
        
        
    
// 源码位置：rcl/src/rcl/subscription.c
rcl_ret_t rcl_take(
  const rcl_subscription_t * subscription,
  void * ros_message,
  rmw_message_info_t * message_info,
  bool * taken)
{
  // 调用RMW层，从DDS DataReader的历史缓存中取出数据
  // 反序列化到ros_message结构体中，taken标记是否成功取到数据
  return rmw_take(subscription->impl->rmw_handle, ros_message, message_info, taken);
}

4.5 核心心脏：rcl_wait() 等待集机制

rcl_wait()是ROS2回调驱动模型的核心，对应Linux的select/epoll，负责监听所有待等待的实体（订阅者、定时器、服务、客户端、守护条件），阻塞直到有事件就绪或超时，是执行器调度回调的基础。

        
        
        
    
// 源码位置：rcl/src/rcl/wait.c
rcl_ret_t rcl_wait(rcl_wait_set_t * wait_set, int64_t timeout)
{
  // wait_set是事件容器，包含：订阅者、定时器、服务、客户端、守护条件、事件

  // 1. 校验等待集合法性，清空上次的就绪标记
  ret = rcl_wait_set_clear(wait_set);

  // 2. 调用RMW层的rmw_wait()，底层调用DDS WaitSet::wait()
  // 阻塞直到有事件就绪、超时或被中断
  ret = rmw_wait(
    wait_set->impl->rmw_subscriptions,
    wait_set->impl->rmw_guard_conditions,
    wait_set->impl->rmw_services,
    wait_set->impl->rmw_clients,
    wait_set->impl->rmw_events,
    wait_set->impl->rmw_wait_set,
    &timeout_time);

  // 3. 检查定时器是否到期，标记就绪状态
  for (size_t i = 0; i < wait_set->size_of_timers; ++i) {
    if (wait_set->timers[i] && rcl_timer_is_ready(wait_set->timers[i], &is_ready)) {
      // 定时器就绪，保留在等待集中
    } else {
      wait_set->timers[i] = NULL; // 未就绪，清空
    }
  }

  // 4. 其他实体的就绪状态校验（服务、客户端等）
  // 就绪的实体保留在等待集中，未就绪的置为NULL
  return RCL_RET_OK;
}

核心要点：rcl_wait()返回后，上层执行器只需遍历等待集中非NULL的实体，即可获取所有就绪的事件，执行对应的回调函数。

五、rclcpp C++客户端库源码分析

rclcpp是ROS2最核心的客户端库，提供了面向C++的原生API，是用户开发ROS2节点最常用的库，基于RCL层的C接口封装，实现了执行器、回调调度、进程内通信、RAII资源管理等高级特性。

5.1 Node类设计：接口分离模式

rclcpp的Node类没有采用庞大的单体类设计，而是使用接口分离模式（ISP），将节点的不同能力拆分为多个独立的接口类，每个接口负责单一功能，通过组合的方式集成到Node类中，极大提升了可扩展性和可维护性。

        
        
        
    
// 源码位置：rclcpp/src/rclcpp/node.cpp
Node::Node(
  const std::string & node_name,
  const std::string & namespace_,
  const NodeOptions & options)
: // 初始化各个功能接口
  node_base_(new rclcpp::node_interfaces::NodeBase(
    node_name, namespace_, options.context(),
    *(options.get_rcl_node_options()),
    options.use_intra_process_comms())),
  node_graph_(new rclcpp::node_interfaces::NodeGraph(node_base_.get())),
  node_logging_(new rclcpp::node_interfaces::NodeLogging(node_base_.get())),
  node_timers_(new rclcpp::node_interfaces::NodeTimers(node_base_.get())),
  node_topics_(new rclcpp::node_interfaces::NodeTopics(node_base_.get(), node_timers_.get())),
  node_services_(new rclcpp::node_interfaces::NodeServices(node_base_.get())),
  node_parameters_(new rclcpp::node_interfaces::NodeParameters(
    node_base_.get(), node_logging_.get(),
    node_topics_.get(), node_services_.get(),
    options.parameter_overrides())),
  // ... 其他接口初始化
{
  // 节点初始化完成后的附属逻辑
}

核心接口职责：

接口类	核心职责
NodeBase	管理底层rcl_node_t生命周期，提供上下文、进程内通信开关
NodeGraph	提供ROS图查询能力（获取话题列表、节点列表、服务列表）
NodeTopics	管理发布者、订阅者的创建与销毁
NodeServices	管理服务、客户端的创建与销毁
NodeTimers	管理定时器的创建与销毁
NodeParameters	实现参数服务，提供参数声明、获取、设置能力
NodeClock	管理时钟，提供ROS时间、系统时间、稳态时间支持

5.2 核心灵魂：Executor执行器模型

Executor（执行器）是rclcpp的核心调度引擎，负责监听事件、调度回调函数的执行，是ROS2节点能够响应消息、定时器、服务请求的核心，彻底解决了ROS1中回调调度混乱、线程安全无法保证的问题。

5.2.1 执行器核心工作流程

执行器的核心逻辑在spin()主循环中，以最常用的SingleThreadedExecutor为例：

        
        
        
    
// 源码位置：rclcpp/src/rclcpp/executors/single_threaded_executor.cpp
void SingleThreadedExecutor::spin()
{
  // 防止重入
  if (spinning.exchange(true)) {
    throw std::runtime_error("spin() called while already spinning");
  }
  RCLCPP_SCOPE_EXIT(this->spinning.store(false); );

  // 主循环，直到节点关闭或spin停止
  while (rclcpp::ok(this->context_) && spinning.load()) {
    AnyExecutable any_executable;
    // 1. 获取下一个可执行的回调任务，阻塞直到有就绪任务
    if (get_next_executable(any_executable, std::chrono::nanoseconds(-1))) {
      // 2. 执行回调任务
      execute_any_executable(any_executable);
    }
  }
}

5.2.2 核心步骤拆解

get_next_executable()：获取就绪任务
- 优先从就绪队列中取已就绪的任务，无就绪任务则调用wait_for_work()
- wait_for_work()内部收集所有需要监听的实体（订阅者、定时器、服务等），加入rcl_wait_set_t
- 调用rcl_wait()阻塞等待，直到有事件就绪
- 遍历就绪的实体，生成对应的AnyExecutable可执行对象，加入就绪队列
execute_any_executable()：执行回调 根据可执行对象的类型，分发到对应的执行函数：
- 定时器回调：execute_timer()
- 话题订阅回调：execute_subscription()
- 服务请求回调：execute_service()
- 服务响应回调：execute_client()
- 自定义可等待对象：waitable->execute()
订阅者回调执行细节：

        
        
        
    
// 源码位置：rclcpp/src/rclcpp/executor.cpp
void Executor::execute_subscription(rclcpp::SubscriptionBase::SharedPtr subscription)
{
  // 1. 调用rcl_take()从底层取出消息
  void * message = subscription->create_message();
  rmw_message_info_t message_info;
  auto ret = rcl_take(
    subscription->get_subscription_handle().get(),
    message, &message_info, nullptr);

  if (RCL_RET_OK == ret) {
    // 2. 调用订阅者的消息处理函数，最终执行用户传入的回调
    subscription->handle_message(message, message_info);
  }

  // 3. 释放消息内存
  subscription->return_message(message);
}

5.2.3 多线程执行器与回调组

ROS2提供了MultiThreadedExecutor多线程执行器，配合CallbackGroup回调组实现精细化的并发控制，核心设计：

回调组类型：
- MutuallyExclusive：互斥组，同一时刻只有一个回调能执行，保证线程安全，默认类型
- Reentrant：可重入组，允许多个回调并发执行，适用于无状态、线程安全的回调
并发控制逻辑：
- 多线程执行器会启动多个线程，每个线程都执行spin()主循环
- 互斥组的回调，只会被一个线程拾取执行，保证串行化
- 可重入组的回调，可被多个线程同时拾取，并发执行
使用方式：用户可创建多个回调组，将不同的订阅者/定时器绑定到不同的组，实现回调的隔离与并发控制

5.3 进程内通信（Intra-Process）零拷贝实现

ROS2提供了同进程内发布-订阅的零拷贝通信机制，避免了DDS的序列化、网络传输开销，极大提升了同进程内节点的通信性能。

核心实现原理

启用方式：创建节点时通过NodeOptions().use_intra_process_comms(true)开启
核心组件：IntraProcessManager进程内管理器，每个context对应一个实例，管理同进程内所有发布者、订阅者的映射
发布流程：
- 发布者调用publish()时，先检查是否有同进程的订阅者
- 无同进程订阅者：走正常DDS发布流程
- 有同进程订阅者：
  - 若使用publish(std::move(msg))移动语义：直接将消息的所有权转移到环形缓冲区，零拷贝
  - 若使用publish(msg)拷贝语义：拷贝消息到环形缓冲区
  - 直接唤醒订阅者的回调，将消息指针传递给回调函数，无需序列化/反序列化
内存管理：使用带引用计数的环形缓冲区存储消息，当所有订阅者都处理完消息后，自动释放内存，避免内存泄漏

六、核心通信机制全链路源码分析

6.1 话题Topic全链路流程

以C++节点的publish()发布消息，到订阅者回调函数执行为例，完整链路如下：

用户层：用户调用publisher->publish(msg)，传入消息对象
rclcpp层：
- 检查是否启用进程内通信，若有同进程订阅者，直接走进程内零拷贝路径，唤醒订阅者回调
- 若无进程内订阅者，调用rcl_publish()进入RCL层
RCL层：参数校验后，直接调用rmw_publish()进入RMW层
RMW层：
- 通过类型支持句柄，调用序列化函数，将ROS消息序列化为CDR格式
- 调用Fast DDS的DataWriter::write()，将序列化后的数据写入DDS历史缓存
DDS层：
- 通过SPDP发现协议匹配订阅者，根据QoS策略选择传输方式（SHM共享内存/UDP/TCP）
- 将数据发送给匹配的订阅者DataReader
接收端DDS层：DataReader收到数据，存入历史缓存，触发监听器事件
接收端RMW层：标记DataReader为就绪状态，唤醒等待的rmw_wait()
接收端RCL层：rcl_wait()返回，标记订阅者为就绪状态
接收端rclcpp层：
- 执行器拾取就绪的订阅者，调用rcl_take()取出数据
- 反序列化数据为ROS消息对象
- 调用用户传入的订阅回调函数，将消息对象传入

6.2 服务Service底层实现

服务是同步的请求-响应通信模式，底层基于两个DDS话题实现：

底层结构：
- 请求话题：客户端→服务端，传输请求消息
- 响应话题：服务端→客户端，传输响应消息，附带请求的唯一ID，实现请求-响应的匹配
客户端实现：
- rclcpp::Client底层包含：DDS DataWriter（发请求）+ DDS DataReader（收响应）
- async_send_request()发送请求，生成唯一请求ID，返回future对象
- 执行器监听响应话题，收到响应后匹配请求ID，设置future的值，唤醒用户等待逻辑
服务端实现：
- rclcpp::Service底层包含：DDS DataReader（收请求）+ DDS DataWriter（发响应）
- 执行器监听请求话题，收到请求后调用用户的服务处理回调
- 回调执行完成后，通过DataWriter发送响应，附带原请求ID

6.3 动作Action底层实现

动作是ROS2为长时间运行任务设计的异步通信机制，底层基于4个DDS话题组合实现：

话题	方向	作用
目标话题	客户端→服务端	发送任务目标
取消话题	客户端→服务端	发送任务取消请求
反馈话题	服务端→客户端	实时上报任务执行进度
结果话题	服务端→客户端	任务完成后上报最终结果
状态话题	服务端→客户端	上报目标执行状态