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

2021 Nqq

已于 2022-09-30 16:07:42 修改

阅读量469

点赞数 2

分类专栏： ROS 理论与实践文章标签：机器人自动驾驶人工智能

于 2022-09-25 23:21:18 首次发布

本文链接：https://blog.csdn.net/qq_42731062/article/details/127028303

版权

ROS 理论与实践专栏收录该内容

27 篇文章 27 订阅

订阅专栏

文章目录

1 应用场景
2 服务通信模型
3 服务通信自定义srv(重点) —— 功能包 plumbing_server_client
4 服务通信自定义srv调用(C++)
5 服务通信自定义srv调用(python)

1 应用场景

服务通信是基于请求响应模式的，是一种应答机制。也即: 一个节点A向另一个节点B发送请求，B接收处理请求并产生响应结果返回给A。比如如下场景:

机器人巡逻过程中，控制系统分析传感器数据发现可疑物体或人… 此时需要拍摄照片并留存

在上述场景中，就使用到了服务通信。

一个节点需要向相机节点发送拍照请求，相机节点处理请求，并返回处理结果

与上述应用类似的，服务通信更适用于对时时性有要求、具有一定逻辑处理的应用场景。

概念：以请求响应的方式实现不同节点之间数据交互的通信模式
作用：用于偶然的、对时时性有要求、有一定逻辑处理需求的数据传输场景

2 服务通信模型

在这里插入图片描述

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

ROS master(管理者)
Server(服务端)
Client(客户端)
适用于对时时性有要求、具有一定逻辑处理的应用场景。基于请求响应模式的，是一种应答机制。一个节点A向另一个节点B发送请求，B接收处理请求并产生响应结果返回给A
ROS Master 负责保管 Server 和 Client 注册的信息，并匹配话题相同的 Server 与 Client，帮助 Server 与 Client 建立连接，连接建立后，Client 发送请求信息，Server 返回响应信息

在这里插入图片描述

和话题通信相比，服务通信必须是服务端先启动，然后客户端启动。就是说客户端发起请求时，服务端已经启动
srv包括请求+响应
srv目录下的AddInts里面进行设置时除了32后面其他地方不能加空格

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

Server注册
Server 启动后，会通过RPC在 ROS Master 中注册自身信息，包含提供的服务的名称。ROS Master 会将节点的注册信息加入到注册表中。
Client注册
Client 启动后，也会通过RPC在 ROS Master 中注册自身信息，包含需要请求的服务的名称。ROS Master 会将节点的注册信息加入到注册表中。
ROS Master实现信息匹配
ROS Master 会根据注册表中的信息匹配Server和 Client，并通过 RPC 向 Client 发送 Server 的 TCP 地址信息，就是向客户端发送服务端的地址信息。
Client发送请求
Client 根据步骤2 响应的信息，使用 TCP 与 Server 建立网络连接，并发送请求数据。
Server发送响应
Server 接收、解析请求的数据，并产生响应结果返回给 Client。

注意:
1.客户端请求被处理时，需要保证服务器已经启动；
2.服务端和客户端都可以存在多个。

3 服务通信自定义srv(重点) —— 功能包 plumbing_server_client

需求：服务通信中，客户端提交两个整数至服务端，服务端求和并响应结果到客户端，请创建服务器与客户端通信的数据载体。srv = 请求 + 响应
流程 —— srv 文件内的可用数据类型与 msg 文件一致，且定义 srv 实现流程与自定义 msg 实现流程类似：1 按照固定格式创建srv文件；2 编辑配置文件；3 编译生成中间文件

3.1 定义srv文件

服务通信中，数据分成两部分，请求与响应，在 srv 文件中请求和响应使用—分割，具体实现如下：功能包下新建 srv 目录，添加 AddInts.srv 文件

# 客户端请求时发送的两个数字
int32 num1
int32 num2
---
# 服务器响应发送的数据
int32 sum
# srv目录下除了32后面其他地方不能加空格

