2、 Topic communication principle, code implementation

1、 Communication principle

The whole communication process is divided into six steps ,0-4 Step adoption RPC agreement ,5-6 Step adoption TCP agreement . Besides , The first step and the second step are in no order , But because of talker Registration takes time , The subscriber may not receive the first few messages , It can be solved by setting the delay .

0、talker register

talker adopt RPC Agreement to master Register node information ：

• Topic name ：bar
• RPC Address ：1234

1、listener register

listener adopt RPC Agreement to master Register your own information ：

• Topic name to subscribe to ：bar

2、ROS Master Realize information matching

ROS Master Match the information according to the registry , And pass RPC Agreement to listener send out talker Of RPC Address

3、Listener towards Talker Send a connection request

listener according to master Provided RPC Address , towards talker Send a connection request ：

• Subscribed topic name
• Message type
• Communication protocol （TCP/UDP）

4、Talker Confirm the request

talker After receiving the connection request, connect , adopt RPC Agreement to listener Confirm connection ：

• TCP Address

5、 Establishing a connection

listener According to the fourth No TCP Address establishment connection , here , If ROS Master close , The two can still establish a connection

6、Talker towards Listener Send a message

2、 Code implementation

1、C++ edition

1. Create a workspace and compile

    mkdir -p workspace/src // Create a workspace 
    cd workspace  // Enter the workspace 
    catkin_make  // compile , Generate devel and build Folder 
   

2. establish ROS Package and add dependencies

   cd src
   catkin_creat_pkg  Function package name  roscpp rospy std_msgs
   

3. C++ The source code to achieve

   //1. Include header file 
   #include "ros/ros.h"
   #include "std_msgs/String.h"// Used to define the type of transmission information 
   #include <sstream>
   
   int main(int argc, char *argv[]){
         
   
       setlocale(LC_ALL,"");// Prevent confusion code 
   
       //2. Node initialization 
       // The first two parameters are used to pass information , Which of the following is the node name , stay rqt_graph Unique identification 
       ros::init(argc,argv,"talker");
   
       //3. Create node handle 
       ros::NodeHandle nh;
   
       //4. Create a publishing object 
       // The first parameter is the published topic , The second parameter is the maximum number of messages saved , When it exceeds , The earliest messages will be deleted 
       ros::Publisher pub = nh.advertise<std_msgs::String>("chatter",10);
   
       //5. Organize published data 
       std_msgs::String msg;// Create data to publish 
       std::string msg_front = "hello  Hello! ！";
       int count = 0;
       ros::Rate r(1);// Set the data publishing rate 
       while(ros::ok()){
         
           std::stringstream ss;
           ss << msg_front << count;
           msg.data = ss.str();
           pub.publish(msg);// Release the news 
           ROS_INFO(" Message sent ：%s",msg.data.c_str());
           r.sleep();
           count++;
           ros::spinOnce();
       }
   
       return 0;
   }
   

   //1. Include header file 
   #include "ros/ros.h"
   #include "std_msgs/String.h"
   
   void doMsg(const std_msgs::String::ConstPtr&msg_p){
         
       ROS_INFO(" I hear ：%s",msg_p->data.c_str());
   }
   
   int main(int argc, char *argv[]){
         
       
       setlocale(LC_ALL,"");
   
       //2. Initialize node 
       ros::init(argc,argv,"listener");
   
       //3. establish ROS Handle 
       ros::NodeHandle nh;
   
       //4. Instantiate the subscription object , Including topic name , The length of the message , Callback function 
       ros::Subscriber sub = nh.subscribe<std_msgs::String>("chatter",10,doMsg);
       
       //5. Process subscribed messages 
       //6. Set loop call callback function 
       ros::spin();
       return 0;
   }
   

4. Configure the file and compile

   add_executable(Hello_pub
   src/Hello_pub.cpp
   )
   add_executable(Hello_sub
   src/Hello_sub.cpp
   )
   
   target_link_libraries(Hello_pub
   ${
         catkin_LIBRARIES}
   )
   target_link_libraries(Hello_sub
   ${
         catkin_LIBRARIES}
   )
   

5. Compile and run

   cd  working space 
   catkin_make
   roscore
   cd  working space 
   source ./devel/setup.bash
   rosrun  Package name   The node name 
   

2、Python edition

1. establish sripts Folder
2. Code implementation

   #! /usr/bin/env python
   
   #1. Guide pack 
   import rospy
   from std_msgs.msg import String # Packages that define data types 
   
   if __name__ == "__main__":
       #2. initialization ROS node 
       rospy.init_node("talker_p")# Unique node name , Otherwise, an error will be reported 
       #3. Instantiate the publisher object 
       pub = rospy.Publisher("chatter_p",String,queue_size=10)
       #4. Organize the release of data 
       msg = String()
       msg_font = "hello python"
       count = 0
       # Set the cycle frequency 
       rate = rospy.Rate(10)
       while not rospy.is_shutdown():
           msg.data = msg_font + str(count)
           pub.publish(msg)
           rate.sleep()
           rospy.loginfo("data:%s",msg.data)
           count += 1
   

    #! /usr/bin/env python
   
    #1. Guide pack 
    import rospy
    from std_msgs.msg import String
   
    def doMsg(msg):
        rospy.loginfo(" I hear ：%s",msg.data)
   
    if __name__ == "__main__":
        #2. initialization ROS node 
        rospy.init_node("listener_p")
        #3. Instantiate subscribers 
        sub = rospy.Subscriber("chatter",String,doMsg,queue_size=10)
        #4. Process subscribed messages 
        #5. Set loop call callback function 
        rospy.spin()
   

3. To configure Cmakelists.txt file

   catkin_install_python(PROGRAMS
   scripts/talker_p.py
   scripts/listener_p.py
   DESTINATION ${
         CATKIN_PACKAGE_BIN_DESTINATION}
   )
   

4. Run code

   cd  working space 
   catkin_make
   roscore
   source devel/setup.bash
   rosrun  Package name  .py