Message timing and frequency in ROS - Step-by-Step Execution

Concept Flow - Message timing and frequency

Start Node

↓

Initialize Publisher

↓

Set Timer with Frequency

↓

Timer triggers callback

↓

Publish Message

↓

Wait for next timer event

↩Back to Timer triggers callback

The node starts, sets up a publisher and a timer that triggers a callback at a set frequency to publish messages repeatedly.

Execution Sample

ROS

import rclpy
from std_msgs.msg import String

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

rclpy.init()
node = rclpy.create_node('talker')
publisher = node.create_publisher(String, 'topic', 10)
timer = node.create_timer(1.0, timer_callback)
rclpy.spin(node)

This code sets up a ROS node that publishes a 'Hello ROS' message every 1 second on a topic.

Execution Table

Step	Action	Timer Event	Message Published	Next Timer Wait
1	Node starts and initializes publisher	No	No	Waiting for timer
2	Timer triggers first callback	Yes	Message with 'Hello ROS' published	Wait 1 second
3	Timer triggers second callback	Yes	Message with 'Hello ROS' published	Wait 1 second
4	Timer triggers third callback	Yes	Message with 'Hello ROS' published	Wait 1 second
5	Node shutdown requested	No	No	Stop timer and exit

💡 Node shutdown stops timer and message publishing

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
msg.data	None	'Hello ROS'	'Hello ROS'	'Hello ROS'	Node stopped

Key Moments - 3 Insights

Why does the message publish happen repeatedly?

Because the timer triggers the callback repeatedly at the set frequency, as shown in execution_table rows 2-4.

What controls how often messages are published?

The timer interval controls frequency; here it is set to 1 second, so messages publish every 1 second (execution_table 'Next Timer Wait').

What happens if the node shuts down?

The timer stops triggering callbacks, so no more messages are published (see execution_table row 5).

Visual Quiz - 3 Questions

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

A Empty string

B 'Goodbye ROS'

C 'Hello ROS'

D No message published

💡 Hint

Check the 'Message Published' column at step 3 in the execution_table.

At which step does the timer stop triggering callbacks?

A Step 2

B Step 5

C Step 4

D Step 1

💡 Hint

Look at the 'Timer Event' column and the exit_note in the execution_table.

If the timer interval changed to 0.5 seconds, how would the 'Next Timer Wait' column change?

A It would show 'Wait 0.5 seconds'

B It would show 'Wait 2 seconds'

C It would not change

D Timer would stop

💡 Hint

The timer interval controls the wait time between callbacks, shown in the 'Next Timer Wait' column.

Concept Snapshot

ROS message timing uses a timer to publish messages repeatedly.
Set timer interval to control frequency (e.g., 1 second).
Timer triggers callback that publishes message.
Node runs until shutdown stops timer.
Messages appear on topic at set intervals.

Full Transcript

In ROS, message timing and frequency are controlled by a timer that triggers a callback repeatedly. The node starts and initializes a publisher. Then it sets a timer with a specific interval, for example, 1 second. Each time the timer triggers, the callback runs and publishes a message on the topic. This repeats until the node shuts down, which stops the timer and message publishing. The key variables like the message content remain constant during each callback. Beginners often wonder why messages publish repeatedly; it's because the timer keeps triggering the callback. The frequency depends on the timer interval. When the node stops, no more messages are sent. This process ensures messages are sent regularly and predictably.

Practice

1. What is the main purpose of using ros::Rate in a ROS node?

easy

A. To initialize the ROS node

B. To store messages received from other nodes

C. To shut down the ROS system safely

D. To control how often the loop runs and messages are sent

Solution

1. Step 1: Understand the role of ros::Rate

   ros::Rate is used to specify the frequency at which a loop runs in a ROS node.

2. Step 2: Connect frequency control to message timing

   By controlling loop frequency, ros::Rate indirectly controls how often messages are published or processed.

3. Final Answer:

   To control how often the loop runs and messages are sent -> Option D

4. Quick Check:

   Message timing = loop frequency = To control how often the loop runs and messages are sent [OK]

Hint: Remember: ros::Rate sets loop speed for message timing [OK]

Common Mistakes:

• Confusing ros::Rate with message storage
• Thinking ros::Rate initializes or shuts down nodes
• Ignoring its role in timing control

2. Which of the following is the correct way to create a ros::Rate object for 10 Hz frequency?

easy

A. ros::Rate loop_rate = 10;

B. ros::Rate loop_rate(0.1);

C. ros::Rate loop_rate(10);

D. ros::Duration loop_rate(0.1);

Solution

1. Step 1: Recall ros::Rate constructor syntax

   The constructor takes a double representing frequency in Hz, e.g., ros::Rate(10) for 10 Hz.