3.2 编辑配置文件

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

  <buildtool_depend>catkin</buildtool_depend>
  <build_depend>roscpp</build_depend>
  <build_depend>rospy</build_depend>
  <build_depend>std_msgs</build_depend>
  <build_depend>message_generation</build_depend>(新添加)

  <build_export_depend>roscpp</build_export_depend>
  <build_export_depend>rospy</build_export_depend>
  <build_export_depend>std_msgs</build_export_depend>
  
  <exec_depend>roscpp</exec_depend>
  <exec_depend>rospy</exec_depend>
  <exec_depend>std_msgs</exec_depend>
  <exec_depend>message_runtime</exec_depend>(新添加)

CMakeLists.txt编辑 srv 相关配置

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
)
# 需要加入 message_generation,必须有 std_msgs

add_service_files(
  FILES
  AddInts.srv
)

generate_messages(
  DEPENDENCIES
  std_msgs
)

注意: 官网没有在 catkin_package 中配置 message_runtime,经测试配置也可以，建议进行配置

# 执行依赖
catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES demo02_talker_listener
  CATKIN_DEPENDS roscpp rospy std_msgs message_runtime
#  DEPENDS system_lib
)

3.3 编译运行

编译 CTRL+SHIFT+B

编译后的中间文件查看

C++ 需要调用的中间文件(…/工作空间/devel/include/包名/AddInts.h)
Python 需要调用的中间文件(…/工作空间/devel/lib/python3/dist-packages/包名/srv)
后续调用相关 srv 时，是从这些中间文件调用的。

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

4.1 vscode 配置

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

步骤1：右击文件devel下的include文件，选择在终端中打开
步骤2：输入pwd
步骤3：复制文字到json文件中

{
    "configurations": [
        {
            "browse": {
                "databaseFilename": "",
                "limitSymbolsToIncludedHeaders": true
            },
            "includePath": [
                "/opt/ros/noetic/include/**",
                "/usr/include/**",
                "/home/rosmelodic/demo01_ws/devel/include/**"(新添加)
            ],
            "name": "ROS",
            "intelliSenseMode": "gcc-x64",
            "compilerPath": "/usr/bin/gcc",
            "cStandard": "c11",
            "cppStandard": "c++17"
        }
    ],
    "version": 4
}

4.2 服务端 demo01_server.cpp

#include "ros/ros.h"
#include "plumbing_server_client/AddInts.h"
/*
    服务端实现：解析客户端提交的数据，并运算再产生响应
        1.包含头文件
        2.初始化ROS节点
        3.创建节点句柄
        4.创建一个服务端对象
        5.处理请求并产生响应
        6.spin()
*/

bool doNums(plumbing_server_client::AddInts::Request &request,
            plumbing_server_client::AddInts::Response &response){
    //1.处理请求
    int num1 = request.num1;
    int num2 = request.num2;
    ROS_INFO("收到的请求数据:num1 = %d,num2 = %d",num1,num2);
    //2.组织响应
    int sum = num1 + num2;
    response.sum = sum;
    ROS_INFO("求和的结果:sum = %d",sum);

    return true;
}
int main(int argc, char *argv[])
{
    //解决乱码问题
    setlocale(LC_ALL,"");

    // 2.初始化ROS节点
    ros::init(argc,argv,"heiShui");//节点名称

    // 3.创建节点句柄
    ros::NodeHandle nh;

    // 4.创建一个服务对象
    ros::ServiceServer server = nh.advertiseService("addInts",doNums);//addInts是话题名称，用于连接二者
    ROS_INFO("服务器端启动");

    // 5.处理请求并产生响应
    // 6.spin()
    ros::spin();
    
    return 0;
}

测试

Ctrl + Shift + B
启动 roscore（窗口1）

roscore

启动服务端 (窗口2)

cd demo01_ws/
source ./devel/setup.bash
rosrun plumbing_server_client demo01_server

启动窗口3

rosservice call addInts tab 补齐

4.3 客户端 demo02_client.cpp

#include "ros/ros.h"
#include "plumbing_server_client/AddInts.h"
/*
    客户端：提交两个整数，并处理响应的结果
        1.包含头文件
        2.初始化ROS节点
        3.创建节点句柄
        4.创建一个客户端对象
        5.提交请求并产生响应

    实现参数的动态提交:
        1.格式：rosrun xxxx xxxxx 12 34 后面两个是需要相加的参数
        2.节点执行时，需要获取命令中的参数 并组织进request

    问题：
        如果先启动客户端，那么会请求异常
    需求：
        如果先启动，不要直接抛出异常，而是挂起，等服务器启动后，再正常请求。
    解决：
        在ROS中提供内置相关函数，可以让客户端启动后挂起，等待服务端启动
        client.waitForExistence();
        ros::service::waitForService("话题名称")
*/

