ROS node concept - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary role of a ROS node?

In the Robot Operating System (ROS), what is the main purpose of a node?

A To compile the ROS packages into executable files.

B To store all robot sensor data permanently in a database.

C To provide a graphical user interface for robot control.

D To act as an independent process that performs computation and communicates with other nodes.

💡 Hint

Think about how ROS breaks down robot software into smaller parts.

A ROS node is a process that performs computation and communicates with other nodes to build a robot system. It does not store data permanently or provide GUIs by default.

❓ component_behavior

intermediate

What happens when two ROS nodes publish to the same topic?

Consider two ROS nodes both publishing messages to the same topic. What is the expected behavior?

A The ROS master crashes due to topic conflict.

B Only the first node's messages are received; the second node's messages are ignored.

C Messages from both nodes are merged and received by subscribers in the order they arrive.

D Subscribers receive messages only from the node with the higher node ID.

💡 Hint

Think about how ROS topics handle multiple publishers.

ROS topics allow multiple nodes to publish messages. Subscribers receive all messages from all publishers in the order they arrive.

❓ lifecycle

advanced

What is the correct sequence of ROS node lifecycle states?

Arrange the following ROS node lifecycle states in the correct order from startup to shutdown:

• Inactive
• Active
• Unconfigured
• Finalized

A 2,1,3,4

B 1,2,3,4

C 1,3,2,4

D 3,2,1,4

💡 Hint

Think about the node starting unconfigured, then becoming active, then shutting down.

The ROS node lifecycle starts at Unconfigured, then moves to Inactive, then Active, and finally Finalized when shutting down.

❓ state_output

advanced

What is the output of this ROS Python node code snippet?

Given the following ROS Python node code, what will be printed to the console?

ROS

import rclpy
from rclpy.node import Node

class SimpleNode(Node):
    def __init__(self):
        super().__init__('simple_node')
        self.counter = 0
        self.timer = self.create_timer(0.5, self.timer_callback)

    def timer_callback(self):
        self.counter += 1
        self.get_logger().info(f'Count: {self.counter}')
        if self.counter == 3:
            self.destroy_timer(self.timer)

rclpy.init()
node = SimpleNode()
rclpy.spin(node)
rclpy.shutdown()

A

Count: 1
Count: 2
Count: 3
Then the node stops printing.

B

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Then the node stops printing.

C No output because the timer is destroyed immediately.

D

Count: 0
Count: 1
Count: 2
Then the node stops printing.

💡 Hint

Look at how the counter increments and when the timer is destroyed.

The timer callback runs every 0.5 seconds, increments counter, prints it, and stops after count 3 by destroying the timer.

🔧 Debug

expert

Which option causes a runtime error in this ROS node code?

Consider this ROS Python node snippet that tries to publish messages:

import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class Talker(Node):
    def __init__(self):
        super().__init__('talker')
        self.publisher_ = self.create_publisher(String, 'chatter', 10)
        self.timer = self.create_timer(1.0, self.timer_callback)

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

rclpy.init()
node = Talker()
rclpy.spin(node)
rclpy.shutdown()

Which modification below will cause a runtime error when running this node?

A Change the message type to an integer: self.create_publisher(int, 'chatter', 10)

B Change 'self.publisher_' to None before publishing: self.publisher_ = None

C Remove the call to rclpy.init() before creating the node

D Change the topic name to an empty string: self.create_publisher(String, '', 10)

💡 Hint

Think about what types ROS publishers accept for messages.

ROS publishers require a valid message type class. Using 'int' instead of a ROS message type causes a runtime error.

Practice

1. What is a ROS node in simple terms?

easy

A. A type of sensor used in robots

B. A hardware part of the robot

C. A small program that runs in the robot system

D. A communication cable between robots

Solution

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

   A ROS node is a software program that runs to perform tasks in a robot system.

2. Step 2: Differentiate from hardware and other parts

   It is not hardware or cables but a small program that communicates with others.

3. Final Answer:

   A small program that runs in the robot system -> Option C

4. Quick Check:

   ROS node = small program [OK]

Hint: Remember: node = small program in ROS [OK]

Common Mistakes:

• Thinking a node is hardware
• Confusing nodes with sensors
• Believing nodes are cables

2. Which of the following is the correct way to initialize a ROS node in Python?

easy

A. rospy.init_node('node_name')

B. ros.init('node_name')

C. node.start('node_name')

D. init.node('node_name')

Solution

1. Step 1: Recall ROS Python syntax for node initialization

   The correct function to start a node is rospy.init_node with the node name as argument.

2. Step 2: Check other options for correctness

   Other options use incorrect function names or syntax not used in ROS Python.

3. Final Answer:

   rospy.init_node('node_name') -> Option A

4. Quick Check:

   Initialize node with rospy.init_node() [OK]

Hint: Use rospy.init_node('name') to start a node [OK]

Common Mistakes:

• Using ros.init instead of rospy.init_node
• Calling node.start which doesn't exist
• Wrong function order or names

3. Consider this Python ROS node snippet:

import rospy
rospy.init_node('talker')
rospy.loginfo('Node started')

What will this code do when run?

medium

A. Cause a syntax error due to missing parentheses

B. Start a node named 'talker' and print 'Node started' info message

C. Start a node but no message will be printed

D. Start a node named 'listener' and print 'Node started'

Solution

1. Step 1: Analyze node initialization

   The code calls rospy.init_node with 'talker', so it starts a node named 'talker'.

2. Step 2: Check logging output

   rospy.loginfo prints the message 'Node started' to the console or log.

3. Final Answer:

   Start a node named 'talker' and print 'Node started' info message -> Option B

4. Quick Check:

   Node 'talker' starts and logs info [OK]

Hint: rospy.loginfo prints messages after node starts [OK]

Common Mistakes:

• Confusing node name with 'listener'
• Thinking no message prints
• Assuming syntax error without checking code

4. This ROS Python node code has an error:

import rospy
rospy.init_node('listener')
rospy.spin

What is the error?

medium

A. rospy.init_node should be called after rospy.spin

B. Wrong node name 'listener'

C. Missing import of std_msgs

D. Missing parentheses after rospy.spin

Solution

1. Step 1: Check usage of rospy.spin

   rospy.spin is a function and must be called with parentheses to keep the node alive.

2. Step 2: Verify other parts

   Node name 'listener' is valid, std_msgs import is not required here, and init_node must be called before spin.

3. Final Answer:

   Missing parentheses after rospy.spin -> Option D

4. Quick Check:

   Call rospy.spin() with parentheses [OK]

Hint: Always call rospy.spin() with parentheses [OK]

Common Mistakes:

• Forgetting parentheses on rospy.spin
• Thinking node name causes error
• Misordering init_node and spin

5. You want to create two ROS nodes that communicate by sending messages. Which is the best way to organize your code?

hard

A. Write two separate node programs, each with its own init_node call

B. Write one program with two init_node calls for both nodes

C. Use one node and switch its name dynamically

D. Create one node and run it twice without changes

Solution

1. Step 1: Understand ROS node design

   Each node is a separate program with its own init_node call to run independently.

2. Step 2: Evaluate other options

   One program cannot have two init_node calls; switching names dynamically or running one node twice without changes won't create two communicating nodes properly.

3. Final Answer:

   Write two separate node programs, each with its own init_node call -> Option A

4. Quick Check:

   Separate programs = separate nodes [OK]

Hint: One node per program with init_node call [OK]

Common Mistakes:

• Trying to call init_node twice in one program
• Reusing one node for two roles
• Not separating node logic into programs