Safety velocity limits in ROS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when the velocity exceeds the safety limit in a ROS node?

Consider a ROS node that subscribes to velocity commands and applies safety velocity limits before publishing. What will be the output behavior if the input velocity exceeds the safety limit?

ROS

def velocity_callback(msg):
    max_speed = 1.0  # m/s
    safe_vel = min(msg.linear.x, max_speed)
    publish_velocity(safe_vel)

# Input velocity message: linear.x = 1.5 m/s

A The node publishes a velocity of 1.0 m/s, limiting the speed to the safety threshold.

B The node throws an error and stops running due to velocity limit violation.

C The node stops the robot by publishing 0 m/s velocity.

D The node publishes the original velocity of 1.5 m/s without any change.

💡 Hint

Think about how the min function limits the velocity value.

The code uses min(msg.linear.x, max_speed) to ensure the velocity never exceeds 1.0 m/s. So if input is 1.5 m/s, it publishes 1.0 m/s.

📝 Syntax

intermediate

Identify the syntax error in this ROS velocity limiting code snippet

Which option contains the correct syntax to limit a velocity message's linear.x to a max of 2.0 m/s in Python ROS?

ROS

def limit_velocity(msg):
    max_vel = 2.0
    if msg.linear.x > max_vel
        msg.linear.x = max_vel
    return msg

A Replace if with while to continuously check velocity.

B Remove the return statement as it's not needed.

C Add a colon after the if statement: if msg.linear.x > max_vel:

D Change max_vel to a string '2.0' to fix the error.

💡 Hint

Python if statements require a colon at the end.

The if statement is missing a colon, which causes a syntax error. Adding ':' fixes it.

❓ state_output

advanced

What is the final velocity published after applying safety limits?

Given this ROS Python code snippet that limits both linear and angular velocities, what will be the published velocities if input is linear.x=3.5 m/s and angular.z=2.5 rad/s?

ROS

def limit_velocities(msg):
    max_linear = 2.0
    max_angular = 1.0
    msg.linear.x = min(msg.linear.x, max_linear)
    msg.angular.z = min(msg.angular.z, max_angular)
    publish(msg)

# Input velocities: linear.x=3.5, angular.z=2.5

A linear.x=2.0 m/s, angular.z=2.5 rad/s

B linear.x=2.0 m/s, angular.z=1.0 rad/s

C linear.x=0 m/s, angular.z=0 rad/s

D linear.x=3.5 m/s, angular.z=2.5 rad/s

💡 Hint

The min function caps values at the max limits.

Both linear and angular velocities are capped at their max values, so output is 2.0 and 1.0 respectively.

🔧 Debug

advanced

Why does this ROS node fail to enforce velocity limits correctly?

Examine the code below. Why does the robot sometimes move faster than the safety velocity limit?

ROS

def callback(msg):
    max_speed = 1.0
    if msg.linear.x > max_speed:
        msg.linear.x = max_speed
    # Missing else clause
    publish(msg)

# Input velocities vary, sometimes below max_speed

A Because the publish function is called outside the if block, so velocity is always published.

B Because the node does not subscribe to the correct topic.

C Because the original message is modified directly, causing unexpected side effects elsewhere.

D Because the code only limits velocity when above max_speed but does not handle negative velocities correctly.

💡 Hint

Think about what happens if velocity is negative and less than max_speed.

Negative velocities less than max_speed are not limited, so robot can move faster backward than intended.

🧠 Conceptual

expert

What is the main benefit of applying safety velocity limits in a ROS robot control system?

Why do ROS developers implement safety velocity limits on robot commands?

A To prevent the robot from moving too fast and causing damage or unsafe situations.

B To reduce the CPU usage of the ROS node by limiting message frequency.

C To ensure the robot always moves at maximum speed for efficiency.

D To disable the robot's movement when sensors fail.

💡 Hint

Think about safety and physical limits of robots.

Safety velocity limits protect hardware and people by preventing dangerous speeds.

Practice

1. What is the main purpose of safety velocity limits in ROS?

easy

A. To keep robot speeds within safe ranges

B. To increase the robot's maximum speed

C. To disable robot movement completely

D. To control the robot's battery usage

Solution

1. Step 1: Understand the role of safety velocity limits

   Safety velocity limits are designed to prevent the robot from moving too fast, ensuring safety.

2. Step 2: Identify the correct purpose

   Among the options, only keeping speeds safe matches the purpose of safety velocity limits.

