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

已于 2022-09-30 16:07:42 修改
阅读量581 收藏 4
点赞数 2
分类专栏： ROS 理论与实践 文章标签： 机器人 自动驾驶 人工智能
于 2022-09-25 23:21:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42731062/article/details/127028303
版权

文章目录

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后面其他地方不能加空格

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

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

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

  3. ROS Master实现信息匹配
    ROS Master 会根据注册表中的信息匹配Server和 Client，并通过 RPC 向 Client 发送 Server 的 TCP 地址信息，就是向客户端发送服务端的地址信息。

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

  5. 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
NqqGOGO
关注
专栏目录
ROS的通讯机制
weixin_41676170的博客
03-22 709
ROS有三种核心的通讯机制： publishers/subscribers services/clients action-servers/action-clients 1.publishers #include <ros/ros.h> //惯例第一头文件，ROS的源码 #include <std_msgs/Float64.h> //传递的消息类型文件，根据...
ROS架构（五）——ROS的通信机制
weixin_45661757的博客
01-11 5791
ROS架构（四）——ROS的通信机制 ROS的核心——分布式通信机制
ROS 通信机制(已整理)
qq_42731062的博客
07-08 2265
b站课程代码
ROS 2 服务通信
最新发布
weixin_44318762的博客
08-12 1015
是一个用于机器人系统开发的开源框架，提供了许多工具和库来简化复杂机器人应用的开发。在 ROS 2 中，服务（Service）是一种同步的通信机制，允许节点之间进行请求-响应模式的通信。这与话题（Topics）中的异步通信方式不同，服务更适合那些需要明确请求和相应结果的应用场景。在这篇文章中，我们将介绍如何使用 C++ 创建和使用 ROS 2 服务，包括服务端（Service Server）和客户端（Service Client）的实现。
ROS通信机制
neuzhangno的博客
06-28 2075
RPC调用将远程节点的服务请求封装在本地节点的函数调用中，通过网络将请求发送给远程节点，远程节点接收请求并执行相应的服务逻辑，然后将结果返回给本地节点。在ROS中，要使用服务通信，你需要创建一个服务客户端节点和一个服务服务器节点。服务客户端节点通过调用ROS的服务客户端接口发送请求到指定服务上，而服务服务器节点通过调用ROS的服务服务器接口接收请求并处理，最后发送响应。2.客户端-服务器架构：服务客户端节点发送请求到服务服务器节点，服务服务器节点接收请求并进行相应的处理，最后发送响应给服务客户端节点。
【ROS 02】ROS通信机制
weixin_42322991的博客
07-31 1771
... 但是，这些数据一般只包含一个 data 字段，结构的单一意味着功能上的局限性，当传输一些复杂的数据，比如: 激光雷达的信息... std_msgs 由于描述性较差而显得力不从心，这种场景下可以使用自定义的消息类型msgs只是简单的文本文件，每行具有字段类型和字段名称，可以使用的字段类型有：int8, int16, int32, int64 (或者无符号类型: uint*)stringHeader标头包含时间戳和ROS中常用的坐标帧信息。会经常看到msg文件的第一行具有。
浅谈ROS的产品化探索（一）——通信机制篇
01-27
通信机制，百度All in人工智能隐藏的ROS身影，研究者对ROS中的解决方案等。近几年，机器人和人工智能繁荣发展，曾经运行在实验室的机器人已经逐渐走入千家万户的生活。作为机器人开发利器的ROS也得到了非常广泛的...
【ROS入门-5】深入了解ROS话题通信机制的过程
01-06
在上一篇文章中简单了解了ROS话题通信机制，但是它内部的通信过程，很多人都是不知道的，今天我看了 胡春旭的书籍——《ROS机器人开发实践》，又加深了对ROS话题通信的理解，打算接着讲解一下其过程是怎么样的。...
ROS 通信机制
Fantasy4040的博客
12-05 495
话题通信是ROS中使用频率最高的一种通信模式，话题通信是基于发布订阅模式的，即：一个节点发布消息，另一个节点订阅该消息。话题通信的应用场景极其广泛，例如：机器人在执行导航功能，使用的传感器是激光雷达，机器人会采集激光雷达感知到的信息并计算，然后生成运动控制信息驱动机器人底盘运动。在上述场景中，不只一次使用到了话题通信：以激光雷达信息的采集处理为例，在ROS中有一个节点需要实时发布当前雷达采集到的数据，导航模块中也会有节点会订阅并解析雷达数据。
ROS：通信机制
立于皓月之边，不弱星光之势
06-23 2099
ROS：通信机制
【ROS】—— ROS通信机制——服务通信（三）
sinat_52032317的博客
01-02 1051
📢本系列将依托赵虚左老师的ROS课程，写下自己的一些心得与笔记。📢 文章可能存在疏漏的地方，恳请大家指出。srv = 请求 +相应按照固定格式创建srv文件编辑配置文件编译生成中间文件服务通信中，数据分成两部分，请求与响应，在 srv 文件中请求和响应使用—分割，具体实现如下:# 客户端请求时发送的两个数字int32 num1int32 num2---# 服务器响应发送的数据int32 sum编写服务端实现；编写客户端实现；编辑配置文件；编译并执行。
ROS的通信机制
一点痕迹
10-15 240
添加链接描述
ROS学习笔记4——ROS通信机制（话题通信）
Simulink_的博客
01-14 1582
ROS Master 负责保管 Talker 和 Listener 注册的信息，并匹配话题相同的 Talker 与 Listener，帮助 Talker 与 Listener 建立连接，连接建立后，Talker 可以发布消息，且发布的消息会被 Listener 订阅。ROS Master 会根据注册表中的信息匹配Talker 和 Listener，如果Talker和Listener的话题一致，就会 Listener 发送 Talker 的 RPC 地址信息。4、上述实现流程是做好封装的，可以直接调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NqqGOGO

你的鼓励是我学习的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值