Publish-subscribe communication model in ROS

Introduction

The publish-subscribe model helps different parts of a robot system talk to each other without being directly connected. It makes communication easy and flexible.

When a sensor sends data to many parts of the robot that need it.

When you want to separate the part that creates data from the parts that use it.

When multiple programs need to listen to the same information at the same time.

When you want to add or remove parts without changing the whole system.

When you want to handle messages asynchronously, so parts work independently.

Syntax

ROS

import rospy
from std_msgs.msg import String

# Publisher node
rospy.init_node('talker')
publisher = rospy.Publisher('chatter', String, queue_size=10)
rate = rospy.Rate(10)  # 10 Hz

while not rospy.is_shutdown():
    message = "hello world"
    publisher.publish(message)
    rate.sleep()

# Subscriber node
def callback(data):
    rospy.loginfo(f"I heard {data.data}")

rospy.init_node('listener')
subscriber = rospy.Subscriber('chatter', String, callback)
rospy.spin()

The publisher sends messages to a named topic.

The subscriber listens to that topic and runs a callback when a message arrives.

Examples

This subscriber handles even empty messages gracefully.

ROS

# Example: Empty message
import rospy
from std_msgs.msg import String

rospy.init_node('listener')
subscriber = rospy.Subscriber('chatter', String, lambda data: rospy.loginfo(f"Received: '{data.data}'"))
rospy.spin()

Publisher sends one message and exits.

ROS

# Example: Single message publish
import rospy
from std_msgs.msg import String

rospy.init_node('talker')
publisher = rospy.Publisher('chatter', String, queue_size=10)
rospy.sleep(1)  # Wait for connections
publisher.publish("single message")

Multiple subscribers can listen to the same topic independently.

ROS

# Example: Subscriber with multiple callbacks
import rospy
from std_msgs.msg import String

def callback_one(data):
    rospy.loginfo(f"Callback one got: {data.data}")

def callback_two(data):
    rospy.loginfo(f"Callback two got: {data.data}")

rospy.init_node('listener')
subscriber = rospy.Subscriber('chatter', String, callback_one)
subscriber2 = rospy.Subscriber('chatter', String, callback_two)
rospy.spin()

Sample Program

This program creates a publisher that sends three messages, and a subscriber that listens and prints them. It shows how publish-subscribe works in ROS.

ROS

import rospy
from std_msgs.msg import String

# Publisher node
class Talker:
    def __init__(self):
        self.publisher = rospy.Publisher('chatter', String, queue_size=10)
        self.rate = rospy.Rate(1)  # 1 Hz

    def start(self):
        count = 0
        while not rospy.is_shutdown() and count < 3:
            message = f"hello {count}"
            rospy.loginfo(f"Publishing: {message}")
            self.publisher.publish(message)
            self.rate.sleep()
            count += 1

# Subscriber node
def callback(data):
    rospy.loginfo(f"I heard: {data.data}")

if __name__ == '__main__':
    try:
        # Start subscriber node
        rospy.init_node('listener')
        subscriber = rospy.Subscriber('chatter', String, callback)

        # Start publisher
        talker = Talker()
        talker.start()

        rospy.spin()
    except rospy.ROSInterruptException:
        pass

Important Notes

Publishing and subscribing happen asynchronously, so messages may arrive with some delay.

Use queue_size to control how many messages are buffered if the subscriber is slow.

Common mistake: forgetting to call rospy.spin() in subscriber nodes, which stops callbacks from running.

Use publish-subscribe when you want loose coupling between parts of your robot system.

Summary

Publish-subscribe lets parts send and receive messages without knowing about each other.

Publishers send messages to topics; subscribers listen to those topics.

This model helps build flexible and scalable robot software.

Practice

1. What is the main role of a publisher in the ROS publish-subscribe model?

easy

A. To create new topics dynamically

B. To receive messages from a topic

C. To store messages in a database

D. To send messages to a topic

Solution

1. Step 1: Understand the publish-subscribe roles

   In ROS, publishers send messages to topics, while subscribers receive messages from topics.

2. Step 2: Identify the publisher's function

   The publisher's job is to send data to a topic so subscribers can receive it.

3. Final Answer:

   To send messages to a topic -> Option D

4. Quick Check:

   Publisher = sends messages [OK]

