Creating a publisher node in ROS - Mechanics & Internals

Overview - Creating a publisher node

What is it?

A publisher node in ROS is a program that sends messages to other nodes. It creates a channel called a topic where it broadcasts information. Other nodes can listen to this topic to receive the messages. This helps different parts of a robot or system communicate smoothly.

Why it matters

Without publisher nodes, different parts of a robot would not be able to share information easily. This would make coordination and control very hard. Publisher nodes solve this by letting data flow from one part to many others in real time. This makes robots smarter and more responsive.

Where it fits

Before learning to create a publisher node, you should understand basic ROS concepts like nodes, topics, and messages. After mastering publishers, you can learn about subscriber nodes, services, and actions to build full communication systems in ROS.

Mental Model

Core Idea

A publisher node is like a radio station broadcasting messages on a topic that any listener node can tune into.

Think of it like...

Imagine a radio station that plays music on a certain frequency. Anyone with a radio tuned to that frequency can hear the music. The publisher node is the radio station, the topic is the frequency, and subscriber nodes are the radios.

Publisher Node
  │
  ▼
[Topic: /example_topic]
  │
  ▼
Subscriber Node(s)

Messages flow from publisher to subscribers through the topic channel.

Build-Up - 6 Steps

1

Foundation

Understanding ROS nodes and topics

Concept: Learn what nodes and topics are in ROS and how they enable communication.

ROS nodes are programs that perform computation. Topics are named channels where nodes send or receive messages. A publisher node sends messages to a topic, and subscriber nodes listen to that topic to get messages.

Result

You understand that nodes communicate by sending messages over topics.

Knowing that topics are the communication channels helps you see why publisher nodes are essential for sending data.

2

Foundation

Installing ROS and setting up workspace

Concept: Prepare your computer with ROS installed and create a workspace to write your publisher node.

Install ROS (e.g., ROS Noetic) following official instructions. Create a catkin workspace with folders for source code. This setup lets you build and run ROS nodes easily.

Result

Your environment is ready to develop and run ROS publisher nodes.

Having a proper workspace ensures your code integrates well with ROS tools and other nodes.

3

Intermediate

Writing a simple publisher node in Python

🤔Before reading on: do you think a publisher node needs to send messages continuously or just once? Commit to your answer.

Concept: Create a Python script that initializes a node and publishes messages repeatedly on a topic.

Use rospy to create a node with rospy.init_node(). Create a publisher with rospy.Publisher() specifying the topic name and message type. Use a loop with rospy.Rate to send messages at a fixed rate using publisher.publish().

Result

The node sends messages repeatedly on the topic, which can be seen by subscribers.

Understanding the loop and rate control is key to sending messages at a steady pace, which is common in robotics.

4

Intermediate

Choosing message types for publishing

🤔Before reading on: do you think you can publish any data type on a ROS topic? Commit to yes or no.

Concept: Learn about ROS message types and how to select or create the right one for your data.

ROS has standard message types like std_msgs/String or geometry_msgs/Twist. You must import the correct message type and use it when creating the publisher. Custom messages can be defined for complex data.

Result

You can send structured data that subscribers understand and use.

Knowing message types prevents communication errors and ensures data consistency across nodes.

5

Advanced

Handling node shutdown and clean exit

🤔Before reading on: do you think a publisher node stops immediately when you press Ctrl+C? Commit to yes or no.

Concept: Implement graceful shutdown to cleanly stop publishing and release resources.

Use rospy.is_shutdown() in the publishing loop to check if ROS wants to stop the node. Handle exceptions and use rospy.loginfo() to print shutdown messages. This prevents errors and resource leaks.

Result

The node stops cleanly without leaving hanging processes or errors.

Proper shutdown handling is crucial for stable robot operation and debugging.

6

Expert

Optimizing publisher performance and QoS

🤔Before reading on: do you think all publisher nodes use the same quality of service settings? Commit to yes or no.

Concept: Learn about Quality of Service (QoS) settings to tune message delivery reliability and latency.

ROS 2 introduces QoS policies like reliability (best effort or reliable), durability, and history depth. Adjusting these affects how messages are sent and received, important for real-time or lossy networks.

Result

You can configure publishers to meet specific performance and reliability needs in complex systems.

