4、 Service communication principle, code implementation

1、 Principle of service communication

0. Server register
   Server After starting , Will pass RPC The agreement Master Register your address and services in （ topic of conversation ）
1. Client register
   Client After starting , Will be in Master Register the services you need in （ topic of conversation ）
2. matching
   Master Match topics according to the registry , And will Server Of TCP Address through RPC The agreement is sent to Client
3. Client Send a request
   Client received TCP After the address , adopt TCP Deal with the Server Establishing a connection , Send request data
4. Server Send corresponding
   Server On request , Send results
   Be careful :
   In topic communication , Because it adopts subscription , There is no requirement for the sequence before and after the start of both parties . however , In service communication , Due to the way of request response , So start it first Server, Restart Client

2、 Service communication customization srv

1. In service communication ,srv The document is divided into two parts ： Client and server , In topic communication ,msg Only part of the document , Create... Under the function pack srv Catalog , Add... Below it xxx.srv file ：

   # client 
   int32 num1
   int32 num2
   ---
   # Server side 
   int32 sum
   

   Be careful ： Between the client and the server — Division
2. Edit profile
   1. package.xml

      <build_depend>message_generation</build_depend>
      <exec_depend>message_runtime</exec_depend>
      <!-- exce_depend  It used to correspond to  run_depend  Now illegal  -->
      

   2. CmakeLists.txt

      find_package(catkin REQUIRED COMPONENTS
      roscpp
      rospy
      std_msgs
      message_generation
      )
      #  Need to add  message_generation, There has to be  std_msgs
      

      add_service_files(
      FILES
      AddInts.srv
      )
      

      generate_messages(
      DEPENDENCIES
      std_msgs
      )
      

   3. compile
      The corresponding middleware will be generated after compilation , Include C++ Medium .h Document and Python Medium .py file

3、 Code implementation

1.C++ Realization

0. vscode To configure , stay C++ in , Need configuration c_cpp_properies.json file , Mainly "includePath" Path settings , If not set , The generated .h file , In the process of typing code , There is no corresponding prompt

   {
         
      "configurations": [
         {
         
               "browse": {
         
                  "databaseFilename": "",
                  "limitSymbolsToIncludedHeaders": true
               },
               "includePath": [
                  "/opt/ros/noetic/include/**",
                  "/usr/include/**",
                  "/xxx/yyy working space /devel/include/**" // To configure  head  Path to file  
               ],
               "name": "ROS",
               "intelliSenseMode": "gcc-x64",
               "compilerPath": "/usr/bin/gcc",
               "cStandard": "c11",
               "cppStandard": "c++17"
         }
      ],
      "version": 4
   }
   

1. Server side

   //1. Include header file 
   #include"ros/ros.h"
   // Path is :  Function pack / The header file 
   #include"server_client/add.h"
   
   // Callback function , Perform relevant service operations , The return value is of Bohr type 
   bool doReq(server_client::add::Request &req,
               server_client::add::Response &resp){
         
                  int num1 = req.num1;
                  int num2 = req.num2;
   
                  ROS_INFO(" The data received by the server is ：num1 = %d,num2 = %d",num1,num2);
   
                  if(num1 < 0 || num2 < 0){
         
                     ROS_ERROR(" Data error ！");
                     return false;
                  }
                  resp.sum = num1 + num2;
                  return true;
   
               }
   int main(int argc, char *argv[]){
         
      setlocale(LC_ALL,"");
      //2. initialization ROS node 
      ros::init(argc,argv,"server");//server Name the node 
      //3. establish ROS Handle 
      ros::NodeHandle nh;
      //4. Create service object ,add_int For the topic 
      ros::ServiceServer server = nh.advertiseService("add_int",doReq);//add_int Name the topic 
      ROS_INFO(" Service startup ");
      //5. The callback function processes the request and generates a response 
      //6.spin function , Without this function , The node will stop immediately after starting 
      ros::spin();
      return 0;
   }
   

   Test after service startup ：
   rosservice call Topic name + Space + Tab Key to complete the parameters , Then modify the corresponding parameters . Be careful , During the test , Confirm that the server has started , And hang , Otherwise, there will be no corresponding topic