//  char* argv[]：是一个数组，每个元素存储的一个指针，就是穿进去的参数的地址。
int main(int argc, char  *argv[])//字符串数组,数组中存放的是数据的地址，读取时是读取数组里存储的地址对应的数据
{
    // 解决乱码问题
    setlocale(LC_ALL,"");

   // 优化实现，获取命令中参数，实现动态 // 有1个参数argc为2，main函数本身1+参数1则argc = 2，这里有两个参数，则argc = 3
    if(argc != 3){
        ROS_INFO("提交的参数个数不对。");
        return true;
    }

    // 2.初始化ROS节点
    ros::init(argc,argv,"daBao");

    // 3.创建节点句柄
    ros::NodeHandle nh;

    // 4.创建一个客户端对象
    ros::ServiceClient client = nh.serviceClient<plumbing_server_client::AddInts>("addInts");//话题是addInts

    // 5.提交请求并产生响应
    plumbing_server_client::AddInts ai;
    // 5.1 组织请求
    ai.request.num1 = atoi(argv[1]);// argv[1]表示的是12，atoi将字符串变成整型
    ai.request.num2 = atoi(argv[2]);// argv[2]表示的是34
    // 5.2 处理响应
    // 判断服务器状态的函数
    // 函数1
    // client.waitForExistence();//客户端等待，实现挂起功能
    // 函数2
    ros::service::waitForService("addInts");
    bool flag = client.call(ai);// true表示正常处理，否则为失败
    if(flag)
    {
        ROS_INFO("响应成功");
        // 获取结果
        ROS_INFO("响应结果：%d",ai.response.sum);
    }
    else{
        ROS_INFO("处理失败");
    }

    return 0;
}

4.4 配置 CMakeLists.txt（和话题通信自定义msg有不同）

add_executable(demo01_server src/demo01_server.cpp)
add_executable(demo02_client src/demo02_client.cpp)

与话题通信自定义msg不同的地方
add_dependencies(demo01_server ${PROJECT_NAME}_gencpp)
add_dependencies(demo02_client ${PROJECT_NAME}_gencpp)


target_link_libraries(demo01_server
  ${catkin_LIBRARIES}
)
target_link_libraries(demo02_client
  ${catkin_LIBRARIES}
)

4.5 编译执行

编译 Ctrl + Shift + B
启动 roscore（窗口1）

roscore

启动服务端(窗口2)

cd demo01_ws/
source ./devel/setup.bash
rosrun plumbing_server_client demo01_server

启动客户端(窗口3)

cd demo01_ws/
source ./devel/setup.bash
rosrun plumbing_server_client demo02_client 12 34 （后面两个是参数）

在这里插入图片描述

流程：1、需要先启动服务:rosrun 包名服务；2、然后再调用客户端 :rosrun 包名客户端参数1 参数2。
结果：会根据提交的数据响应相加后的结果。
注意：如果先启动客户端，那么会导致运行失败
优化：在客户端发送请求前添加 —— client.waitForExistence()；或ros::service::waitForService(“AddInts”)；这是一个阻塞式函数，只有服务启动成功后才会继续执行。此处可以使用 launch 文件优化，但是需要注意 args 传参特点

5 服务通信自定义srv调用(python)

5.1 vscode 配置

为了方便代码提示以及误抛异常，需要先配置 vscode，将前面生成的 python 文件路径配置进 settings.json.

步骤1：右击文件devel下devel ——> lib ——> python3文件，选择在终端中打开
步骤2：输入pwd
步骤3：复制文字到json文件中

{
“python.autoComplete.extraPaths”: [
“/opt/ros/noetic/lib/python3/dist-packages”,
“/home/rosdemo/demo01_ws/devel/lib/python3/dist-packages”(新添加)
]
}

4.2 服务端 demo01_server_p.py

