Publisher

A publisher is a node that broadcasts messages on a topic. It has to do the following:

• Register with the ROS server running on the machine (the active roscore session at the time). This is done using initialization of the node itself.
• Have a NodeHandler defined.
  • This object takes care of all the communication with the ROS server.
    • For nodes written in python, this happens in the background so you don't need to declare it.
    • For nodes written in C++, this needs to be declared
• Tell the ROS server that it's going to publish messages on the topic. The topic name and the message type (data type or name of the message) must be specified. This is called advertising.
  • This yields an object that we'll use to publish messages.

Subscriber

A subscriber is a node that receives the broadcasted messages on a topic. It's basically like a listener. It has to do the following:

• Register with the ROS server running on the machine (the active roscore session at the time). This is done using initialization of the node itself.
• Have a NodeHandler defined.
  • This object takes care of all the communication with the ROS server.
    • For nodes written in python, this happens in the background so you don't need to declare it.
    • For nodes written in C++, this needs to be declared
• Tell the ROS server that it wants to subscribe to a topic. Furthermore, it must have a function that's invoked when a message is received.
  • We'll see how to deal with the message being parsed when we're coding the nodes.

Creating Publishers and Subscribers

Let's create a publisher that publishes a number (of message type std_msgs/Float64) and a subscriber that listens to those. We'll let the topic name be /floating_numbers. We'll publish two messages a second here, but you could pick any rate (or choose not to publish in a rate).

C++

Publisher

The file name is "NumberPublisher.cpp". The following is the manner in which it is programmed:

1. Include the header file for ROS and the message.
2. Declare the main function.
3. Initialize the ROS node using ros::init function.
4. Create a NodeHandler instance (object) that will handle all communications with the server while it's running
5. Create a Publisher object that will be used to publish messages. Check out the code through the link (or scroll below) to see how it's called. We call the advertise member function through the node handler object. It's main parts are:
   • It needs to be given the message type as a generic.
   • Pass it the topic name as a "floating_numbers" (no '/').
   • The queue size, how many outgoing messages are stored in the queue.
   • Latching parameter (false by default). When a connection is latched, the last message published is saved and automatically sent to any future subscribers that connect. In this way, new subscribers don't miss the previous messages.
6. Declare a rate object, in case if we want to publish at a rate.
   • This is nothing to do with the publisher, actually. It's just going to create a delay of some time in a loop. For example, if rate is 2Hz, it manages a delay such that every loop iteration we stop nearly for 500 ms (two messages in a loop).
7. Create a while loop that will continuously publish messages, we'll use the sleep function in the end of the loop.
8. Create a message object that will be published on the topic.
   • Most of the objects have a data member which carries the information.
9. Publish the message through the publisher object that we created in step 5.
10. End the loop with the sleep function of the rate handler object.

Subscriber

The file name is "NumberSubscriber.cpp". The following is the manner in which it is programmed:

1. Include the header files for ROS and messages and declare the main function.
2. Define a caller function that gets called everytime a message is received. Make sure that the only function argument it has is a constant pointer of the message type. This avoids data duplication, thus reducing latency and increasing performance.
3. In the main function, write code for the following
   • Initialize the node using the init function.
   • Create a NodeHandler object
   • Subscribe to the topic using the node handler that we created
4. In the end of main function, we call ros::spin(). This function hands over control to the ROS framework to listen to messages and call functions if one is received.
   • There may be cases when we can't do that, in such cases, we use the ros::spinOnce function which checks all subscribed topics once and then returns back control to the program. This is particularly helpful when we need to create nodes that subscribe and do something else at the same time.
5. In the caller function, we write code that must be executed when we receive a message of the given type. Here, we'll just print it as an INFO message.

Building the C++ nodes

1. Open the "CMakeLists.txt" file in intro_pkg1 package folder.
2. Write code for the add_executable function.
   • Declare the executable.
3. Write code for the target_link_libraries function
   • Link the catkin_LIBRARIES to the executable.
4. Save the file
5. Call catkin_make on the workspace home directory

Running the C++ nodes

1. Open a terminal and start the roscore
2. Run the following commands:
   • rosrun intro_pkg1 NumberPublisher
     • This runs the publisher node
   • rostopic echo /floating_numbers
     • This will show whatever is being published on the topic. You can kill it using 'Ctrl + C' after observing the output.
   • rosrun intro_pkg1 NumberSubscriber
     • This runs the subscriber node

Python

Publisher

The file name is "NumberPublisher.py". It has been programmed in the following manner:

1. Import the rospy library and the message class
2. Initialize the node using init_node function.
3. Create a publisher object using Publisher class.
4. Create a rate handler, if you're publishing the message periodically. Use the Rate class to generate and maintain periodicity.
5. Create a while loop till ROS is working (not shutdown)
6. Create a message object and then load it with data
7. Publish the message object
8. Use the rate handler to create the delay

Subscriber

The file name is "NumberSubscriber.py". It has been programmed in the following manner:

1. Initialize the node
2. Create an object of Subscriber class.
   • Create a callback function that receives the message as argument
   • Write all code inside that function
   • Give that function as parameter to the constructor
3. Hand over ROS the control of the node using spin. This will get the node into "scanning mode". Whenever the messages are received, the respective callback function is called.

Running the Python nodes

1. Open a terminal and cd into the scripts folder of your package using
   • roscd intro_pkg1/scripts
2. Use chmod to change the access modes of all python scripts
   • chmod +x *.py
3. Run the nodes using rosrun command
   • rosrun intro_pkg1 NumberPublisher.py
     • Runs the publisher node
   • rosrun intro_pkg1 NumberSubscriber.py
     • Runs the subscriber node

Codes for Python Publisher and Subscriber

Additional

• You'll also notice that you can run the publisher made using C++ and subscriber made using python (or the vice versa) and they interact just fine. This is the beauty of ROS, you can develop things separately in isolation and they work together seamlessly. The communication is all handled in the back-end, so you take care of only the front-end.
• ROS uses it's own set of protocols made over open protocols for communication between nodes
  • TCPROS (made over TCP)
  • UDPROS (made over UDP)