Understanding QoS lets you build robust communication that adapts to network conditions and application demands.

Under the Hood

A publisher node registers itself with the ROS master, announcing the topic it will publish. When it sends a message, ROS transports it over the network to all subscriber nodes listening to that topic. The ROS master helps nodes find each other but does not handle message data directly. Messages are serialized and sent using TCPROS or UDPROS protocols depending on settings.

Why designed this way?

ROS was designed to be modular and distributed, so nodes can run on different machines. Using a central master for discovery but decentralized message passing allows flexibility and scalability. This design avoids bottlenecks and lets robots combine many components easily.

┌─────────────┐        ┌─────────────┐
│ Publisher   │        │ Subscriber  │
│ Node        │        │ Node        │
└─────┬───────┘        └─────┬───────┘
      │                      │
      │ Registers topic      │
      │ with ROS Master      │
      │                      │
      │───── Messages ──────>│
      │                      │
┌─────▼───────┐        ┌─────▼───────┐
│ ROS Master  │        │ Network     │
│ (Discovery) │        │ Transport   │
└─────────────┘        └─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does a publisher node send messages only when a subscriber is connected? Commit to yes or no.

Common Belief: A publisher node only sends messages if there is at least one subscriber listening.

Reality: A publisher node sends messages regardless of subscribers. It does not check if anyone is listening before publishing.

Why it matters: Assuming messages are sent only when subscribers exist can cause missed data or wasted resources if the node is stopped incorrectly.

Quick: Can you publish any Python data type directly on a ROS topic? Commit to yes or no.

Common Belief: You can publish any Python variable directly as a ROS message.

Reality: You must use predefined ROS message types or custom message definitions. Raw Python types are not valid messages.

Why it matters: Trying to publish unsupported types causes runtime errors and communication failures.

Quick: Does the ROS master handle all message data routing? Commit to yes or no.

Common Belief: The ROS master routes all message data between nodes.

Reality: The ROS master only manages node registration and topic discovery. Actual message data flows directly between nodes.

Why it matters: Misunderstanding this can lead to wrong assumptions about network load and debugging complexity.

Quick: Are all publisher nodes in ROS 1 and ROS 2 configured the same way? Commit to yes or no.

Common Belief: Publisher nodes work the same in ROS 1 and ROS 2 without changes.

Reality: ROS 2 introduces Quality of Service settings and different APIs for publishers, requiring different setup.

Why it matters: Using ROS 1 patterns in ROS 2 can cause unexpected behavior or performance issues.

Expert Zone

1

Publisher nodes can use latched topics to send the last message to new subscribers immediately, which is useful for static data.

2

In ROS 2, QoS policies like durability and reliability can be combined to fine-tune communication for different network conditions.

3

Publishing large messages frequently can cause network congestion; batching or throttling messages is a common optimization.

When NOT to use

Publisher nodes are not suitable for request-response interactions; services or actions should be used instead. For very high-frequency data, specialized middleware or shared memory approaches may be better.

Production Patterns

In production, publisher nodes often include diagnostics and error handling. They may dynamically adjust publishing rates based on system load. Using parameter servers to configure topics and message types at runtime is common.

Connections

Event-driven programming

Publisher nodes emit events (messages) that subscribers react to, similar to event emitters and listeners.

Understanding event-driven patterns helps grasp how ROS nodes communicate asynchronously and decouple components.

Publish-subscribe messaging pattern

ROS publisher nodes implement the publish-subscribe pattern, a common design in distributed systems.

Knowing this pattern clarifies why topics decouple senders and receivers, improving scalability and flexibility.

Broadcast radio communication

Like a radio station broadcasting signals to many receivers, publisher nodes send messages to multiple subscribers.

This connection shows how one-to-many communication works efficiently without direct connections.

Common Pitfalls

#1 Not initializing the ROS node before creating a publisher.

Wrong approach:

publisher = rospy.Publisher('chatter', String, queue_size=10)
rospy.init_node('talker')

Correct approach:

rospy.init_node('talker')
publisher = rospy.Publisher('chatter', String, queue_size=10)

Root cause:

The node must be initialized first so ROS can set up communication infrastructure before creating publishers.

#2 Publishing messages without a loop or rate control, causing a flood of messages.