2. Step 2: Check each option for correct syntax

   ros::Rate loop_rate(10); uses correct constructor syntax. ros::Rate loop_rate = 10; assigns int directly, which is invalid. ros::Rate loop_rate(0.1); uses 0.1 Hz, not 10 Hz. ros::Duration loop_rate(0.1); uses wrong class ros::Duration.

3. Final Answer:

   ros::Rate loop_rate(10); -> Option C

4. Quick Check:

   Constructor needs frequency in Hz = ros::Rate loop_rate(10); [OK]

Hint: Use ros::Rate(freq) with freq as number in Hz [OK]

Common Mistakes:

• Using assignment instead of constructor
• Confusing frequency with period (0.1 instead of 10)
• Confusing ros::Rate with ros::Duration

3. Given the code snippet:

ros::Rate loop_rate(5);
int count = 0;
while (ros::ok() && count < 3) {
  ROS_INFO("Count: %d", count);
  loop_rate.sleep();
  count++;
}

How many seconds will this loop approximately take to finish?

medium

A. 0.2 seconds

B. 0.6 seconds

C. 0.4 seconds

D. 0.8 seconds

Solution

1. Step 1: Understand ros::Rate frequency and sleep duration

   ros::Rate(5) means 5 cycles per second, so each cycle lasts 1/5 = 0.2 seconds.

2. Step 2: Calculate total time for 3 iterations

   3 iterations x 0.2 seconds each = 0.6 seconds. The loop calls sleep() 3 times (once after each print), totaling 0.6 seconds of sleep time. Computation (ROS_INFO, increment) is negligible, so approximately 0.6 seconds.

3. Final Answer:

   0.6 seconds -> Option B

4. Quick Check:

   3 x 0.2s = 0.6s [OK]

Hint: Multiply iterations by 1/frequency to get total time [OK]

Common Mistakes:

• Confusing frequency with period
• Overestimating computation overhead
• Counting iterations incorrectly

4. Identify the error in this ROS loop code:

ros::Rate loop_rate(10);
while (ros::ok()) {
  ROS_INFO("Running");
  loop_rate.sleep();
  loop_rate.sleep();
}

medium

A. Calling loop_rate.sleep() twice causes the loop to run at half frequency

B. Missing ros::spinOnce() call inside the loop

C. ros::Rate must be declared inside the loop

D. ROS_INFO cannot be used inside loops

Solution

1. Step 1: Analyze the effect of calling loop_rate.sleep() twice

   Each call to loop_rate.sleep() pauses the loop to maintain the set frequency. Calling it twice doubles the sleep time, effectively halving the loop frequency.

2. Step 2: Check other options for correctness

   Missing ros::spinOnce() call inside the loop is not mandatory unless callbacks are used. ros::Rate must be declared inside the loop is incorrect; ros::Rate is usually declared outside the loop. ROS_INFO cannot be used inside loops is false; ROS_INFO is commonly used inside loops.

3. Final Answer:

   Calling loop_rate.sleep() twice causes the loop to run at half frequency -> Option A

4. Quick Check:

   Extra sleep doubles wait time = half frequency [OK]

Hint: One sleep call per loop to keep correct frequency [OK]

Common Mistakes:

• Calling sleep multiple times per loop
• Thinking ros::Rate must be inside loop
• Assuming ROS_INFO is invalid in loops

5. You want a ROS node to publish sensor data at 20 Hz but only if new data is available. Which approach best controls message timing and frequency?

hard

A. Use ros::Rate(20) and call loop_rate.sleep() every loop, publishing only when data is new

B. Publish data immediately when available without any rate control

C. Use ros::Rate(1) and publish data every second regardless of availability

D. Call loop_rate.sleep() twice per loop to slow down publishing

Solution

1. Step 1: Understand the requirement for 20 Hz publishing only when data is new

   The node should run at 20 Hz frequency but publish messages conditionally based on data availability.

2. Step 2: Evaluate each option for meeting this requirement

   Use ros::Rate(20) and call loop_rate.sleep() every loop, publishing only when data is new correctly sets loop frequency to 20 Hz and publishes only when new data exists. Publish data immediately when available without any rate control lacks frequency control, risking irregular timing. Use ros::Rate(1) and publish data every second regardless of availability sets too low frequency (1 Hz). Call loop_rate.sleep() twice per loop to slow down publishing slows down publishing incorrectly by double sleeping.

3. Final Answer:

   Use ros::Rate(20) and call loop_rate.sleep() every loop, publishing only when data is new -> Option A

4. Quick Check:

   Set rate high, publish conditionally = Use ros::Rate(20) and call loop_rate.sleep() every loop, publishing only when data is new [OK]

Hint: Set high rate, publish only when needed inside loop [OK]

Common Mistakes:

• Ignoring rate control causing irregular timing
• Using too low frequency for sensor data
• Calling sleep multiple times to slow down