ROS2系列教程：Action动作通信（带反馈长任务）

发布时间：2026-09-05 15:48:29

🕒 阅读时间：23 分钟📝 字数：4256👀 阅读量：Loading...

本文是 ROS2 系列教程的第 10 篇

本文是 ROS2 系列教程的第 10 篇：Action 动作通信——带反馈的长任务。话题是单向数据流，服务是一问一答，而机器人世界里还有一类需求：“导航到目标点”“机械臂抓取物体”“执行建图”——它们耗时长、需要进度反馈、还可能要中途取消。这就是动作（Action）的用武之地。本篇文章讲透 Goal/Feedback/Result 三通道模型，用 Python 与 C++ 实现动作服务端与客户端，掌握 ros2 action 命令，并完成三种通信方式的选型总结。

一、动作通信模型

1.1 为什么需要 Action

用一个例子理解：让机器人“导航到厨房”。

话题方案：发一个目标点话题，然后就不知道了——没有完成确认，没有进度。
服务方案：调一个服务“导航到(厨房)”，服务端算完才返回——调用期间完全阻塞，无法取消，也没有中间反馈。
动作方案：客户端发目标 → 服务端持续回报“已走 30%、还有 5 米”→ 完成时返回最终结果 → 随时可取消。完美契合。

动作是为”长任务 + 进度反馈 + 可取消“设计的通信原语，是导航（Nav2）、机械臂（MoveIt2）等核心系统的标准接口。

1.2 三通道模型

一个动作由三个通道组成（对应三个话题 + 一个服务）：

1
客户端                                  服务端
2
  │  1. 发送目标 Goal ──────────────────▶  接受/拒绝目标
3
  │  2. ◀────────────── 持续反馈 Feedback  报告进度
4
  │  3. ◀────────────────── 最终结果 Result  任务完成
5
  │  4. 发送取消请求 Cancel ────────────▶  终止任务

通道	方向	内容	类比
Goal	客户端→服务端	任务目标（如目标坐标）	下达任务
Feedback	服务端→客户端	进度信息（持续发送）	汇报进度
Result	服务端→客户端	最终结果（一次）	交付成果
Cancel	客户端→服务端	取消请求	中止任务

实现上：Goal 用服务传输（保证送达），Feedback/Result 用话题传输，Cancel 用服务——但用户不需要关心底层，API 已封装。

1.3 动作接口定义（.action 文件）

动作接口用 .action 文件定义，三部分用 --- 分隔：

1
# action/CountUntil.action —— 计数到目标值
2
int32 target_number          # 目标（Goal）：要数到几
3
---
4
int32 current_number         # 结果（Result）：最终数到几
5
---
6
int32 current_number         # 反馈（Feedback）：当前数到几

定义在接口包里（如 my_interfaces），构建后生成对应语言的类型。

二、Python 动作服务端

2.1 简单计数器动作服务端

用 ROS2 自带的 example_interfaces/action/Fibonacci（斐波那契数列）演示：

1
# py_pkg/py_action_server.py —— Python 动作服务端
2
import rclpy
3
import time
4
from rclpy.node import Node
5
from rclpy.action import ActionServer
6
from example_interfaces.action import Fibonacci
7

8
class FibonacciServer(Node):
9
    def __init__(self):
10
        super().__init__('fibonacci_server')
11
        # 创建动作服务端：动作类型 + 动作名 + 三个回调
12
        self.action_server = ActionServer(
13
            self,
14
            Fibonacci,
15
            'fibonacci',
16
            self.execute_callback)   # 执行回调（核心）
17
        self.get_logger().info('动作服务端就绪: /fibonacci')
18

19
    def execute_callback(self, goal_handle):
20
        # 1. 接受目标
21
        self.get_logger().info(f'收到目标: {goal_handle.request.order}')
22
        feedback_msg = Fibonacci.Feedback()
23

24
        # 2. 计算斐波那契数列，持续发反馈
25
        sequence = [0, 1]
26
        for i in range(1, goal_handle.request.order):