Wrong approach:

while not rospy.is_shutdown():
publisher.publish('hello') # no sleep or rate control

Correct approach:

rate = rospy.Rate(10) # 10 Hz
while not rospy.is_shutdown():
publisher.publish('hello')
rate.sleep()

Root cause:

Without controlling the loop speed, the node sends messages as fast as possible, overwhelming the network.

#3 Using incorrect message type when publishing.

Wrong approach:

publisher = rospy.Publisher('chatter', Int32, queue_size=10)
publisher.publish('hello') # publishing string on Int32 topic

Correct approach:

publisher = rospy.Publisher('chatter', String, queue_size=10)
publisher.publish('hello')

Root cause:

Message types must match between publisher and published data to avoid runtime errors.

Key Takeaways

A publisher node sends messages on a topic to share information with other nodes in ROS.

Topics act like channels where messages flow from publishers to subscribers asynchronously.

Choosing the right message type and controlling publishing rate are essential for reliable communication.

Proper node initialization and shutdown handling ensure stable and clean operation.

Advanced settings like Quality of Service in ROS 2 let you tune message delivery for different needs.

Practice

1. What is the main purpose of a publisher node in ROS?

easy

A. To store data in a database

B. To receive messages from other nodes

C. To compile the ROS package

D. To send messages on a topic to share information

Solution

1. Step 1: Understand the role of a publisher node

   A publisher node sends messages to other nodes by publishing on a topic.

2. Step 2: Compare options with the role

   Only To send messages on a topic to share information describes sending messages on a topic, which matches the publisher's role.

3. Final Answer:

   To send messages on a topic to share information -> Option D

4. Quick Check:

   Publisher node = sends messages [OK]

Hint: Publisher nodes send messages, subscribers receive them [OK]

Common Mistakes:

• Confusing publisher with subscriber
• Thinking publisher stores data
• Assuming publisher compiles code

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

easy

A. self.createPublisher(String, 'topic_name', 10)

B. self.create_publisher(String, 'topic_name', 10)

C. create_publisher(String, 'topic_name', 10)

D. self.create_publisher('topic_name', String, 10)

Solution

1. Step 1: Recall ROS2 Python publisher syntax

   The method is called on the node instance as self.create_publisher, with message type first, then topic name, then queue size.

2. Step 2: Check each option's syntax

   self.create_publisher(String, 'topic_name', 10) matches the correct method name and argument order. self.createPublisher(String, 'topic_name', 10) has wrong method name casing. create_publisher(String, 'topic_name', 10) misses self. self.create_publisher('topic_name', String, 10) swaps argument order.

3. Final Answer:

   self.create_publisher(String, 'topic_name', 10) -> Option B

4. Quick Check:

   Correct method and argument order = self.create_publisher(String, 'topic_name', 10) [OK]

Hint: Use self.create_publisher with message type first [OK]

Common Mistakes:

• Wrong method name casing
• Missing self when calling method
• Swapping topic name and message type

3. Given this ROS2 Python publisher code snippet, what will be printed when the timer callback runs?

def timer_callback(self):
    msg = String()
    msg.data = 'Hello ROS'
    self.publisher.publish(msg)
    print('Published:', msg.data)

medium

A. Published: Hello ROS

B. Hello ROS

C. Published: msg.data

D. Error: msg.data undefined

Solution

1. Step 1: Analyze the print statement

   The print outputs the string 'Published:' followed by the value of msg.data, which is 'Hello ROS'.

2. Step 2: Confirm msg.data value

   msg.data is assigned 'Hello ROS' before publishing, so the print shows 'Published: Hello ROS'.

3. Final Answer:

   Published: Hello ROS -> Option A

4. Quick Check:

   Print shows 'Published:' plus msg.data [OK]

Hint: Print uses string plus msg.data value [OK]

Common Mistakes:

• Printing variable name instead of value
• Assuming print shows only msg.data
• Confusing msg.data with undefined

4. Identify the error in this ROS2 Python publisher node snippet:

def __init__(self):
    self.publisher = self.create_publisher(String, 'chatter', 10)

def timer_callback(self):
    msg = String()
    msg.data = 'Hello'
    self.publisher.publish(msg)

