第2章 ROS通信机制——服务通信

2.2 服务通信

服务通信也是ROS中一种极其常用的通信模式，服务通信是基于请求响应模式的，是一种应答机制。也即: 一个节点A向另一个节点B发送请求，B接收处理请求并产生响应结果返回给A。比如如下场景:机器人巡逻过程中，控制系统分析传感器数据发现可疑物体或人…此时需要拍摄照片并留存。在上述场景中，就使用到了服务通信。一个节点需要向相机节点发送拍照请求，相机节点处理请求，并返回处理结果与上述应用类似的，服务通信更适用于对时时性有要求、具有一定逻辑处理的应用场景。

概念：以请求响应的方式实现不同节点之间数据交互的通信模式。

作用：用于偶然的、对时时性有要求、有一定逻辑处理需求的数据传输场景。

2.2.1 服务通信理论模型

服务通信较之于话题通信更简单些，理论模型如下图所示，该模型中涉及到三个角色:

  • ROS master(管理者)
  • Server(服务端)
  • Client(客户端)

ROS Master 负责保管 Server 和 Client 注册的信息，并匹配话题相同的 Server 与 Client ，帮助 Server 与 Client 建立连接，连接建立后，Client 发送请求信息，Server 返回响应信息。

整个流程由以下步骤实现:

0.Server 注册

Server 启动后，会通过RPC在 ROS Master 中注册自身信息，其中包含提供的服务的名称。ROS Master 会将节点的注册信息加入到注册表中。

1.Client 注册

Client 启动后，也会通过RPC在 ROS Master 中注册自身信息，包含需要请求的服务的名称。ROS Master 会将节点的注册信息加入到注册表中。

2.ROS Master 实现信息匹配

ROS Master 会根据注册表中的信息匹配Server和 Client，并通过 RPC 向 Client 发送 Server 的 地址信息。

3.发送请求

Client 根据步骤2 响应的信息，使用 TCP 与 Server 建立网络连接，并发送请求数据。

4.发送响应

Server 接收、解析请求的数据，并产生响应结果返回给 Client。

注意:

1.客户端请求被处理时，需要保证服务器已经启动；

2.服务端和客户端都可以存在多个。

2.2.2 服务通信自定义srv

需求:

服务通信中，客户端提交两个整数至服务端，服务端求和并响应结果到客户端，请创建服务器与 客户端通信的数据载体。

流程:

srv 文件内的可用数据类型与 msg 文件一致，且定义 srv 实现流程与自定义 msg 实现流程类似:

  1. 按照固定格式创建srv文件
  2. 编辑配置文件
  3. 编译生成中间文件

1.定义srv文件

服务通信中，数据分成两部分，请求与响应，在 srv 文件中请求和响应使用 ---分割，具体实现如下:

功能包下新建 srv 目录，添加 xxx.srv 文件，内容:

1
2
3
4
5
6
# 客户端请求时发送的两个数字
int32 num1
int32 num2
---
# 服务器响应发送的数据
int32 sum

2.编辑配置文件

package.xml中添加编译依赖与执行依赖

1
2
<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

CMakeLists.txt编辑 srv 相关配置

1
2
3
4
5
6
7
find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
)
# 需要加入 message_generation,必须有 std_msgs
1
2
3
4
add_service_files(
  FILES
  Sum.srv
)
1
2
3
4
generate_messages(
  DEPENDENCIES
  std_msgs
)

3.编译

编译后的中间文件查看:

C++ 需要调用的中间文件(…/工作空间/devel/include/包名/xxx.h)

Python 需要调用的中间文件(…/工作空间/devel/lib/python3/dist-packages/包名/srv)

后续调用相关 srv 时，是从这些中间文件调用的

2.2.3 服务通信自定义srv调用(C++)

需求:

编写服务通信，客户端提交两个整数至服务端，服务端求和并响应结果到客户端。

分析:

在模型实现中，ROS master 不需要实现，而连接的建立也已经被封装了，需要关注的关键点有三个:

  1. 服务端
  2. 客户端
  3. 数据

流程:

  1. 编写服务端实现；
  2. 编写客户端实现；
  3. 编辑配置文件；
  4. 编译并执行。

0.vscode配置