27
            sequence.append(sequence[i] + sequence[i-1])
28
            feedback_msg.sequence = sequence
29
            goal_handle.publish_feedback(feedback_msg)   # 发反馈
30
            time.sleep(0.5)                              # 模拟耗时
31

32
        # 3. 完成：返回结果
33
        goal_handle.succeed()
34
        result = Fibonacci.Result()
35
        result.sequence = sequence
36
        return result
37

38
def main():
39
    rclpy.init()
40
    node = FibonacciServer()
41
    rclpy.spin(node)
42
    node.destroy_node()
43
    rclpy.shutdown()
44

45
if __name__ == '__main__':
46
    main()

服务端三个关键回调：

execute_callback：收到目标后执行（可同步写耗时逻辑，执行器会调度）。
publish_feedback：随时发布进度。
succeed()/abort()：标记任务成功/失败，然后返回 Result。

2.2 支持取消的动作服务端

1
# py_pkg/cancellable_server.py —— 可取消的动作服务端
2
import rclpy, time
3
from rclpy.node import Node
4
from rclpy.action import ActionServer, CancelResponse, GoalResponse
5
from example_interfaces.action import Fibonacci
6

7
class CancellableServer(Node):
8
    def __init__(self):
9
        super().__init__('cancellable_server')
10
        self.action_server = ActionServer(
11
            self, Fibonacci, 'fibonacci',
12
            execute_callback=self.execute_callback,
13
            goal_callback=self.goal_callback,        # 目标接受回调
14
            cancel_callback=self.cancel_callback,    # 取消回调
15
        )
16

17
    def goal_callback(self, goal_request):
18
        # 可在此校验目标：拒绝非法目标
19
        self.get_logger().info(f'收到目标 order={goal_request.order}')
20
        if goal_request.order <= 0:
21
            self.get_logger().warn('拒绝非法目标（order<=0）')
22
            return GoalResponse.REJECT
23
        return GoalResponse.ACCEPT
24

25
    def cancel_callback(self, goal_handle):
26
        self.get_logger().info('收到取消请求，同意取消')
27
        return CancelResponse.ACCEPT
28

29
    def execute_callback(self, goal_handle):
30
        feedback_msg = Fibonacci.Feedback()
31
        sequence = [0, 1]
32
        for i in range(1, goal_handle.request.order):
33
            # 检查是否被取消
34
            if goal_handle.is_cancel_requested:
35
                goal_handle.canceled()              # 标记取消
36
                self.get_logger().info('任务已取消')
37
                return Fibonacci.Result()           # 返回空结果
38
            sequence.append(sequence[i] + sequence[i-1])
39
            feedback_msg.sequence = sequence
40
            goal_handle.publish_feedback(feedback_msg)
41
            time.sleep(0.5)
42
        goal_handle.succeed()
43
        result = Fibonacci.Result()
44
        result.sequence = sequence
45
        return result
46

47
def main():
48
    rclpy.init()
49
    node = CancellableServer()
50
    rclpy.spin(node)
51
    node.destroy_node()
52
    rclpy.shutdown()
53

54
if __name__ == '__main__':
55
    main()

取消处理三步：

cancel_callback 决定是否同意取消（返回 CancelResponse.ACCEPT）。
执行循环里用 goal_handle.is_cancel_requested 检查是否被请求取消。
同意后调 goal_handle.canceled() 标记状态并返回。

三、Python 动作客户端

3.1 基础客户端

1
# py_pkg/py_action_client.py —— Python 动作客户端
2
import rclpy
3
from rclpy.node import Node
4
from rclpy.action import ActionClient
5
from example_interfaces.action import Fibonacci
6

7
class FibonacciClient(Node):
8
    def __init__(self):
9
        super().__init__('fibonacci_client')
10
        # 创建动作客户端
11
        self.action_client = ActionClient(self, Fibonacci, 'fibonacci')
12

13
    def send_goal(self, order):
14
        # 1. 等待服务端
15
        self.action_client.wait_for_server()
