【ROS】—— ROS通信机制——服务通信(三)

文章目录

  • 前言
  • 1. 服务通信理论模型
  • 2. 服务通信自定义srv
    • 2.1 定义srv文件
    • 2.2 编辑配置文件
    • 2.3 编译
  • 3. 服务通信自定义srv调用(C++)
    • 3.1 vscode配置
    • 3.2 服务端
    • 3.3 客户端
    • 3.4 配置 CMakeLists.txt
  • 4. 服务通信自定义srv调用(python)
    • 4.1 vscode配置
    • 4.2 服务端
    • 4.3 客户端
    • 4.4 配置 CMakeLists.txt

前言

本系列将依托赵虚左老师的ROS课程,写下自己的一些心得与笔记。
课程链接:https://www.bilibili.com/video/BV1Ci4y1L7ZZ
讲义链接:http://www.autolabor.com.cn/book/ROSTutorials/index.html
文章可能存在疏漏的地方,恳请大家指出。

1. 服务通信理论模型

服务通信也是ROS中一种极其常用的通信模式,服务通信是基于请求响应模式的,是一种应答机制。也即: 一个节点A向另一个节点B发送请求,B接收处理请求并产生响应结果返回给A。服务通信更适用于对时时性有要求、具有一定逻辑处理的应用场景。

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

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


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

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

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


【ROS】—— ROS通信机制——服务通信(三)_第1张图片

整个流程由以下步骤实现:
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 的 TCP 地址信息。

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

4.Server发送响应
Server 接收、解析请求的数据,并产生响应结果返回给 Client。

注意:

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

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

ps:话题通信是单向式的,listener是被动的接受数据;服务通信是应答式的,只有客户端发布相关请求,服务端才会进行相关应答,给出消息。

2. 服务通信自定义srv

srv = 请求 +相应

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

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

2.1 定义srv文件

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

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

2.2 编辑配置文件

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

  <build_depend>message_generationbuild_depend>
  <exec_depend>message_runtimeexec_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
)

2.3 编译

编译后的中间文件查看:

C++ 需要调用的中间文件(…/工作空间/devel/include/包名/xxx.h)【ROS】—— ROS通信机制——服务通信(三)_第2张图片

Python 需要调用的中间文件(…/工作空间/devel/lib/python3/dist-packages/包名/srv)【ROS】—— ROS通信机制——服务通信(三)_第3张图片

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

流程:

  • 编写服务端实现;
  • 编写客户端实现;
  • 编辑配置文件;
  • 编译并执行。

3.1 vscode配置

与之前的配置方式一致(若之前的工作空间配置过则不用更改)。【ROS】—— ROS通信机制——话题通信(二)

3.2 服务端

#include "ros/ros.h"
#include "publisher/addints.h"
/*
    需求: 
        编写两个节点实现服务通信,客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据,相加后,将结果响应回客户端,
        客户端再解析

    服务器实现:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建 ROS 句柄
        4.创建 服务 对象
        5.回调函数处理请求并产生响应
        6.由于请求有多个,需要调用 ros::spin()

*/

//回调函数处理请求并产生响应
bool donums(publisher::addints::Request &request,
                             publisher::addints::Response &response)
{
    //1.处理请求
    int num1 = request.num1;
    int num2 = request.num2;
    ROS_INFO("收到的请求:num1 = %d, num2=%d",num1,num2);
    //逻辑处理
    if (num1 < 0 || num2 < 0)
    {
        ROS_ERROR("提交的数据异常:数据不可以为负数");
        return false;
    }
    //2.组织响应
    int sum = num1 +num2;
    response.sum = sum;
    ROS_INFO("求得的结果: sum = %d",sum);
    return true;
}
int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ROS_INFO("服务端启动");
    //初始化 ROS 节点
    ros::init(argc,argv,"server");
    //创建 ROS 句柄
    ros::NodeHandle nh;
    //创建 服务 对象
    ros::ServiceServer server = nh.advertiseService("addints",donums);
    // 由于请求有多个,需要调用 ros::spin()
    ros::spin();
    return 0;
}

rosrun启动服务端后,可以通过rosservice进行测试。

 rosservice call /addints "num1: 2
num2: 4" 

结果
在这里插入图片描述

3.3 客户端

#include "ros/ros.h"
#include "publisher/addints.h"
/*
    需求: 
        编写两个节点实现服务通信,客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据,相加后,将结果响应回客户端,
        客户端再解析

    服务器实现:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建 ROS 句柄
        4.创建 客户端 对象
        5.请求服务,接收响应

*/

int main(int argc, char  *argv[])
{
    setlocale(LC_ALL,"");
    //初始化 ROS 节点
    ros::init(argc,argv,"client");
    //创建 ROS 句柄
    ros::NodeHandle nh;
    //创建客户端对象
    ros::ServiceClient client = nh.serviceClient<publisher::addints>("addints");
    //提交请求并处理响应
    publisher::addints add; 
    //组织请求
    add.request.num1  = 100;
    add.request.num2 = 200;
    //处理响应
    bool flag = client.call(add);
    // 7.处理响应
    if (flag)
    {
        ROS_INFO("请求正常处理,响应结果:%d",add.response.sum);
    }
    else
    {
        ROS_ERROR("请求处理失败....");
        return 1;
    }

    return 0;
}

【ROS】—— ROS通信机制——服务通信(三)_第4张图片动态方式提交请求

