ROS2系列教程：服务Service通信（上）客户端与服务端

发布时间：2026-09-04 13:44:36

🕒 阅读时间：17 分钟📝 字数：3443👀 阅读量：Loading...

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

本文是 ROS2 系列教程的第 7 篇：服务 Service 通信（上）——客户端与服务端。话题解决“单向广播”，服务解决“请求-应答”：客户端发请求，服务端算好回响应。机器人里的“查询状态”“设置参数”“执行动作”这类一问一答的场景都用服务。本篇文章讲透 Request/Response 模型、同步与异步调用，用 Python 与 C++ 实现服务端与客户端，掌握 ros2 service 调试命令，并理清“话题 vs 服务”的选型。

一、服务通信模型

1.1 Request / Response 模型

服务（Service）采用**请求-响应（Request/Response）**模型：

1
客户端（Client）                服务端（Server）
2
    │   ── 发送请求(Request) ──▶    │
3
    │                              │  处理请求
4
    │   ◀── 返回响应(Response) ──  │

核心特点：

双向：一问一答，客户端必须等待（或异步等待）服务端响应。
一对多：一个服务可被多个客户端调用；一个服务端可提供多个服务。
有状态交互：适合“查询/设置/触发”类操作，不适合持续数据流。

典型场景：查询电池状态、设置机器人速度、触发一次建图、请求一次路径规划。持续高频的数据（雷达、里程计）请用话题。

1.2 服务名与接口类型

服务由服务名 + 服务类型标识：

1
服务名（service name）：/set_speed
2
服务类型（service type）：my_interfaces/srv/SetSpeed

服务类型定义请求与响应的结构，用 .srv 文件描述（第 4 篇讲过），--- 分隔：

1
float64 target_speed      # 请求部分
2
bool   is_emergency_stop
3
---
4
bool     success          # 响应部分
5
string   message

1.3 ROS1 vs ROS2 的服务

维度	ROS1	ROS2
客户端查找服务端	通过 roscore 注册表	DDS 自动发现
请求响应类型	原生类型为主	强类型 `.srv` 接口
客户端多服务端	同一服务名只认第一个	支持多服务端负载均衡（部分 DDS）
加密安全	无	SROS2 支持

ROS2 的服务与话题一样，都基于 DDS 传输，只是语义从“流”变成“问答”。服务名与话题名可以相同（不同命名空间），但为了清晰通常用不同名字。

二、Python 服务端与客户端

2.1 服务端（Server）

用内置的 std_srvs/srv/Trigger（空请求，返回 success + message）演示最简服务端：

1
# py_pkg/py_service_server.py —— Python 服务端
2
import rclpy
3
from rclpy.node import Node
4
from std_srvs.srv import Trigger
5

6
class PyServiceServer(Node):
7
    def __init__(self):
8
        super().__init__('py_service_server')
9
        # 创建服务：服务类型 + 服务名 + 回调函数
10
        self.srv = self.create_service(Trigger, 'ping_service', self.handle_request)
11
        self.get_logger().info('服务已就绪: /ping_service')
12

13
    def handle_request(self, request, response):
14
        # 处理请求，填充响应（request 为空请求，但可读取字段）
15
        response.success = True
16
        response.message = 'pong from py_server'
17
        self.get_logger().info('收到请求，返回 pong')
18
        return response
19

20
def main():
21
    rclpy.init()
22
    node = PyServiceServer()
23
    rclpy.spin(node)
24
    node.destroy_node()
25
    rclpy.shutdown()
26

27
if __name__ == '__main__':
28
    main()

服务端回调关键点：

create_service(类型, 服务名, 回调) 注册服务。
回调签名固定为 (request, response) -> response。
回调由 spin() 驱动——服务端必须 spin，否则不响应任何请求。
回调同样不能做耗时操作（阻塞期间其他请求排队）。

2.2 客户端（Client）——同步调用

1
# py_pkg/py_service_client.py —— Python 客户端（同步）
2
import rclpy
3
from rclpy.node import Node
4
from std_srvs.srv import Trigger
5

6
class PyServiceClient(Node):
7
    def __init__(self):
8
        super().__init__('py_service_client')
9
        # 创建客户端：服务类型 + 服务名
10
        self.client = self.create_client(Trigger, 'ping_service')
11

12
    def call_sync(self):
13
        # 1. 等待服务端上线
14
        while not self.client.wait_for_service(timeout_sec=1.0):