需要像之前自定义 msg 实现一样配置c_cpp_properies.json 文件，如果以前已经配置且没有变更工作 空间，可以忽略，如果需要配置，配置方式与之前相同:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
{
  "configurations": [
    {
      "browse": {
        "databaseFilename": "${default}",
        "limitSymbolsToIncludedHeaders": false
      },
      "includePath": [
        "/opt/ros/noetic/include/**",
        "/home/ylm123/test/src/helloworld/include/**",
        "/home/ylm123/test/src/topic/include/**",
        "/home/ylm123/test/devel/include/**",//配置 head 文件的路径 
        "/usr/include/**"
      ],
      "name": "ROS",
      "intelliSenseMode": "gcc-x64",
      "compilerPath": "/usr/bin/gcc",
      "cStandard": "gnu11",
      "cppStandard": "c++14"
    }
  ],
  "version": 4
}

1.服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
    需求:
        编写两个节点实现服务通信，客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据，相加后，将结果响应回客户端，
        客户端再解析
    服务器实现:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建 ROS 句柄
        4.创建 客户端 对象
        5.请求服务，接收响应
*/
// 1.包含头文件
#include "ros/ros.h"
#include "topic/Sum.h"
int main(int argc, char *argv[])
{
    setlocale(LC_ALL, "");
    // 调用时动态传值,如果通过 launch 的 args 传参，需要传递的参数个数 +3
    if (argc != 3)
    // if (argc != 5)//launch 传参(0-文件路径 1传入的参数 2传入的参数 3节点名称 4日志路径)
    {
        ROS_ERROR("请提交两个整数");
        return 1;
    }
    // 2.初始化 ROS 节点
    ros::init(argc, argv, "Sum_Client");
    // 3.创建 ROS 句柄
    ros::NodeHandle nh;
    // 4.创建 客户端 对象
    ros::ServiceClient client = nh.serviceClient<topic::Sum>("Sum");
    // 等待服务启动成功
    // 方式1
    ros::service::waitForService("Sum");
    // 方式2
    //  client.waitForExistence();
    //  5.组织请求数据
    topic::Sum ai;
    ai.request.num1 = atoi(argv[1]);
    ai.request.num2 = atoi(argv[2]);
    // 6.发送请求,返回 bool 值，标记是否成功
    bool flag = client.call(ai);
    // 7.处理响应
    if (flag)
    {
        ROS_INFO("请求正常处理,响应结果:%d", ai.response.sum);
    }
    else
    {
        ROS_ERROR("请求处理失败....");
        return 1;
    }
    return 0;
}

2.客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
    需求:
        编写两个节点实现服务通信，客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据，相加后，将结果响应回客户端，
        客户端再解析
    服务器实现:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建 ROS 句柄
        4.创建 客户端 对象
        5.请求服务，接收响应
*/
// 1.包含头文件
#include "ros/ros.h"
#include "topic/Sum.h"
int main(int argc, char *argv[])
{
    setlocale(LC_ALL, "");
    // 调用时动态传值,如果通过 launch 的 args 传参，需要传递的参数个数 +3
    if (argc != 3)
    // if (argc != 5)//launch 传参(0-文件路径 1传入的参数 2传入的参数 3节点名称 4日志路径)
    {
        ROS_ERROR("请提交两个整数");
        return 1;
    }
    // 2.初始化 ROS 节点
    ros::init(argc, argv, "Sum_Client");
    // 3.创建 ROS 句柄
    ros::NodeHandle nh;
    // 4.创建 客户端 对象
    ros::ServiceClient client = nh.serviceClient("Sum");
    // 等待服务启动成功
    // 方式1
    ros::service::waitForService("Sum");
    // 方式2
    //  client.waitForExistence();
    //  5.组织请求数据
    topic::Sum ai;
    ai.request.num1 = atoi(argv[1]);
    ai.request.num2 = atoi(argv[2]);
    // 6.发送请求,返回 bool 值，标记是否成功
    bool flag = client.call(ai);
    // 7.处理响应
    if (flag)
    {
        ROS_INFO("请求正常处理,响应结果:%d", ai.response.sum);
    }
    else
    {
        ROS_ERROR("请求处理失败....");
        return 1;
    }
    return 0;
}

3.配置CMakeLists.txt

1
2
3
4
5
6
7
8
9
10
add_executable(Sum_Server src/server.cpp)
add_executable(Sum_Client src/client.cpp)
add_dependencies(Sum_Server ${PROJECT_NAME}_gencpp)
add_dependencies(Sum_Client ${PROJECT_NAME}_gencpp)
target_link_libraries(Sum_Server
  ${catkin_LIBRARIES}
)
target_link_libraries(Sum_Client
  ${catkin_LIBRARIES}
)

