Message timing and frequency in ROS - Mini Project: Build & Apply

Message timing and frequency

📖 Scenario: You are building a simple ROS node that publishes messages at a fixed rate. This is common in robotics to send sensor data or commands regularly.

🎯 Goal: Create a ROS publisher node that sends messages at a frequency of 2 Hz using a timer.

📋 What You'll Learn

Create a ROS node named talker

Create a publisher for the topic chatter with message type std_msgs/String

Set up a timer to publish messages at 2 Hz

Publish a message with the text Hello ROS every time the timer triggers

💡 Why This Matters

🌍 Real World

Robots often need to send sensor data or commands at fixed intervals. This project shows how to do that with ROS timers.

💼 Career

Understanding message timing and frequency is essential for robotics software engineers working with ROS to build reliable and responsive robot applications.

1

Create the ROS node and publisher

Write code to initialize a ROS node called talker and create a publisher named pub that publishes std_msgs.msg.String messages on the topic chatter.

ROS

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

# Your code here

Hint

Use rclpy.init() to start ROS, then create a Node named talker. Use create_publisher on the node to make the publisher.

2

Set the publishing frequency

Create a variable called timer_period and set it to 0.5 to represent the time interval in seconds for a 2 Hz frequency.

ROS

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

rclpy.init()
node = Node('talker')
pub = node.create_publisher(String, 'chatter', 10)

# Your code here

Hint

Set timer_period to 0.5 seconds because 2 Hz means 2 messages per second, so each message is sent every 0.5 seconds.

3

Create the timer callback to publish messages

Define a function called timer_callback that creates a String message with data 'Hello ROS' and publishes it using the pub publisher. Then create a timer on node that calls timer_callback every timer_period seconds.

ROS

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

rclpy.init()
node = Node('talker')
pub = node.create_publisher(String, 'chatter', 10)
timer_period = 0.5

# Your code here

Hint

Define timer_callback to create and publish the message. Use node.create_timer with timer_period and the callback function.

4

Add spinning to keep the node alive

Add code to spin the node so it keeps running and processing timer events, then shut down ROS after spinning.

ROS

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

rclpy.init()
node = Node('talker')
pub = node.create_publisher(String, 'chatter', 10)
timer_period = 0.5

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

node.create_timer(timer_period, timer_callback)

# Your code here

Hint

Use rclpy.spin(node) to keep the node alive. After spinning, clean up with node.destroy_node() and rclpy.shutdown().

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