16
        # 2. 构造目标
17
        goal_msg = Fibonacci.Goal()
18
        goal_msg.order = order
19
        self.get_logger().info(f'发送目标: order={order}')
20
        # 3. 发送目标（异步），注册反馈回调
21
        self.send_goal_future = self.action_client.send_goal_async(
22
            goal_msg, feedback_callback=self.feedback_callback)
23
        # 4. 目标被接受后，再请求结果
24
        self.send_goal_future.add_done_callback(self.goal_response_callback)
25

26
    def feedback_callback(self, feedback_msg):
27
        # 进度反馈（服务端 publish_feedback 时触发）
28
        fb = feedback_msg.feedback
29
        self.get_logger().info(f'进度: {list(fb.sequence)}')
30

31
    def goal_response_callback(self, future):
32
        goal_handle = future.result()
33
        if not goal_handle.accepted:
34
            self.get_logger().error('目标被拒绝')
35
            return
36
        self.get_logger().info('目标已接受，等待结果...')
37
        # 5. 请求结果（异步）
38
        self.get_result_future = goal_handle.get_result_async()
39
        self.get_result_future.add_done_callback(self.result_callback)
40

41
    def result_callback(self, future):
42
        result = future.result().result
43
        self.get_logger().info(f'最终结果: {list(result.sequence)}')
44
        # 关闭节点
45
        rclpy.shutdown()
46

47
def main():
48
    rclpy.init()
49
    node = FibonacciClient()
50
    node.send_goal(10)      # 数到 10
51
    rclpy.spin(node)
52
    node.destroy_node()
53
    rclpy.shutdown()
54

55
if __name__ == '__main__':
56
    main()

客户端四步流程：

send_goal_async(目标, feedback_callback) 发送目标。
目标响应回调里检查 accepted（被接受/拒绝）。
接受后 get_result_async() 请求最终结果。
result_callback 拿到最终结果。

3.2 可取消客户端

1
# py_pkg/cancellable_client.py —— 可取消客户端
2
import rclpy
3
from rclpy.node import Node
4
from rclpy.action import ActionClient
5
from example_interfaces.action import Fibonacci
6
import threading, time
7

8
class CancellableClient(Node):
9
    def __init__(self):
10
        super().__init__('cancellable_client')
11
        self.action_client = ActionClient(self, Fibonacci, 'fibonacci')
12
        self.goal_handle = None
13

14
    def send_goal(self, order):
15
        self.action_client.wait_for_server()
16
        goal_msg = Fibonacci.Goal()
17
        goal_msg.order = order
18
        future = self.action_client.send_goal_async(
19
            goal_msg, feedback_callback=self.feedback_callback)
20
        future.add_done_callback(self.on_goal_response)
21

22
    def feedback_callback(self, feedback_msg):
23
        self.get_logger().info(f'进度: {list(feedback_msg.feedback.sequence)}')
24

25
    def on_goal_response(self, future):
26
        self.goal_handle = future.result()
27
        if not self.goal_handle.accepted:
28
            self.get_logger().error('目标被拒绝')
29
            return
30
        self.get_logger().info('目标已接受，2 秒后取消...')
31
        # 2 秒后发起取消
32
        timer = threading.Timer(2.0, self.cancel_goal)
33
        timer.start()
34

35
    def cancel_goal(self):
36
        self.get_logger().info('发送取消请求...')
37
        cancel_future = self.goal_handle.cancel_goal_async()
38
        cancel_future.add_done_callback(self.on_cancel_done)
39

40
    def on_cancel_done(self, future):
41
        cancel_response = future.result()
42
        if len(cancel_response.goals_canceling) > 0:
43
            self.get_logger().info('取消成功')
44
        else:
45
            self.get_logger().warn('取消未生效')
46

47
def main():
48
    rclpy.init()
49
    node = CancellableClient()
50
    node.send_goal(10)
51
    rclpy.spin(node)
52
    node.destroy_node()
53
    rclpy.shutdown()
54

55
if __name__ == '__main__':
56
    main()