15
            self.get_logger().info('等待服务端...')
16
        # 2. 构造请求
17
        request = Trigger.Request()
18
        # 3. 同步调用（阻塞直到收到响应）
19
        future = self.client.call_async(request)
20
        # 4. 等待 future 完成
21
        rclpy.spin_until_future_complete(self, future)
22
        if future.result() is not None:
23
            response = future.result()
24
            self.get_logger().info(
25
                f'服务端响应: success={response.success} msg={response.message}')
26
        else:
27
            self.get_logger().error('调用失败')
28

29
def main():
30
    rclpy.init()
31
    node = PyServiceClient()
32
    node.call_sync()
33
    node.destroy_node()
34
    rclpy.shutdown()
35

36
if __name__ == '__main__':
37
    main()

Python 同步调用的本质：rclpy 没有真正阻塞的 call()，而是用 call_async() 发起 + spin_until_future_complete 原地处理回调直到完成。这保证了调用期间事件循环仍在转。

2.3 客户端——异步调用

不阻塞主流程的异步调用（适合周期检查、多服务并发）：

1
# py_pkg/py_service_client_async.py —— 异步客户端
2
import rclpy
3
from rclpy.node import Node
4
from std_srvs.srv import Trigger
5

6
class AsyncClient(Node):
7
    def __init__(self):
8
        super().__init__('async_client')
9
        self.client = self.create_client(Trigger, 'ping_service')
10
        self.timer = self.create_timer(2.0, self.periodic_call)
11
        self.busy = False
12

13
    def periodic_call(self):
14
        if self.busy:
15
            return
16
        if not self.client.wait_for_service(timeout_sec=0.5):
17
            self.get_logger().info('服务端未就绪，跳过本轮')
18
            return
19
        request = Trigger.Request()
20
        future = self.client.call_async(request)
21
        # 注册回调：响应到达时自动执行（不阻塞主循环）
22
        future.add_done_callback(self.on_response)
23
        self.busy = True
24

25
    def on_response(self, future):
26
        self.busy = False
27
        if future.result() is not None:
28
            r = future.result()
29
            self.get_logger().info(f'响应: {r.message}')
30
        else:
31
            self.get_logger().error('请求超时或失败')
32

33
def main():
34
    rclpy.init()
35
    node = AsyncClient()
36
    rclpy.spin(node)          # 定时器驱动，循环发起异步请求
37
    node.destroy_node()
38
    rclpy.shutdown()
39

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

异步调用的优势：主循环不阻塞，可以同时“边等响应边干别的”；多个并发请求互不干扰。代价是逻辑复杂度上升（回调处理响应）。

三、C++ 服务端与客户端

3.1 C++ 服务端

1
// cpp_pkg/src/service_server.cpp —— C++ 服务端
2
#include "rclcpp/rclcpp.hpp"
3
#include "std_srvs/srv/trigger.hpp"
4

5
class ServiceServer : public rclcpp::Node
6
{
7
public:
8
  ServiceServer() : Node("service_server")
9
  {
10
    // 创建服务，回调绑定成员函数
11
    server_ = this->create_service<std_srvs::srv::Trigger>(
12
      "ping_service",
13
      std::bind(&ServiceServer::handle_request, this,
14
                std::placeholders::_1, std::placeholders::_2));
15
    RCLCPP_INFO(this->get_logger(), "服务已就绪: /ping_service");
16
  }
17

18
private:
19
  // 回调签名：请求/响应都是 SharedPtr
20
  void handle_request(
21
    const std::shared_ptr<std_srvs::srv::Trigger::Request> request,
22
    std::shared_ptr<std_srvs::srv::Trigger::Response> response)
23
  {
24
    response->success = true;
25
    response->message = "pong from cpp_server";
26
    RCLCPP_INFO(this->get_logger(), "收到请求，返回 pong");
27
  }
28

29
  rclcpp::Service<std_srvs::srv::Trigger>::SharedPtr server_;
30
};
31

32
int main(int argc, char** argv)
33
{
34
  rclcpp::init(argc, argv);
35
  rclcpp::spin(std::make_shared<ServiceServer>());
36
  rclcpp::shutdown();
37
  return 0;
38
}

3.2 C++ 客户端——同步调用

1
// cpp_pkg/src/service_client.cpp —— C++ 客户端
2
#include "rclcpp/rclcpp.hpp"
3
#include "std_srvs/srv/trigger.hpp"
4
#include <chrono>
5

