Message timing and frequency in ROS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a ROS publisher that publishes messages at a fixed rate.

ROS

ros::Rate loop_rate([1]);

Drag options to blanks, or click blank then click option'

Aspin

Brate

Cnode

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name instead of a number for the rate.

Confusing ros::Rate with ros::spin.

The ros::Rate object controls the frequency of the loop. Here, 10 means 10 Hz, so the loop runs 10 times per second.

2fill in blank

medium

Complete the code to publish a message and maintain the loop rate.

ROS

while (ros::ok()) {
  pub.publish(msg);
  ros::spinOnce();
  [1].sleep();
}

Drag options to blanks, or click blank then click option'

Aloop_rate

Bros

Cnode

Drate

Attempts:

3 left

💡 Hint

Common Mistakes

Calling ros::sleep() instead of loop_rate.sleep().

Forgetting to call sleep(), causing the loop to run too fast.

The loop_rate.sleep() call pauses the loop to maintain the desired frequency.

3fill in blank

hard

Fix the error in the code to correctly set the message publishing frequency.

ROS

ros::Rate loop_rate([1]);

while (ros::ok()) {
  pub.publish(msg);
  ros::spinOnce();
  loop_rate.sleep();
}

Drag options to blanks, or click blank then click option'

A-5

B10

C0

D"10"

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero or negative numbers for frequency.

Passing the frequency as a string instead of a number.

The frequency must be a positive number. Using 10 sets the loop to run at 10 Hz. Zero or negative values cause errors. Passing a string is invalid.

4fill in blank

hard

Fill both blanks to create a ROS timer that calls a callback function at a fixed rate.

ROS

ros::Timer timer = nh.createTimer(ros::Duration([1]), [2]);

Drag options to blanks, or click blank then click option'

A0.5

Bcallback

C0.1

Dspin

Attempts:

3 left

💡 Hint

Common Mistakes

Using ros::spin instead of a callback function.

Passing the timer period as an integer instead of a float.

The ros::Duration argument sets the timer period in seconds (0.5 means every half second). The callback function is passed as the second argument.

5fill in blank

hard

Fill all three blanks to create a ROS node that publishes messages at 5 Hz using a timer.

ROS

ros::NodeHandle nh;
ros::Publisher pub = nh.advertise<std_msgs::String>("chatter", 1000);
ros::Timer timer = nh.createTimer(ros::Duration([1]), [2]);

void [3](const ros::TimerEvent&) {
  std_msgs::String msg;
  msg.data = "Hello";
  pub.publish(msg);
}

Drag options to blanks, or click blank then click option'

A0.2

BtimerCallback

Ccallback

Dspin

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong timer period for 5 Hz.

Mismatching the callback function name.

0.2 seconds means the timer triggers 5 times per second (5 Hz). The callback function name must match the function defined, here 'timerCallback'.

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