In ROS 2, the Publish-Subscribe (PubSub) mechanism is a fundamental communication pattern that enables nodes to communicate efficiently through topics. This post explores how PubSub works in ROS 2, its key benefits, and provides an example using the rclpy library.
The Publish-Subscribe (PubSub) mechanism is a messaging pattern that allows nodes to communicate asynchronously in a distributed system. Publishers send messages to a “topic,” and any node that subscribes to that topic will receive the messages.
Key Points:
In ROS 2, the Publish-Subscribe mechanism can be implemented using the rclpy library. Here’s a step-by-step breakdown of how to implement a publisher and subscriber works in general:
publish method to send the message to the specified topic.callback method to connect to the desired topic.The figure below illustrates this PubSub mechanism where one publisher publishes its information on the topic /chatter and two subscribers subscribe to information on that topic.
Here’s some sample code illustrating how PubSub works in ROS 2:
import rclpy
from rclpy.executors import SingleThreadedExecutor
from rclpy.node import Node
from std_msgs.msg import String
class MyPublisher(Node):
def __init__(self):
super().__init__('publisher')
self.publisher = self.create_publisher(String, 'chatter', 10)
self.timer = self.create_timer(1, self.publish)
def publish(self):
msg = String()
msg.data = 'Hello, World!'
self.publisher.publish(msg)
class MySubscriber1(Node):
def __init__(self):
super().__init__('subscriber1')
self.subscription = self.create_subscription(
String,
'chatter',
self.listener_callback,
10)
def listener_callback(self, msg):
self.get_logger().info(f'Received: {msg.data}')
class MySubscriber2(Node):
def __init__(self):
super().__init__('subscriber2')
self.subscription = self.create_subscription(
String,
'chatter',
self.listener_callback,
10)
def listener_callback(self, msg):
self.get_logger().info(f'Received: {msg.data}')
def main(args=None):
rclpy.init(args=args)
publisher = MyPublisher()
subscriber1 = MySubscriber1()
subscriber2 = MySubscriber2()
executor = SingleThreadedExecutor()
executor.add_node(publisher)
executor.add_node(subscriber1)
executor.add_node(subscriber2)
executor.spin()
if __name__ == '__main__':
main()In this example, we have three nodes: publisher and subscriber1 and subscriber2. The publisher node publishes a message to the chatter topic, while the subscriber node subscribe to that same topic. When the subscribers receive a new message, they log it to the console.
Let’s discuss the most important parts of the code:
: Here the inherited method create_publisher is used to create the publisher object. It publishes messages of type std_msgs.msg.String() on the chatter topic with a queue size of 10.The Publish-Subscribe mechanism offers several advantages, making it a popular choice in robotics systems:
The Publish-Subscribe mechanism is widely used in ROS 2 robotics for tasks like:
The Publish-Subscribe mechanism in ROS 2, powered by rclpy, is essential for building scalable and modular robotic systems. It allows nodes to communicate asynchronously, with benefits like loose coupling, flexibility, and scalability. Whether you’re handling sensor data, controlling robotic components, or enabling inter-robot communication, PubSub offers an efficient and organized way to manage message exchanges.
Explore more ROS 2 PubSub examples and download the full source code from our GitHub repository.
String, Int32, over sensor data like PointCloud2 and custom messages defined in .msg files.rclpy in ROS 2? rclpy is the Python client library in ROS 2, enabling the development of nodes in Python. It simplifies interaction with the ROS 2 core, including PubSub operations.
