ROS2: 服务通信

服务通信模型

 服务通信模型如上图所示，分为服务端和客户端，客户端根据需要向服务端发送请求（Request），服务端处理请求，并向客户端发回响应（Response）。一个服务端对应有多个客户端，并且消息的流向是双向的。

服务通信的C++实现

服务端

 首先明确服务端的工作流程：服务端创建后被挂起，直到收到客户端请求后执行对应的任务，并返回响应结果

1. 依赖

#include "rclcpp/rclcpp.hpp" //标准库
#include "自定义接口文件/srv/xxx.hpp" //消息接口库
using 自定义接口文件::srv::xxx; //命名空间

2. 实现流程

1、节点类中声明服务端对象指针。
2、节点构造函数中创建服务端对象，并绑定回调函数。
3、 在回调函数中处理请求数据，并返回响应。

3. 代码模板

#include "rclcpp/rclcpp.hpp"
#include "自定义节点包/srv/自定义消息.hpp"
using 自定义节点包::srv::自定义消息;
using namespace std::placeholders;

class My_Service : public rclcpp::Node{
private:
   rclcpp::Service<消息类型>::SharedPtr service_; //1、节点类中声明服务端对象指针。
   
   void srv_callback(const 自定义消息::Request::SharedPtr req,const 自定义消息::Response::SharedPtr res)//3、在回调函数中处理请求数据，并返回响应。
   { 
   	req->xxx; //请求数据解析
    res->xxx= XXX; //响应数据发送
   }
public:
   My_Service():Node("test_service_node"){
   service_ = this->create_service<消息类型>("服务名",std::bind(&My_Service::srv_callback,this,_1,_2));//2、节点构造函数中创建服务端对象，并绑定回调函数。
   }

};

int main(int argc,char* argv[]){
   rclcpp::init(argc,argv);
   rclcpp::spin(std::make_shared<消息类型>()); //循环执行服务
   rclcpp::shutdown();
   return 0;
}

客户端

 客户端的工作流程：客户端创建后择机发送请求数据，然后等待客户端返回响应信息。

1. 依赖

#include "rclcpp/rclcpp.hpp" //标准库
#include "自定义接口文件/srv/xxx.hpp" //消息接口库
using 自定义接口文件::srv::xxx; //命名空间

2. 实现流程

1、节点类中声明客户端对象指针。
2、节点构造函数中创建客户端对象。
3、 在调用客户端对象的发送方法，发送请求。
4、 阻塞等待返回结果，并解析Response数据

3. 代码模板

#include "rclcpp/rclcpp.hpp"
#include "based_interfaces/srv/myservice.hpp" //自定义接口文件
using based_interfaces::srv::Myservice; //使用自定义消息的数据类型

using namespace std::chrono_literals;

class My_Client : public rclcpp::Node{
private:
   rclcpp::Client<Myservice>::SharedPtr client_; //1、节点类中声明客户端对象指针。

public:
   My_Client():Node("test_client_node"){
       client_ = this->create_client<Myservice>("my_srv",10); //2、节点构造函数中创建客户端对象。
   }
   
//等待连接到服务端
   bool connect_srv(void){
       while(!client_->wait_for_service(1s)){
           if(!rclcpp::ok())
           {
               RCLCPP_INFO(rclcpp::get_logger("rclcpp"),"程序结束！");
               return false;
           }
           RCLCPP_INFO(this->get_logger(),"等待连接中");

       }
       RCLCPP_INFO(this->get_logger(),"连接成功");
       return true;
   }
//3、 在调用客户端对象的发送方法，发送请求。
   rclcpp::Client<Myservice>::FutureAndRequestId send_data(std::string message){
       auto request = std::make_shared<Myservice::Request>();
       request->request_msg = message;
       return client_->async_send_request(request);
   }

};


int main(int argc,char* argv[]){
   rclcpp::init(argc,argv);

   auto myclient = std::make_shared<My_Client>();
   if(myclient->connect_srv()){
       RCLCPP_INFO(rclcpp::get_logger("rclcpp"),"连接成功");
      // 4、 阻塞等待返回结果，并解析Response数据
       auto response = myclient->send_data(argv[1]);
       if(rclcpp::spin_until_future_complete(myclient,response)==rclcpp::FutureReturnCode::SUCCESS)
       {
           RCLCPP_INFO(rclcpp::get_logger("rclcpp"),"请求成功！");
           RCLCPP_INFO(rclcpp::get_logger("rclcpp"),"返回：%s！",response.get()->respone_msg.c_str());
       }else
           RCLCPP_INFO(rclcpp::get_logger("rclcpp"),"请求异常！");
   }
   else
       RCLCPP_INFO(rclcpp::get_logger("rclcpp"),"连接失败！");
   rclcpp::shutdown();
   return 0;
}

关键函数说明

1. 定义客户端与服务端对象

rclcpp::Service<消息类型>::SharedPtr service_;
rclcpp::Client<消息类型>::SharedPtr client_;

2. 服务端与客户端对象创建

==回调函数传入两个参数（请求与响应的指针）：const 自定义消息::Request::SharedPtr req,const 自定义消息::Response::SharedPtr res，顺序不可以搞错！==
service_ = this->create_service<消息类型>("服务名",std::bind(&My_Service::srv_callback,this,_1,_2));
//
client_ = this->create_client<消息类型>("服务名",10);

3. 服务端等待连接函数
   client->wait_for_service(xxs);相当于xx秒的阻塞延时，如果在这段时间内如果连接上服务就返回true,否则返回false。
4. 服务端发送数据函数
   auto response = client_->async_send_request(request);,其中response的类型为： rclcpp::Client<消息类型>::FutureAndRequestId。
   response.get()->xxx获取响应数据内容。
5. 客户端等待响应数据
   rclcpp::spin_until_future_complete(node_name,response),这里的response是async_send_request函数的返回值。
   函数返回值类型为rclcpp::FutureReturnCode，其下有SUCCESS, INTERRUPTED, TIMEOUT三种类型，分别代表不同的服务返回状态。