四、C++ 动作服务端与客户端

4.1 C++ 动作服务端

1
#include "rclcpp/rclcpp.hpp"
2
#include "rclcpp_action/rclcpp_action.hpp"
3
#include "example_interfaces/action/fibonacci.hpp"
4
#include <chrono>
5
#include <memory>
6

7
using Fibonacci = example_interfaces::action::Fibonacci;
8
using GoalHandleFibonacci = rclcpp_action::ServerGoalHandle<Fibonacci>;
9

10
class FibonacciServer : public rclcpp::Node
11
{
12
public:
13
  FibonacciServer() : Node("fibonacci_server_cpp")
14
  {
15
    action_server_ = rclcpp_action::create_server<Fibonacci>(
16
      this, "fibonacci",
17
      std::bind(&FibonacciServer::handle_goal, this, std::placeholders::_1, std::placeholders::_2),
18
      std::bind(&FibonacciServer::handle_cancel, this, std::placeholders::_1),
19
      std::bind(&FibonacciServer::handle_accepted, this, std::placeholders::_1));
20
    RCLCPP_INFO(this->get_logger(), "动作服务端就绪");
21
  }
22

23
private:
24
  // 目标回调：校验并决定接受/拒绝
25
  rclcpp_action::GoalResponse handle_goal(
26
    const rclcpp_action::GoalUUID& uuid,
27
    std::shared_ptr<const Fibonacci::Goal> goal)
28
  {
29
    RCLCPP_INFO(this->get_logger(), "收到目标 order=%d", goal->order);
30
    if (goal->order <= 0) return rclcpp_action::GoalResponse::REJECT;
31
    return rclcpp_action::GoalResponse::ACCEPT;
32
  }
33

34
  // 取消回调
35
  rclcpp_action::CancelResponse handle_cancel(
36
    const std::shared_ptr<GoalHandleFibonacci> goal_handle)
37
  {
38
    RCLCPP_INFO(this->get_logger(), "收到取消请求");
39
    return rclcpp_action::CancelResponse::ACCEPT;
40
  }
41

42
  // 接受后：开线程执行（不能阻塞回调）
43
  void handle_accepted(const std::shared_ptr<GoalHandleFibonacci> goal_handle)
44
  {
45
    std::thread(std::bind(&FibonacciServer::execute, this, goal_handle)).detach();
46
  }
47

48
  // 执行逻辑
49
  void execute(const std::shared_ptr<GoalHandleFibonacci> goal_handle)
50
  {
51
    auto feedback = std::make_shared<Fibonacci::Feedback>();
52
    auto result = std::make_shared<Fibonacci::Result>();
53
    std::vector<int> seq{0, 1};
54
    for (int i = 1; i < goal_handle->get_goal()->order; i++) {
55
      seq.push_back(seq[i] + seq[i-1]);
56
      feedback->sequence = seq;
57
      goal_handle->publish_feedback(feedback);
58
      std::this_thread::sleep_for(std::chrono::milliseconds(500));
59
    }
60
    goal_handle->succeed();
61
    result->sequence = seq;
62
    goal_handle->publish_result(result);
63
  }
64

65
  rclcpp_action::Server<Fibonacci>::SharedPtr action_server_;
66
};
67

68
int main(int argc, char** argv)
69
{
70
  rclcpp::init(argc, argv);
71
  rclcpp::spin(std::make_shared<FibonacciServer>());
72
  rclcpp::shutdown();
73
  return 0;
74
}

C++ 关键差异：handle_accepted 里必须开新线程执行任务（不能阻塞执行器回调线程）；三个回调分别对应 Goal 接受、取消、执行。

4.2 C++ 动作客户端

1
#include "rclcpp/rclcpp.hpp"
2
#include "rclcpp_action/rclcpp_action.hpp"
3
#include "example_interfaces/action/fibonacci.hpp"
4

5
using Fibonacci = example_interfaces::action::Fibonacci;
6