6
class ServiceClient : public rclcpp::Node
7
{
8
public:
9
  ServiceClient() : Node("service_client")
10
  {
11
    client_ = this->create_client<std_srvs::srv::Trigger>("ping_service");
12
    timer_ = this->create_wall_timer(
13
      std::chrono::seconds(2),
14
      std::bind(&ServiceClient::call_service, this));
15
  }
16

17
private:
18
  void call_service()
19
  {
20
    // 1. 等服务端
21
    if (!client_->wait_for_service(std::chrono::seconds(1))) {
22
      RCLCPP_WARN(this->get_logger(), "服务端未就绪");
23
      return;
24
    }
25
    // 2. 构造请求
26
    auto request = std::make_shared<std_srvs::srv::Trigger::Request>();
27
    // 3. 异步发起，保存 future
28
    auto future = client_->async_send_request(request);
29
    // 4. 同步等待（spin_until_future_complete 内处理响应）
30
    if (rclcpp::spin_until_future_complete(this->get_node_base_interface(), future)
31
        == rclcpp::FutureReturnCode::SUCCESS) {
32
      auto response = future.get();
33
      RCLCPP_INFO(this->get_logger(), "响应: %s", response->message.c_str());
34
    } else {
35
      RCLCPP_ERROR(this->get_logger(), "调用失败");
36
    }
37
  }
38

39
  rclcpp::Client<std_srvs::srv::Trigger>::SharedPtr client_;
40
  rclcpp::TimerBase::SharedPtr timer_;
41
};
42

43
int main(int argc, char** argv)
44
{
45
  rclcpp::init(argc, argv);
46
  rclcpp::spin(std::make_shared<ServiceClient>());
47
  rclcpp::shutdown();
48
  return 0;
49
}

C++ 同步调用要点：async_send_request 返回 SharedFuture，配合 spin_until_future_complete 等待；不能真的 future.get() 死等（会卡死事件循环）。C++ 的“同步”本质与 Python 一致——都是在事件循环里处理响应。

3.3 双语言混调

1
# Python 服务端 + C++ 客户端，或反过来，都能工作
2
ros2 run py_pkg py_service_server
3
ros2 run cpp_pkg service_client

与话题一样，服务也支持跨语言：只要服务名与类型一致，任何语言的客户端都能调任何语言的服务端。

四、自定义服务接口实战

4.1 定义并构建服务接口

沿用第 4 篇的 my_interfaces 包，添加 SetSpeed.srv（见第 4 篇 4.4），构建：

1
colcon build --packages-select my_interfaces
2
source install/setup.bash

验证接口可用：

1
ros2 interface show my_interfaces/srv/SetSpeed

4.2 服务端：速度设置服务

1
# py_pkg/speed_service.py —— 速度设置服务端
2
import rclpy
3
from rclpy.node import Node
4
from my_interfaces.srv import SetSpeed
5

6
class SpeedService(Node):
7
    def __init__(self):
8
        super().__init__('speed_service')
9
        self.srv = self.create_service(SetSpeed, 'set_speed', self.handle)
10
        self.current_speed = 0.0
11

12
    def handle(self, request, response):
13
        if request.is_emergency_stop:
14
            self.current_speed = 0.0
15
            response.success = True
16
            response.message = '急停！速度归零'
17
        elif 0.0 <= request.target_speed <= 3.0:
18
            self.current_speed = request.target_speed
19
            response.success = True
20
            response.message = f'速度已设置为 {self.current_speed}'
21
        else:
22
            response.success = False
23
            response.message = f'速度 {request.target_speed} 超出范围 [0, 3]'
24
        self.get_logger().info(response.message)
25
        return response
26

27
def main():
28
    rclpy.init()
29
    node = SpeedService()
30
    rclpy.spin(node)
31
    node.destroy_node()
32
    rclpy.shutdown()
33

34
if __name__ == '__main__':
35
    main()

4.3 客户端：连续请求测试

1
# py_pkg/speed_client.py —— 速度设置客户端
2
import rclpy
3
from rclpy.node import Node
4
from my_interfaces.srv import SetSpeed
5

6
class SpeedClient(Node):
7
    def __init__(self):
8
        super().__init__('speed_client')
9
        self.client = self.create_client(SetSpeed, 'set_speed')
10

11
    def set_speed(self, target, emergency=False):
12
        if not self.client.wait_for_service(timeout_sec=1.0):
13
            self.get_logger().error('服务不可用')