4.编译执行

  1. 编译

  2. 启动 roscore;

  3. 启动服务节点; 

    1
    rosrun 包名 服务

  4. 启动客服端节点。

    1
    rosrun 包名 客户端 参数1 参数2

    会根据提交的数据响应相加后的结果。

注意：

如果先启动客户端，那么会导致运行失败

优化

在客户端发送请求前添加: client.waitForExistence();

或: ros::service::waitForService("AddInts");

这是一个阻塞式函数，只有服务启动成功后才会继续执行

此处可以使用 launch 文件优化，但是需要注意 args 传参特点

2.2.4 服务通信自定义srv调用(Python)

0.vscode

需要像之前自定义 msg 实现一样配置settings.json 文件，如果以前已经配置且没有变更工作空间，可 以忽略，如果需要配置，配置方式与之前相同:

1
2
3
4
5
6
7
8
9
{
    "python.autoComplete.extraPaths": [
        "/opt/ros/noetic/lib/python3/dist-packages",
        "/home/ylm123/test/devel/lib/python3/dist-packages"
    ],
    "python.analysis.extraPaths": [
        "/opt/ros/noetic/lib/python3/dist-packages"
    ]
}

1.服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#! /usr/bin/env python
"""
    需求: 
        编写两个节点实现服务通信，客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据，相加后，将结果响应回客户端，
        客户端再解析
    服务器端实现:
        1.导包
        2.初始化 ROS 节点
        3.创建服务对象
        4.回调函数处理请求并产生响应
        5.spin 函数
"""
 # 1.导包
import rospy
from topic.srv import Sum,SumRequest,SumResponse
 # 回调函数的参数是请求对象，返回值是响应对象
def doReq(req):
    # 解析提交的数据
    sum = req.num1 + req.num2
    rospy.loginfo("提交的数据:num1 = %d, num2 = %d, sum = %d",req.num1, req.num2, sum)
    # 创建响应对象，赋值并返回
    # resp = SumResponse()
    # resp.sum = sum
    resp = SumResponse(sum)
    return resp
if __name__ == "__main__":
    # 2.初始化 ROS 节点
    rospy.init_node("Sum_server_p")
    # 3.创建服务对象
    server = rospy.Service("Sum",Sum,doReq)
    # 4.回调函数处理请求并产生响应
    # 5.spin 函数
    rospy.spin()

2.客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#! /usr/bin/env python
"""
    需求: 
        编写两个节点实现服务通信，客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据，相加后，将结果响应回客户端，
        客户端再解析
    客户端实现:
        1.导包
        2.初始化 ROS 节点
        3.创建请求对象
        4.发送请求
        5.接收并处理响应
    优化:
        加入数据的动态获取
"""
 #1.导包
import rospy
from topic.srv import *
import sys
if __name__ == "__main__":
    #优化实现
    if len(sys.argv) != 3:
        rospy.logerr("请正确提交参数")
        sys.exit(1)
    # 2.初始化 ROS 节点
    rospy.init_node("Sum_Client_p")
    # 3.创建请求对象
    client = rospy.ServiceProxy("Sum",Sum)
    # 请求前，等待服务已经就绪
    # 方式1:
    # rospy.wait_for_service("Sum")
    # 方式2
    client.wait_for_service()
    # 4.发送请求,接收并处理响应
    # 方式1
    # resp = client(3,4)
    # 方式2
    # resp = client(SumRequest(1,5))
    # 方式3
    req = SumRequest()
    # req.num1 = 100
    # req.num2 = 200 
    #优化
    req.num1 = int(sys.argv[1])
    req.num2 = int(sys.argv[2]) 
    resp = client.call(req)
    rospy.loginfo("响应结果:%d",resp.sum)

3.设置权限

终端下进入 scripts 执行: 

1
chmod +x *.py

4.配置CMakeLists.txt

1
2
3
4
5
catkin_install_python(PROGRAMS
  scripts/server_py.py
  scripts/client_py.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

5.编译执行

  1. 编译

  2. 启动 roscore;

  3. 启动服务节点; 

    1
    rosrun 包名 服务

  4. 启动客服端节点。

    1
    rosrun 包名 客户端 参数1 参数2

    会根据提交的数据响应相加后的结果。