古月居ROS2学习笔记：服务通讯模型_ros2 通讯模型

       话题通讯（topic）可以有n个发布者，n个订阅者，可以实现一对多，多对多的通信，适合传输一些逻辑性不强，定时发送的信息，例如传感器检测的数据和图像，定时发布的运动指令。在编写代码的时候要创建发布者（self.create_publisher）和订阅者(self.create_subscription),并且都用到了回调函数，一般来说，发布者用到了时间回调函数，订阅者收到消息（msg）后触发回调函数。

        ROS另外一种常用的通信方法——服务，可以实现类似你问我答的同步通信效果。

客户端（client）/服务器(server)模型

  从服务的实现机制上来看，这种你问我答的形式叫做客户端/服务器模型，简称为CS模型，客户端在需要某些数据的时候，针对某个具体的服务，发送请求信息，服务器端收到请求之后，就会进行处理并反馈应答信息。

特点：

1.同步通信

      这个过程一般要求越快越好，假设服务器半天没有反应，你的浏览器一直转圈圈，那有可能是服务器宕机了，或者是网络不好，所以相比话题通信，在服务通信中，客户端可以通过接收到的应答信息，判断服务器端的状态，我们也称之为同步通信

2.一对多通信

比如古月居这个网站，服务器是唯一存在的，并没有多个完全一样的古月居网站，但是可以访问古月居网站的客户端是不唯一的，大家每一个人都可以看到同样的界面。所以服务通信模型中，服务器端唯一，但客户端可以不唯一。

服务接口

和话题通信类似，服务通信的核心还是要传递数据，数据变成了两个部分，一个请求的数据，比如请求苹果位置的命令，还有一个反馈的数据，比如反馈苹果坐标位置的数据，这些数据和话题消息一样，在ROS中也是要标准定义的，话题使用.msg文件定义，服务使用的是.srv文件定义，后续我们会给大家介绍定义的方法。

求和器

客户端（client）：

import sys
import rclpy
from rclpy.node import Node
from learning_interface.srv import AddTwoInts  #自定义的服务接口
 
 
class AdderClient(Node):
    def __init__(self,name):
        super().__init__(name)
        self.client=self.create_client(AddTwoInts,'add_two_ints') #创建一个客户端（服务器接口类型，客户端名字）
        whlie not client.wait_for_service(timeout_sec=1.0):
            self.getlogger().info('service not availiable, waiting again...')
        self.request=AddTwoInts.Request()    #创建服务请求的数据对象  
    def send_request(self):
        self.request.a= int (sys.argv[1])
        self.request.b= int (sys.argv[2])
        self.future=self.client.call_async(self.request)  #异步方式发送服务请求
 
 
def main(args=None):
    rclpy.init(args=args)
    node=AdderClient('servive_adder_client')
    node.send_request
    while rclpy.ok():
        rclpy.spin_once(node)   #循环执行一次节点
        if node.future.done():  #数据是否处理完成
            try 
                response =node.future.result()
            except Exception as e:
                node.get_logger().info('Service call failed %r',%(e,))
            else
                node.get_logger().info('Result of add_two_ints: for %d + %d = %d',%(node.request.a,node.request.b,response.sum))
            break
    node.destroy_node()
    rclpy.shutdown()

服务端

import rclpy                                     # ROS2 Python接口库
from rclpy.node   import Node                    # ROS2 节点类
from learning_interface.srv import AddTwoInts    # 自定义的服务接口
 
class adderServer(Node):
    def __init__(self, name):
        super().__init__(name)                                                           # ROS2节点父类初始化
        self.srv = self.create_service(AddTwoInts, 'add_two_ints', self.adder_callback)  # 创建服务器对象（接口类型、服务名、服务器回调函数）
 
    def adder_callback(self, request, response):   # 创建回调函数，执行收到请求后对数据的处理
        response.sum = request.a + request.b       # 完成加法求和计算，将结果放到反馈的数据中
        self.get_logger().info('Incoming request\na: %d b: %d' % (request.a, request.b))   # 输出日志信息，提示已经完成加法求和计算
        return response                          # 反馈应答信息
 
def main(args=None):                             # ROS2节点主入口main函数
    rclpy.init(args=args)                        # ROS2 Python接口初始化
    node = adderServer("service_adder_server")   # 创建ROS2节点对象并进行初始化
    rclpy.spin(node)                             # 循环等待ROS2退出
    node.destroy_node()                          # 销毁节点对象
    rclpy.shutdown()                             # 关闭ROS2 Python接口

注意一个小细节，只有客户端创建了具体的数据对象（可能因为要具体赋值），在服务端没有创建具体对象，在回调函数的输入参数中有输入和输出（self，request，response），应该是和自定义接口的格式有关，回调函数有返回值（一问一答）。

案例2 机器视觉案例

结构如下：

节点1：相机节点，话题（topic）模型，发布者，发布图像话题（publisher）。

节点2：图像处理模块，负责接收先图像，订阅者（subscription），负责轮廓识别并找到坐标，同时作为服务端，负责随时向客户端发送位置(server)

节点3：客户端，向服务端发起请求，收到位置消息client。