#! /usr/bin/env python # 指定编译器
"""
    服务端：解析客户端请求，产生响应。

        1.导包
        2.初始化ROS节点
        3.创建服务端对象
        4.处理逻辑
        5.spin()
"""

import rospy
from plumbing_server_client.srv import AddInts,AddIntsRequest,AddIntsResponse
# import plumbing_server_client import *

# 回调函数
# 参数：封装了请求数据 返回值：响应数据
def doNum(request):
    # 1. 解析提交的两个整数
    num1 = request.num1
    num2 = request.num2

    # 2. 求和
    sum = num1 + num2

    # 3. 将结果封装进响应
    response = AddIntsResponse()
    response.sum = sum # 将sum赋值给响应对象的sum,即可完成封装
    rospy.loginfo("服务器解析的数据：num1 = %d, num2 = %d,响应的结果：sum = %d",num1,num2,sum)
    return response

if __name__ == "__main__":
    
    # 2.初始化ROS节点
    rospy.init_node("heiShui")

    # 3.创建服务端对象
    server = rospy.Service("addInts",AddInts,doNum)# Addints表示消息对应类型,addInts表示话题名称
    rospy.loginfo("服务器已经启动了")
    # 4.处理逻辑
    # 5.spin()
    rospy.spin()

问题：如果先启动客户端，那么会请求异常
需求：如果先启动，不要直接抛出异常，而是挂起，等服务器启动后，再正常请求
解决：在ROS中提供内置相关函数，可以让客户端启动后挂起，等待服务端启动
client.waitForExistence()
ros::service::waitForService(“话题名称”)

5.3 客户端 demo02_client_p.py

#! /usr/bin/env python # 指定编译器
"""
    客户端：组织并提交请求，处理服务端响应
        1.导包
        2.初始化ROS节点
        3.创建客户端对象
        4.组织请求数据，并且发送请求
        5.处理来自服务端的响应

    优化实现:
        可以在执行节点时，动态传入参数，使用sys
    
    
    问题：
        客户端先于服务端启动，那么会抛出异常
    需求：
        如果客户端先启动，不要直接抛出异常，而是挂起，等服务器启动后，再正常请求。
    解决：
        在ROS中提供内置相关函数，可以让客户端启动后挂起，等待服务端启动
"""

import rospy
from plumbing_server_client.srv import AddInts,AddIntsRequest,AddIntsResponse
import sys

if __name__ == "__main__":

    # 判断参数长度
    if len(sys.argv) != 3:
        rospy.loginfo("传入的参数个数不对")
        sys.exit(1)

    # 2.初始化ROS节点
    rospy.init_node("erHei")

    # 3.创建客户端对象
    client = rospy.ServiceProxy("addInts",AddInts)

    # 4.组织请求数据，并且发送请求,call函数就是发请求的
    # 解析传入的参数 argv[0]表示程序名
    num1 = int(sys.argv[1])
    num2 = int(sys.argv[2]) # 将字符串转化为整型

    # 在客户端之后，发送请求之前调用。等待服务器启动
    # client.wait_for_service()
    rospy.wait_for_service("addInts")

    response = client.call(num1,num2)

    # 5.处理来自服务端的响应
    rospy.loginfo("相应的数据：%d",response.sum)

问题：客户端先于服务端启动，那么会抛出异常
需求：如果客户端先启动，不要直接抛出异常，而是挂起，等服务器启动后，再正常请求
解决：在ROS中提供内置相关函数，可以让客户端启动后挂起，等待服务端启动
法1：client.wait_for_service()
法2：rospy.wait_for_service(“addInts”)

5.4 添加可执行权限

scripts文件右击，在终端中打开，终端下进入 scripts 执行

chmod +x *.py
ll

5.5 配置 CMakeLists.txt

catkin_install_python(PROGRAMS
  scripts/demo01_server_p.py
  scripts/demo02_client_p.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

5.6 编译执行

编译Ctrl + Shift + B
启动 roscore(窗口1)

roscore

启动发布节点(窗口2)

cd demo01_ws/
source ./devel/setup.bash
rosrun plumbing_server_client demo01_server_p.py

启动订阅节点(窗口3)

cd demo01_ws/
source ./devel/setup.bash
rosrun plumbing_server_client demo02_client_p.py