self.timer = self.create_timer(1.0, timer_callback)

medium

A. timer_callback is missing 'self' parameter

B. create_publisher is called with wrong arguments

C. Timer is created outside the class constructor

D. msg.data is assigned incorrectly

Solution

1. Step 1: Check code structure and indentation

   The self.timer = self.create_timer(1.0, timer_callback) line lacks indentation and appears outside __init__ at class level, where 'self' is undefined, causing NameError.

2. Step 2: Verify other options

   A: timer_callback includes 'self'. B: create_publisher args are correct (type, topic, qos). D: msg.data = 'Hello' is valid.

3. Final Answer:

   Timer is created outside the class constructor -> Option C

4. Quick Check:

   self assignments must be inside instance methods like __init__ [OK]

Hint: Create timers inside __init__ with self.create_timer(1.0, self.timer_callback) [OK]

Common Mistakes:

• Omitting 'self' in method parameters
• Misordering create_publisher arguments
• Creating timer outside class context

5. You want to create a ROS2 publisher node that publishes integers incrementing every second starting from 0. Which code snippet correctly implements this behavior?

hard

A. class IntPublisher(Node):
def __init__(self):
super().__init__('int_publisher')
self.publisher = self.create_publisher(Int32, 'numbers', 10)
self.i = 0
self.timer = self.create_timer(1.0, self.timer_callback)
def timer_callback(self):
msg = Int32()
msg.data = self.i
self.publisher.publish(msg)
self.i += 1

B. class IntPublisher(Node):
def __init__(self):
super().__init__('int_publisher')
self.publisher = self.create_publisher(Int32, 'numbers', 10)
self.i = 0
self.timer = self.create_timer(1.0, self.timer_callback)
def timer_callback():
msg = Int32()
msg.data = self.i
self.publisher.publish(msg)
self.i += 1

C. class IntPublisher(Node):
def __init__(self):
super().__init__('int_publisher')
self.publisher = self.create_publisher(Int32, 'numbers', 10)
self.i = 0
self.timer = self.create_timer(1.0, self.timer_callback)
def timer_callback(self):
msg = Int32()
msg.data = 0
self.publisher.publish(msg)
self.i += 1

D. class IntPublisher(Node):
def __init__(self):
super().__init__('int_publisher')
self.publisher = self.create_publisher(Int32, 'numbers', 10)
self.i = 1
self.timer = self.create_timer(1.0, self.timer_callback)
def timer_callback(self):
msg = Int32()
msg.data = self.i
self.publisher.publish(msg)
self.i = 0

Solution

1. Step 1: Check timer_callback method signatures

   Options A and C define timer_callback(self); B omits 'self', causing AttributeError on self.i and self.publisher.

2. Step 2: Verify increment logic

   class IntPublisher(Node): def __init__(self): super().__init__('int_publisher') self.publisher = self.create_publisher(Int32, 'numbers', 10) self.i = 0 self.timer = self.create_timer(1.0, self.timer_callback) def timer_callback(self): msg = Int32() msg.data = self.i self.publisher.publish(msg) self.i += 1 initializes self.i=0 and does self.i += 1 after publishing, yielding 0,1,2,... class IntPublisher(Node): def __init__(self): super().__init__('int_publisher') self.publisher = self.create_publisher(Int32, 'numbers', 10) self.i = 0 self.timer = self.create_timer(1.0, self.timer_callback) def timer_callback(self): msg = Int32() msg.data = 0 self.publisher.publish(msg) self.i += 1 always publishes 0. class IntPublisher(Node): def __init__(self): super().__init__('int_publisher') self.publisher = self.create_publisher(Int32, 'numbers', 10) self.i = 1 self.timer = self.create_timer(1.0, self.timer_callback) def timer_callback(self): msg = Int32() msg.data = self.i self.publisher.publish(msg) self.i = 0 publishes 1 then sets self.i=0 repeatedly.

3. Final Answer:

   self.i = 0; msg.data = self.i; self.i += 1 -> Option A

4. Quick Check:

   self.i starts 0, increment after publish [OK]

Hint: Use self.i and increment after publishing in timer callback [OK]

Common Mistakes:

• Missing 'self' in timer_callback
• Not incrementing the counter
• Resetting counter inside callback