7
class FibonacciClient : public rclcpp::Node
8
{
9
public:
10
  FibonacciClient() : Node("fibonacci_client_cpp")
11
  {
12
    client_ = rclcpp_action::create_client<Fibonacci>(this, "fibonacci");
13
  }
14

15
  void send_goal(int order)
16
  {
17
    // 1. 等服务端
18
    if (!client_->wait_for_action_server()) {
19
      RCLCPP_ERROR(this->get_logger(), "动作服务端不可用");
20
      return;
21
    }
22
    // 2. 构造目标
23
    auto goal = Fibonacci::Goal();
24
    goal.order = order;
25
    // 3. 发送目标（异步），注册反馈与响应回调
26
    auto send_goal_options = rclcpp_action::Client<Fibonacci>::SendGoalOptions();
27
    send_goal_options.goal_response_callback =
28
      std::bind(&FibonacciClient::goal_response_callback, this, std::placeholders::_1);
29
    send_goal_options.feedback_callback =
30
      std::bind(&FibonacciClient::feedback_callback, this,
31
                std::placeholders::_1, std::placeholders::_2);
32
    send_goal_options.result_callback =
33
      std::bind(&FibonacciClient::result_callback, this, std::placeholders::_1);
34
    client_->async_send_goal(goal, send_goal_options);
35
  }
36

37
private:
38
  void goal_response_callback(const GoalHandleFibonacci::SharedPtr& goal_handle)
39
  {
40
    if (!goal_handle) {
41
      RCLCPP_ERROR(this->get_logger(), "目标被拒绝");
42
    } else {
43
      RCLCPP_INFO(this->get_logger(), "目标已接受");
44
    }
45
  }
46

47
  void feedback_callback(GoalHandleFibonacci::SharedPtr,
48
                         const std::shared_ptr<const Fibonacci::Feedback> feedback)
49
  {
50
    RCLCPP_INFO(this->get_logger(), "进度: %zu 项", feedback->sequence.size());
51
  }
52

53
  void result_callback(const GoalHandleFibonacci::WrappedResult& result)
54
  {
55
    if (result.code == rclcpp_action::ResultCode::SUCCEEDED) {
56
      RCLCPP_INFO(this->get_logger(), "任务成功");
57
    }
58
  }
59

60
  rclcpp_action::Client<Fibonacci>::SharedPtr client_;
61
};
62

63
int main(int argc, char** argv)
64
{
65
  rclcpp::init(argc, argv);
66
  auto node = std::make_shared<FibonacciClient>();
67
  node->send_goal(10);
68
  rclcpp::spin(node);
69
  rclcpp::shutdown();
70
  return 0;
71
}

五、自定义动作接口实战

5.1 定义动作接口

在 my_interfaces 包加 action/NavigateTo.action：

1
float32 x              # 目标 x 坐标
2
float32 y              # 目标 y 坐标
3
---
4
bool     reached       # 是否到达
5
float32 final_distance # 最终距离
6
---
7
float32 distance_left  # 剩余距离
8
float32 speed          # 当前速度

修改 CMakeLists.txt：

1
set(action_files
2
  "action/NavigateTo.action"
3
)
4
rosidl_generate_interfaces(${PROJECT_NAME}
5
  ${msg_files}
6
  ${srv_files}
7
  ${action_files}       # 加入动作文件
8
  DEPENDENCIES builtin_interfaces
9
)

重建并验证：

1
colcon build --packages-select my_interfaces
2
source install/setup.bash
3
ros2 interface show my_interfaces/action/NavigateTo

5.2 导航动作服务端（模拟）

1
# py_pkg/nav_action_server.py —— 模拟导航动作
2
import rclpy, math, time
3
from rclpy.node import Node
4
from rclpy.action import ActionServer
5
from my_interfaces.action import NavigateTo
6

7
class NavServer(Node):
8
    def __init__(self):
9
        super().__init__('nav_server')
10
        self.action_server = ActionServer(
11
            self, NavigateTo, 'navigate_to', self.execute_callback)
12
        self.get_logger().info('导航动作服务端就绪')