#include "ros/ros.h"
#include "publisher/addints.h"
/*
    需求: 
        编写两个节点实现服务通信,客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据,相加后,将结果响应回客户端,
        客户端再解析

    服务器实现:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建 ROS 句柄
        4.创建 客户端 对象
        5.请求服务,接收响应

*/

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;
    }
    //初始化 ROS 节点
    ros::init(argc,argv,"client");
    //创建 ROS 句柄
    ros::NodeHandle nh;
    //创建客户端对象
    ros::ServiceClient client = nh.serviceClient<publisher::addints>("addints");
    //等待请求
    ros::service::waitForService("addints");
    //提交请求并处理响应
    publisher::addints add; 
    //组织请求
    add.request.num1  = atoi(argv[1]);
    add.request.num2 = atoi(argv[2]);
    //处理响应
    bool flag = client.call(add);
    // 7.处理响应
    if (flag)
    {
        ROS_INFO("请求正常处理,响应结果:%d",add.response.sum);
    }
    else
    {
        ROS_ERROR("请求处理失败....");
        return 1;
    }

    return 0;
}

【ROS】—— ROS通信机制——服务通信(三)_第5张图片注意:
看看这个代码if (argc != 3),为什么argc需要是3个参数呢?
原因:第一个参数argc[0]是程序的名称,第二个参数argc[1]、第三个参数argc[2]才是传入的参数。

3.4 配置 CMakeLists.txt

add_executable(AddInts_Server src/AddInts_Server.cpp)
add_executable(AddInts_Client src/AddInts_Client.cpp)

add_dependencies(AddInts_Server ${PROJECT_NAME}_gencpp)
add_dependencies(AddInts_Client ${PROJECT_NAME}_gencpp)

target_link_libraries(AddInts_Server
  ${catkin_LIBRARIES}
)
target_link_libraries(AddInts_Client
  ${catkin_LIBRARIES}
)

流程:
需要先启动服务:rosrun 包名 服务
然后再调用客户端 :rosrun 包名 客户端 参数1 参数2

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

注意:
如果先启动客户端,那么会导致运行失败

优化:
在客户端发送请求前添加:client.waitForExistence();
或:ros::service::waitForService("AddInts");
这是一个阻塞式函数,只有服务启动成功后才会继续执行
此处可以使用 launch 文件优化,但是需要注意 args 传参特点

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

流程:

  1. 编写服务端实现;
  2. 编写客户端实现;
  3. 为python文件添加可执行权限;
  4. 编辑配置文件;
  5. 编译并执行。

4.1 vscode配置

与之前的配置方式一致(若之前的工作空间配置过则不用更改)。【ROS】—— ROS通信机制——话题通信(二)

4.2 服务端

#! /usr/bin/env python
#-- coding:UTF-8 --

import rospy
from publisher.srv import addints, addintsRequest, addintsResponse
"""
    需求: 
        编写两个节点实现服务通信,客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据,相加后,将结果响应回客户端,
        客户端再解析

    服务器端实现:
        1.导包
        2.初始化 ROS 节点
        3.创建服务对象
        4.回调函数处理请求并产生响应
        5.spin 函数

"""
#参数:封装了请求数据
#返回值:响应数据
def donum(request):
    num1 = request.num1
    num2 = request.num2

    sum = num1 + num2
    response = addintsResponse()
    response.sum = sum
    rospy.loginfo("提交的数据:num1 = %d, num2 = %d, sum = %d",request.num1, request.num2, sum)
    return response

if __name__ == "__main__" :
    # 初始化 ROS 节点
    rospy.init_node("server")
    # 创建服务对象    
    server = rospy.Service("addints",addints,donum)
    rospy.loginfo("启动服务端")
    rospy.spin()

同样测试一下
【ROS】—— ROS通信机制——服务通信(三)_第6张图片

4.3 客户端

#! /usr/bin/env python
#-- coding:UTF-8 --

import rospy
from publisher.srv import addints, addintsRequest, addintsResponse
import sys
"""
    需求: 
        编写两个节点实现服务通信,客户端节点需要提交两个整数到服务器
        服务器需要解析客户端提交的数据,相加后,将结果响应回客户端,
        客户端再解析

    客户端实现:
        1.导包
        2.初始化 ROS 节点
        3.创建请求对象
        4.发送请求
        5.接收并处理响应

    优化:
        加入数据的动态获取


"""
if __name__ == "__main__":

    #优化实现
    if len(sys.argv) != 3:
        rospy.logerr("请正确提交参数")
        sys.exit(1)


    # 2.初始化 ROS 节点
    rospy.init_node("addInts_Client_p")
    # 3.创建请求对象
    client = rospy.ServiceProxy("addints",addints)
    # 请求前,等待服务已经就绪
    # 方式1:
    # rospy.wait_for_service("addInts")
    # 方式2
    client.wait_for_service()
    # 4.发送请求,接收并处理响应
    # 方式1
    # resp = client(3,4)
    # 方式2
    # resp = client(AddIntsRequest(1,5))
    # 方式3
    req = addintsRequest()
    # 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)

之后记得给文件执行权限
【ROS】—— ROS通信机制——服务通信(三)_第7张图片

4.4 配置 CMakeLists.txt

catkin_install_python(PROGRAMS
  scripts/AddInts_Server_p.py 
  scripts/AddInts_Client_p.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

你可能感兴趣的:(ROS,机器人,github,自动驾驶)