Hint: Publisher sends, subscriber receives messages [OK]

Common Mistakes:

• Confusing publisher with subscriber
• Thinking publisher stores messages
• Assuming publisher creates topics

2. Which of the following is the correct way to create a ROS publisher in Python?

easy

A. pub = rospy.Publisher('topic_name', callback, queue_size=10)

B. pub = rospy.Subscriber('topic_name', String, callback)

C. pub = rospy.Publisher('topic_name', String, queue_size=10)

D. pub = rospy.Subscriber('topic_name', String)

Solution

1. Step 1: Recall publisher syntax in ROS Python

   The correct syntax uses rospy.Publisher with topic name, message type, and queue size.

2. Step 2: Check each option

   pub = rospy.Publisher('topic_name', String, queue_size=10) matches the correct syntax. Using Subscriber instead of Publisher is incorrect. pub = rospy.Publisher('topic_name', callback, queue_size=10) incorrectly uses callback instead of message type.

3. Final Answer:

   pub = rospy.Publisher('topic_name', String, queue_size=10) -> Option C

4. Quick Check:

   Publisher syntax = rospy.Publisher(topic, type, queue_size) [OK]

Hint: Publisher uses rospy.Publisher(topic, type, queue_size) [OK]

Common Mistakes:

• Using Subscriber instead of Publisher
• Passing callback instead of message type
• Omitting queue_size parameter

3. Given the following ROS Python code snippet, what will be printed when a message with data 'Hello' is published?

import rospy
from std_msgs.msg import String

def callback(msg):
    print(f'Received: {msg.data}')

rospy.init_node('listener')
sub = rospy.Subscriber('chatter', String, callback)
rospy.spin()

medium

A. Received: Hello

B. Hello

C. Received: msg

D. No output

Solution

1. Step 1: Understand the callback function

   The callback prints 'Received: ' followed by the message's data field.

2. Step 2: Analyze the message content

   The message data is 'Hello', so the print statement outputs 'Received: Hello'.

3. Final Answer:

   Received: Hello -> Option A

4. Quick Check:

   Callback prints 'Received: ' + msg.data [OK]

Hint: Callback prints 'Received: ' plus message data [OK]

Common Mistakes:

• Printing message object instead of data
• Expecting just the message data without prefix
• Thinking no output occurs without explicit print

4. Identify the error in this ROS Python subscriber code:

import rospy
from std_msgs.msg import String

def callback(msg):
    print(msg.data)

rospy.init_node('listener')
sub = rospy.Subscriber('chatter', String)
rospy.spin()

medium

A. Incorrect message type used

B. Missing callback function in Subscriber

C. Node not initialized

D. No import for rospy

Solution

1. Step 1: Review Subscriber syntax

   Subscriber requires three arguments: topic name, message type, and callback function.

2. Step 2: Check the given code

   The Subscriber call misses the callback argument, causing an error.

3. Final Answer:

   Missing callback function in Subscriber -> Option B

4. Quick Check:

   Subscriber needs callback argument [OK]

Hint: Subscriber must include callback function [OK]

Common Mistakes:

• Omitting callback in Subscriber
• Confusing Publisher and Subscriber arguments
• Forgetting to initialize node

5. You want to create a ROS system where multiple nodes publish sensor data to the same topic, and one node subscribes to process all data. Which feature of the publish-subscribe model makes this possible?

hard

A. Topics allow multiple publishers and subscribers to communicate independently

B. Each topic can have only one publisher and one subscriber

C. Publishers must know all subscribers to send messages

D. Subscribers can only listen to one topic at a time

Solution

1. Step 1: Understand topic communication in ROS

   Topics support multiple publishers and subscribers simultaneously, enabling flexible communication.

2. Step 2: Analyze the scenario

   Multiple nodes publishing to the same topic and one subscriber processing all data is possible because topics allow many publishers and subscribers.

3. Final Answer:

   Topics allow multiple publishers and subscribers to communicate independently -> Option A

4. Quick Check:

   Topics support many-to-many communication [OK]

Hint: Topics support many publishers and subscribers [OK]

Common Mistakes:

• Thinking topics allow only one publisher or subscriber
• Believing publishers must know subscribers
• Assuming subscribers can listen to only one topic