2. client

   //1. Include header file 
   #include"ros/ros.h"
   #include"server_client/add.h"
   
   int main(int argc, char *argv[]){
         
      setlocale(LC_ALL,"");
      // stay launch In file , Parameter is 5 individual 
      //argc Represents the number of parameters passed 
      //argv Store the corresponding parameters ： 0： The node name  1： The first parameter  2： The second parameter 
      if(argc != 3){
         
         ROS_ERROR(" Please submit two integers ！");
         return 1;
      }
      //2. initialization ros node 
      ros::init(argc,argv,"client");
      //3. establish ROS Handle 
      ros::NodeHandle nh;
      //4. Create client objects , Submit the desired service 
      ros::ServiceClient client = nh.serviceClient<server_client::add>("add_int");
      /* In service communication , You need to start the server first , Have you got anything to do , For the convenience of the project , You can use the wait function ,  In this way, you can start the client first , Wait for the server to start */
      // The way 1
      ros::service::waitForService("add_int");
      // The way 2
      // client.waitForExistence();
      //5. Organization request data 
      server_client::add ai;
      ai.request.num1 = atoi(argv[1]);
      ai.request.num2 = atoi(argv[2]);
      //6. Send a request , return bool value , Success is true 
      bool flag = client.call(ai);
      if (flag){
         
         ROS_INFO(" Request OK , The result is ：%d, %s, %s, %s",ai.response.sum,argv[0],argv[1],argv[2]);
      }
      else{
         
         ROS_INFO(" request was aborted ！");
         return 1;
      }
      return 0;
   }
   

3. To configure 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}
   )
   

4. perform
   1. Start the service

      rosrun  Package name   service name 
      

   2. Start the customer

      rosrun  Package name   Customer name   Parameters 1  Parameters 2
      

2.Python Realization

0. vscode To configure , stay Python in , Need configuration setting.json file , Supplement of parameters

   {
         
    "python.autoComplete.extraPaths": [
        "/opt/ros/noetic/lib/python3/dist-packages",
    ]
   }
   

1. Server side

   #! /usr/bin/env python
   
   #1.  Guide pack 
   import rospy
   # From the function pack srv File import the corresponding data type 
   from server_client.srv import add, addRequest, addResponse
   
   #req Parameters can be named casually , It's a class , But its element must be srv Parameters in 
   def doReq(req):
      #num1 num2 by srv Data types defined in 
      sum = req.num1 + req.num2
      rospy.loginfo(" result ：%d",sum)
      resp = addResponse(sum)
   
      # The callback function returns the response result 
      return resp
   
   if __name__ == "__main__":
   
      #2. initialization ROS node   Note that the node name is unique 
      rospy.init_node("server_p")
   
      #3. Create service object  
      # add_int_p Name the topic  add Is the data type  
      # doReq Is the callback function , Its data type is srv Data types in 
      server = rospy.Service("add_int_p",add,doReq)
   
      #4. The callback function processes the request and generates a response 
      
      #5.spin function 
      rospy.spin()
   

2. client

   #! /usr/bin/env python
   #1. Guide pack 
   import rospy
   from server_client.srv import *
   import sys 
   
   if __name__ == "__main__":
   
      if len(sys.argv) != 3:
         rospy.logerr(" Please enter the correct parameters ！")
         sys.exit
   
      #2. initialization ROS node 
      rospy.init_node("client_p")
   
      #3. Create request object  
      # add_int_p For the topic , The same as the server 
      # add Is the data type 
      client = rospy.ServiceProxy("add_int_p",add)
   
      rospy.wait_for_service("add_int_p")
      # client.wait_for_service()
   
      #4. Send a request , Accept and deal with the corresponding 
      # The way 1
      #resp = client(3,4)
   
      # The way 2
      #resp = client(addRequest(1,2))
      
      # The way 3
      req = addRequest()
      req.num1 = int(sys.argv[1])
      req.num2 = int(sys.argv[2])
   
      resp = client.call(req)
      rospy.loginfo(" The result is ：%d",resp.sum)
   

3. Add executable rights
   stay scripts Under the folder , perform ：chmod +x *.py
4. To configure CMakeLists.txt file

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

5. perform
   • Server side ：rosrun Package name service
   • client ：rosrun Package name Customer Parameters 1 Parameters 2
     Be careful ： Service and customers are .py file