3. Final Answer:

   To keep robot speeds within safe ranges -> Option A

4. Quick Check:

   Safety velocity limits = keep speeds safe [OK]

Hint: Safety limits control max speed, not disable or increase it [OK]

Common Mistakes:

• Thinking safety limits increase speed
• Confusing safety limits with power control
• Assuming safety limits stop all movement

2. Which ROS parameter syntax correctly sets a maximum linear velocity limit to 0.5 m/s?

easy

A. max_linear_velocity 0.5

B. max_linear_velocity = 0.5

C. max_linear_velocity->0.5

D. max_linear_velocity: 0.5

Solution

1. Step 1: Recall ROS parameter YAML syntax

   ROS parameters in YAML use colon and space, like param_name: value.

2. Step 2: Match syntax to options

   Only max_linear_velocity: 0.5 uses correct YAML syntax for setting parameters.

3. Final Answer:

   max_linear_velocity: 0.5 -> Option D

4. Quick Check:

   ROS YAML param = key: value [OK]

Hint: ROS params use colon and space, not equals or arrows [OK]

Common Mistakes:

• Using equals sign instead of colon
• Omitting colon and space
• Using arrow notation which is invalid

3. Given this ROS node snippet setting velocity limits:

velocity_limits:
  max_linear: 1.0
  max_angular: 0.5

robot_velocity:
  linear: 1.2
  angular: 0.4

What will be the effective linear velocity after applying safety limits?

medium

A. 1.0 m/s

B. 1.2 m/s

C. 0.5 m/s

D. 0.4 m/s

Solution

1. Step 1: Compare robot velocity to max limits

   The robot's linear velocity is 1.2 m/s, which exceeds the max_linear limit of 1.0 m/s.

2. Step 2: Apply safety velocity limit

   The effective linear velocity must be capped at the max_linear limit, 1.0 m/s.

3. Final Answer:

   1.0 m/s -> Option A

4. Quick Check:

   Velocity capped at max_linear = 1.0 [OK]

Hint: If velocity > max limit, use max limit value [OK]

Common Mistakes:

• Using original velocity without capping
• Confusing angular and linear limits
• Choosing the lower angular limit for linear velocity

4. You wrote this YAML for velocity limits but the robot ignores the limits:

velocity_limits:
  max_linear = 0.8
  max_angular: 0.4

What is the likely error?

medium

A. Incorrect indentation for max_angular

B. Missing quotes around numbers

C. Using '=' instead of ':' for max_linear

D. Parameter names must be uppercase

Solution

1. Step 1: Check YAML syntax for parameters

   YAML requires colon and space to assign values, not equals sign.

2. Step 2: Identify the error in max_linear line

   Using '=' instead of ':' causes the parameter to be ignored or cause parsing errors.

3. Final Answer:

   Using '=' instead of ':' for max_linear -> Option C

4. Quick Check:

   YAML param syntax = colon, not equals [OK]

Hint: YAML uses colon, not equals, to assign values [OK]

Common Mistakes:

• Using equals sign in YAML
• Forgetting indentation rules
• Thinking quotes are mandatory for numbers

5. You want to set different safety velocity limits for two robot modes: normal and cautious. Which YAML structure correctly defines max linear velocities for both modes?

hard

A. velocity_limits:
normal:
max_linear: 1.0
cautious:
max_linear: 0.5

B. velocity_limits:
max_linear:
normal: 1.0
cautious: 0.5

C. velocity_limits:
normal_max_linear: 1.0
cautious_max_linear: 0.5

D. velocity_limits:
max_linear_normal: 1.0
max_linear_cautious: 0.5

Solution

1. Step 1: Understand hierarchical YAML for modes

   Grouping limits under max_linear with mode keys is clear and scalable.

2. Step 2: Compare options for clarity and structure

   velocity_limits:
     max_linear:
       normal: 1.0
       cautious: 0.5

   nests modes under max_linear, which is a common pattern for related parameters.

3. Final Answer:

   velocity_limits: max_linear: normal: 1.0 cautious: 0.5 -> Option B

4. Quick Check:

   Nested keys for modes under max_linear =

   velocity_limits:
     max_linear:
       normal: 1.0
       cautious: 0.5

   [OK]

Hint: Nest modes under max_linear for clear grouped limits [OK]

Common Mistakes:

• Using flat keys with mode suffixes
• Not grouping related parameters
• Confusing key names and structure