客户端代码

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
"""
@作者: 古月居(www.guyuehome.com)
@说明: ROS2服务示例-请求目标识别，等待目标位置应答
"""
 
import rclpy                                            # ROS2 Python接口库
from rclpy.node   import Node                           # ROS2 节点类
from learning_interface.srv import GetObjectPosition    # 自定义的服务接口
 
class objectClient(Node):
    def __init__(self, name):
        super().__init__(name)                          # ROS2节点父类初始化
        self.client = self.create_client(GetObjectPosition, 'get_target_position')
        while not self.client.wait_for_service(timeout_sec=1.0):
            self.get_logger().info('service not available, waiting again...')
        self.request = GetObjectPosition.Request()
 
    def send_request(self):
        self.request.get = True
        self.future = self.client.call_async(self.request)
 
def main(args=None):
    rclpy.init(args=args)                             # ROS2 Python接口初始化
    node = objectClient("service_object_client")      # 创建ROS2节点对象并进行初始化
    node.send_request()
 
    while rclpy.ok():
        rclpy.spin_once(node)
 
        if node.future.done():
            try:
                response = node.future.result()
            except Exception as e:
                node.get_logger().info(
                    'Service call failed %r' % (e,))
            else:
                node.get_logger().info(
                    'Result of object position:\n x: %d y: %d' %
                    (response.x, response.y))
            break
    node.destroy_node()                              # 销毁节点对象
    rclpy.shutdown()                                 # 关闭ROS2 Python接口

服务端代码

import rclpy                                           # ROS2 Python接口库
from rclpy.node import Node                            # ROS2 节点类
from sensor_msgs.msg import Image                      # 图像消息类型
import numpy as np                                     # Python数值计算库
from cv_bridge import CvBridge                         # ROS与OpenCV图像转换类
import cv2                                             # Opencv图像处理库
from learning_interface.srv import GetObjectPosition   # 自定义的服务接口
 
lower_red = np.array([0, 90, 128])     # 红色的HSV阈值下限
upper_red = np.array([180, 255, 255])  # 红色的HSV阈值上限
 
class ImageSubscriber(Node):
    def __init__(self, name):
        super().__init__(name)                              # ROS2节点父类初始化
        self.sub = self.create_subscription(
            Image, 'image_raw', self.listener_callback, 10) # 创建订阅者对象（消息类型、话题名、订阅者回调函数、队列长度）
        self.cv_bridge = CvBridge()                         # 创建一个图像转换对象，用于OpenCV图像与ROS的图像消息的互相转换
 
        self.srv = self.create_service(GetObjectPosition,   # 创建服务器对象（接口类型、服务名、服务器回调函数）
                                       'get_target_position',
                                       self.object_position_callback)    
        self.objectX = 0
        self.objectY = 0                              
 
    def object_detect(self, image):
        hsv_img = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)      # 图像从BGR颜色模型转换为HSV模型
        mask_red = cv2.inRange(hsv_img, lower_red, upper_red) # 图像二值化
        contours, hierarchy = cv2.findContours(
            mask_red, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)   # 图像中轮廓检测
 
        for cnt in contours:                                  # 去除一些轮廓面积太小的噪声
            if cnt.shape[0] < 150:
                continue
 
            (x, y, w, h) = cv2.boundingRect(cnt)              # 得到苹果所在轮廓的左上角xy像素坐标及轮廓范围的宽和高
            cv2.drawContours(image, [cnt], -1, (0, 255, 0), 2)# 将苹果的轮廓勾勒出来
            cv2.circle(image, (int(x+w/2), int(y+h/2)), 5,
                       (0, 255, 0), -1)                       # 将苹果的图像中心点画出来
 
            self.objectX = int(x+w/2)
            self.objectY = int(y+h/2)
 
        cv2.imshow("object", image)                            # 使用OpenCV显示处理后的图像效果
        cv2.waitKey(50)
 
    def listener_callback(self, data):
        self.get_logger().info('Receiving video frame')        # 输出日志信息，提示已进入回调函数
        image = self.cv_bridge.imgmsg_to_cv2(data, 'bgr8')     # 将ROS的图像消息转化成OpenCV图像
        self.object_detect(image)                              # 苹果检测
 
    def object_position_callback(self, request, response):     # 创建回调函数，执行收到请求后对数据的处理
        if request.get == True:
            response.x = self.objectX                          # 目标物体的XY坐标
            response.y = self.objectY
            self.get_logger().info('Object position\nx: %d y: %d' %
                                   (response.x, response.y))   # 输出日志信息，提示已经反馈
        else:
            response.x = 0
            response.y = 0
            self.get_logger().info('Invalid command')          # 输出日志信息，提示已经反馈
        return response
 
 
def main(args=None):                                 # ROS2节点主入口main函数
    rclpy.init(args=args)                            # ROS2 Python接口初始化
    node = ImageSubscriber("service_object_server")  # 创建ROS2节点对象并进行初始化
    rclpy.spin(node)                                 # 循环等待ROS2退出
    node.destroy_node()                              # 销毁节点对象
    rclpy.shutdown()                                 # 关闭ROS2 Python接口