机器人 / 系统课时

使用异步客户端发送请求

使用异步客户端发送请求

当节点需要调用 ROS 2 服务却不能长期占用执行器线程时,可以用 call_async() 发送请求,并用 Future 在响应完成后读取结果。本篇在 ROS 2 Jazzy 中编写一次性加法客户端,验证回调能得到 12,同时处理服务不可用和响应超时。

学习目标

  • 使用 create_client() 创建客户端,检查服务可用性并发起异步请求。
  • 通过 Future.add_done_callback() 读取响应和捕获异常。
  • 理解执行器如何完成请求,避免在 ROS 回调内同步等待。

确认服务名称与类型

示例适用于 Ubuntu 24.04 上的 ROS 2 Jazzy,要求已安装 rclpy、example_interfaces 和 demo_nodes_cpp。服务采用 /add_two_ints,接口为 example_interfaces/srv/AddTwoInts:请求字段 a、b 是 int64,响应字段 sum 也是 int64。

终端 A 加载环境并启动内置加法服务:

bash
source /opt/ros/jazzy/setup.bash
ros2 run demo_nodes_cpp add_two_ints_server

预期结果:进程持续运行,等待请求;收到请求之前不一定打印日志。后续操作保持该终端运行。若找不到可执行文件,先安装对应 Jazzy 演示节点包;两个终端需处于相同 ROS_DOMAIN_ID。

编写客户端与完成回调

在另一个目录创建 async_client.py,使用下面的完整代码。call_async() 返回尚未完成的 Future,不会原地等待服务结果;add_done_callback() 注册结果处理函数。示例在主流程中调用 spin_once(),既驱动回调,又为请求设置 5 秒的等待上限。

python
import time

import rclpy
from example_interfaces.srv import AddTwoInts
from rclpy.node import Node

class AsyncAddClient(Node):
    def __init__(self):
        super().__init__('async_add_client')
        self.client = self.create_client(AddTwoInts, '/add_two_ints')
        self.finished = False

    def send_once(self):
        # 服务发现最多等待 3 秒;此处不在任何 ROS 回调中
        if not self.client.wait_for_service(timeout_sec=3.0):
            raise RuntimeError('/add_two_ints is unavailable')

        request = AddTwoInts.Request()
        request.a = 7
        request.b = 5

        # 先发请求,再登记完成回调;不阻塞等待响应
        future = self.client.call_async(request)
        future.add_done_callback(self.on_response)
        self.get_logger().info('request sent: 7 + 5')

    def on_response(self, future):
        try:
            response = future.result()
            self.get_logger().info(f'result: {response.sum}')
        except Exception as exc:
            self.get_logger().error(f'call failed: {exc}')
        finally:
            self.finished = True

def main():
    rclpy.init()
    node = AsyncAddClient()
    try:
        node.send_once()
        deadline = time.monotonic() + 5.0
        while rclpy.ok() and not node.finished and time.monotonic() < deadline:
            # 只在主流程驱动执行器,不在订阅或定时器回调中嵌套 spin
            rclpy.spin_once(node, timeout_sec=0.1)
        if not node.finished:
            node.get_logger().error('response timeout after 5.0 s')
    except RuntimeError as exc:
        node.get_logger().error(str(exc))
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        if rclpy.ok():
            rclpy.shutdown()

if __name__ == '__main__':
    main()

预期结果:运行时先打印 request sent: 7 + 5,服务端响应后打印 result: 12,随后进程退出。

wait_for_service(timeout_sec=3.0) 只限制寻找服务的时间,不代表请求有 3 秒超时。示例使用单独的单调时钟截止时间限制响应等待;Future 完成后才在 on_response() 中调用 result(),因此不会在未完成时卡住该回调。

运行并验证响应

保持终端 A 的服务运行。在终端 B 中进入保存脚本的目录,加载相同 ROS 环境并直接运行 Python 文件,无需先建立功能包:

bash
source /opt/ros/jazzy/setup.bash
python3 async_client.py

预期输出(时间戳随运行变化):

text
[INFO] [<TIME>] [async_add_client]: request sent: 7 + 5
[INFO] [<TIME>] [async_add_client]: result: 12

结果 12 来自服务端计算 7 + 5,并通过 Future 送回客户端。正常情况下客户端随后销毁节点并退出;若没有收到响应,约 5 秒后打印超时错误。<TIME> 仅表示运行时生成的日志时间戳。

看懂调度顺序与死锁风险

异步调用要区分发出请求与收到响应:客户端创建请求并调用 call_async() 后,服务端计算结果;执行器在后续 spin_once() 中接收响应,使 Future 完成,然后触发 on_response()。若不运行 spin()、spin_once() 或其他执行器循环,响应完成回调通常无法得到调度。

异步服务请求、Future 完成和回调调度时序

rclpy.spin_until_future_complete(node, future) 可放在一次性客户端的主流程中,但不要放进订阅或定时器回调:默认互斥回调组和单线程执行器下,当前回调可能占着执行机会等待另一个回调,最终死锁。需要从回调触发服务请求时,发起 call_async() 后立即返回,让完成回调接续处理。

排查时先用 ros2 service list -t 确认 /add_two_ints 和 example_interfaces/srv/AddTwoInts 一致,再检查服务端进程及通信域。生产中的持续运行节点还应追踪未完成请求,并在超时或取消时清理挂起状态,避免连续调用积累待处理请求。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

使用异步客户端发送请求

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通