14
            return
15
        request = SetSpeed.Request()
16
        request.target_speed = target
17
        request.is_emergency_stop = emergency
18
        future = self.client.call_async(request)
19
        rclpy.spin_until_future_complete(self, future)
20
        if future.result():
21
            r = future.result()
22
            self.get_logger().info(f'success={r.success} msg={r.message}')
23
        return future.result()
24

25
def main():
26
    rclpy.init()
27
    node = SpeedClient()
28
    node.set_speed(1.5)       # 正常设置
29
    node.set_speed(5.0)       # 超范围，应被拒绝
30
    node.set_speed(2.0, emergency=True)  # 急停
31
    node.destroy_node()
32
    rclpy.shutdown()
33

34
if __name__ == '__main__':
35
    main()

4.4 命令行调用服务

不写任何代码，用命令行直接测服务（开发调试利器）：

1
# 运行服务端
2
ros2 run py_pkg speed_service
3

4
# 调用服务（命令行客户端）
5
ros2 service call /set_speed my_interfaces/srv/SetSpeed \
6
  "{target_speed: 1.5, is_emergency_stop: false}"
7

8
# 查看服务信息
9
ros2 service list                       # 列出所有服务
10
ros2 service list -t                    # 带类型
11
ros2 service type /set_speed            # 查看服务类型
12
ros2 service find my_interfaces/srv/SetSpeed   # 按类型找服务
13
ros2 service info /set_speed            # 服务详情（客户端/服务端数量）

命令行调用是验证服务逻辑最快的方式：先跑服务端，再用 ros2 service call 模拟客户端，观察响应是否符合预期。

五、ros2 service 全套命令

1
# 列出所有服务
2
ros2 service list
3

4
# 列出服务及类型
5
ros2 service list -t
6

7
# 查看某服务的类型
8
ros2 service type /set_speed
9

10
# 按类型反查服务
11
ros2 service find std_srvs/srv/Trigger
12

13
# 查看服务详情（服务端/客户端数量）
14
ros2 service info /set_speed
15

16
# 手动调用服务
17
ros2 service call /set_speed my_interfaces/srv/SetSpeed "{target_speed: 2.0, is_emergency_stop: false}"
18

19
# 调用内置 Trigger 服务
20
ros2 service call /ping_service std_srvs/srv/Trigger "{}"

六、话题 vs 服务：如何选型

维度	话题 Topic	服务 Service
通信模式	单向广播	请求-应答
是否阻塞	发布不阻塞	客户端等响应（可异步）
数据流	持续流式	一次性问答
典型场景	传感器数据、控制指令	查询、设置、触发
多接收方	天然一对多	一对一（一个请求一个响应）
反馈	无	有（响应即反馈）
长任务	不适合	不适合（用 Action，第 10 篇）
调试命令	`ros2 topic *`	`ros2 service *`

选型口诀：

持续流动的数据 → 话题（雷达、里程计、图像、速度指令）
偶尔发生的问答 → 服务（查状态、设参数、触发生成）
带进度反馈的长任务 → 动作 Action（导航、机械臂运动，第 10 篇）

反例警示：别用服务做高频数据（每帧一个请求，服务端成瓶颈）；别用话题做“必须等到结果”的操作（收不到确认）。

七、总结

本篇文章完成了服务通信的完整入门：理解了 Request/Response 模型与适用场景，用 Python 和 C++ 分别实现了服务端、同步客户端、异步客户端，实战了自定义服务接口（速度设置），并掌握了 ros2 service 命令行调试工具，最后理清了话题与服务的选型边界。

关键要点回顾：

服务 = 服务名 + 服务类型（.srv），请求与响应由 --- 分隔。
服务端必须 spin() 才会处理请求；回调签名固定为 (request, response) -> response。
客户端先 wait_for_service，再 call_async；同步语义靠 spin_until_future_complete 实现。
异步调用用 future.add_done_callback，主循环不阻塞。
ros2 service call/list/type/info 是服务调试四件套。
持续数据用话题，一问一答用服务，长任务带反馈用 Action。

下一篇预告

下一篇深入服务 Service 通信（下）——同步异步与回调组：对比同步/异步的底层机制与性能差异、多请求并发处理、ReentrantCallbackGroup 与 MutuallyExclusiveCallbackGroup 回调组、服务的超时与重试策略、服务与 QoS 的关系，以及服务端多线程执行器的最佳实践。学完你能设计稳健的服务架构。