Creating a publisher node in ROS - Visual Walkthrough

Concept Flow - Creating a publisher node

Initialize ROS Node

↓

Create Publisher Object

↓

Create Message

↓

Publish Message

↓

rclpy.spin(node)

↓

Shutdown

This flow shows how a ROS publisher node starts, creates a publisher, publishes a message, then spins to keep the node alive until stopped.

Execution Sample

ROS

import rclpy
from std_msgs.msg import String

def main(args=None):
    rclpy.init(args=args)
    node = rclpy.create_node('publisher_node')
    publisher = node.create_publisher(String, 'topic', 10)
    msg = String()
    msg.data = 'Hello ROS'
    publisher.publish(msg)
    rclpy.spin(node)
    rclpy.shutdown()

if __name__ == '__main__':
    main()

This code initializes a ROS 2 node, creates a publisher for String messages on 'topic', publishes one message, then spins to keep the node alive.

Execution Table

Step	Action	Node State	Publisher State	Message Content	Output
1	Initialize ROS client library	Not initialized -> Initialized	null	null	ROS system ready
2	Create node 'publisher_node'	Initialized -> Node created	null	null	Node ready
3	Create publisher on 'topic'	Node created	Publisher created	null	Ready to publish
4	Create message object	Node created	Publisher created	Empty String	Message ready
5	Set message data to 'Hello ROS'	Node created	Publisher created	'Hello ROS'	Message set
6	Publish message	Node created	Publisher created	'Hello ROS'	Message sent on 'topic'
7	Spin node to keep alive	Node active	Publisher active	Last message sent	Node running
8	Shutdown ROS	Node active -> Shutdown	Publisher active -> Shutdown	null	Node stopped

💡 ROS node shuts down after spinning or external interrupt

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 6	Final
rclpy	Not initialized	Initialized	Initialized	Initialized	Initialized	Shutdown
node	null	Created	Created	Created	Created	Shutdown
publisher	null	null	Created	Created	Created	Shutdown
msg	null	null	null	Data='Hello ROS'	Data='Hello ROS'	null

Key Moments - 3 Insights

Why do we need to call rclpy.init() before creating a node?

rclpy.init() sets up the ROS client library. Without it, the node cannot be created or communicate. See execution_table step 1 and 2.

What happens if we publish a message before creating the publisher?

Publishing requires a valid publisher object. Without it, the message cannot be sent. See execution_table step 3 and 6.

Why do we call rclpy.spin(node) after publishing?

spin() keeps the node alive to process callbacks and maintain communication. Without it, the node would exit immediately. See execution_table step 7.

Visual Quiz - 3 Questions

Look at the execution table, what is the message content at step 5?

A null

B Empty String

C 'Hello ROS'

D 'Goodbye ROS'

💡 Hint

Check the 'Message Content' column at step 5 in the execution_table.

At which step does the publisher get created?

A Step 2

B Step 3

C Step 5

D Step 6

💡 Hint

Look at the 'Action' and 'Publisher State' columns in the execution_table.

If we skip rclpy.spin(node), what happens to the node?

A Node shuts down immediately after publishing

B Node keeps running normally

C Node crashes with error

D Node publishes multiple messages automatically

💡 Hint

Refer to key_moments about the purpose of rclpy.spin and execution_table step 7.

Concept Snapshot

ROS Publisher Node Quick Guide:
- Call rclpy.init() to start ROS client
- Create a node with rclpy.create_node('name')
- Create a publisher with node.create_publisher(msg_type, topic, queue_size)
- Create and fill message object
- Publish message with publisher.publish(msg)
- Use rclpy.spin(node) to keep node alive
- Shutdown with rclpy.shutdown()

Full Transcript

This visual execution trace shows how to create a ROS publisher node. First, the ROS client library is initialized with rclpy.init(). Then a node named 'publisher_node' is created. Next, a publisher object is created on the topic 'topic' for String messages. A message object is created and its data field set to 'Hello ROS'. The message is published once. The node is kept alive by calling rclpy.spin(node) to allow ongoing communication. Finally, the node shuts down cleanly with rclpy.shutdown(). Variables like node, publisher, and message change state step-by-step as shown. Key moments clarify why initialization and spinning are necessary. The quiz tests understanding of message content, publisher creation, and node lifecycle.

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