13

14
    def execute_callback(self, goal_handle):
15
        goal = goal_handle.request
16
        self.get_logger().info(f'导航到 ({goal.x}, {goal.y})')
17
        feedback = NavigateTo.Feedback()
18
        # 模拟：机器人从 (0,0) 以 1m/s 直线运动
19
        total = math.sqrt(goal.x**2 + goal.y**2)
20
        distance_left = total
21
        while distance_left > 0.05:
22
            distance_left -= 0.2
23
            feedback.distance_left = max(distance_left, 0.0)
24
            feedback.speed = 1.0
25
            goal_handle.publish_feedback(feedback)
26
            time.sleep(0.2)
27
        goal_handle.succeed()
28
        result = NavigateTo.Result()
29
        result.reached = True
30
        result.final_distance = 0.0
31
        return result
32

33
def main():
34
    rclpy.init()
35
    node = NavServer()
36
    rclpy.spin(node)
37
    node.destroy_node()
38
    rclpy.shutdown()
39

40
if __name__ == '__main__':
41
    main()

5.3 命令行调用动作

1
# 查看动作列表
2
ros2 action list
3
ros2 action list -t
4

5
# 查看动作类型信息
6
ros2 action info /navigate_to
7

8
# 发送动作目标（命令行）
9
ros2 action send_goal /navigate_to my_interfaces/action/NavigateTo \
10
  "{x: 5.0, y: 3.0}"
11

12
# 带反馈显示
13
ros2 action send_goal /navigate_to my_interfaces/action/NavigateTo \
14
  "{x: 5.0, y: 3.0}" --feedback
15

16
# 显示动作接口
17
ros2 interface show my_interfaces/action/NavigateTo

注意：命令行 ros2 action send_goal 会阻塞等待结果；--feedback 显示实时反馈；Ctrl+C 可取消。

六、三种通信方式选型总结

维度	话题 Topic	服务 Service	动作 Action
通信模式	单向流	请求-应答	目标-反馈-结果
是否阻塞	否	客户端等待	客户端异步
进度反馈	无	无	有
取消支持	不适用	无	有
适用任务	持续数据	即时问答	长任务
典型场景	传感器、指令	查询、设置	导航、抓取、建图
接口定义	.msg	.srv	.action（3段）
底层实现	话题	服务	话题+服务组合

选型口诀：

1
持续流动 → 话题
2
一问一答 → 服务
3
长任务+进度+可取消 → 动作

动作的使用误区：

别用动作做毫秒级操作（开销大，杀鸡用牛刀）。
别在 execute_callback 里做无限循环（要有退出条件与取消检查）。
客户端别忘记注册 feedback_callback 和 result_callback。

七、总结

本篇文章完整覆盖了动作通信：理解了三通道模型与适用场景、动作接口定义（.action 三段式），用 Python 与 C++ 实现了动作服务端（含可取消版本）与客户端（含取消流程），实战了自定义导航动作，掌握了 ros2 action 命令行工具，并完成了话题/服务/动作三大通信方式的选型总结。

关键要点回顾：

动作 = Goal（目标）+ Feedback（反馈）+ Result（结果）+ Cancel（取消）。
.action 文件三段式定义接口，放在接口包的 action/ 目录。
服务端核心：execute_callback + publish_feedback + succeed()/canceled()。
取消三步：cancel_callback 同意 → is_cancel_requested 检查 → canceled() 标记。
客户端四步：send_goal_async → goal_response_callback → get_result_async → result_callback。
C++ 服务端要在 handle_accepted 里开线程执行任务，避免阻塞执行器。
长任务带反馈可取消用动作；持续数据用话题；即时问答用服务。

下一篇预告

下一篇进入 launch 文件与多节点启动：手动开几十个终端运行节点太原始了。本篇文章讲透 launch——用 Python 编写 launch 文件启动多节点、传递参数、设置条件与复用、包含其他 launch 文件，掌握 ros2 launch 命令与 launch 调试技巧。学完你就能一键启动整个机器人系统。