Velocity smoothing in ROS - Deep Dive

Overview - Velocity smoothing

What is it?

Velocity smoothing is a technique used in robotics to make the robot's speed changes smooth and gradual instead of sudden. It adjusts the velocity commands sent to the robot so that acceleration and deceleration happen gently. This helps prevent jerky movements and reduces mechanical stress. In ROS, velocity smoothing is often applied to control commands for mobile robots or manipulators.

Why it matters

Without velocity smoothing, robots can move abruptly, causing instability, wear on parts, or unsafe behavior around people. Sudden speed changes can make the robot harder to control and damage sensors or hardware. Velocity smoothing ensures safer, more reliable, and more predictable robot motion, which is critical for real-world applications like delivery robots or factory automation.

Where it fits

Before learning velocity smoothing, you should understand basic ROS concepts like topics, messages, and robot control commands. After mastering velocity smoothing, you can explore advanced motion planning, trajectory generation, and control algorithms that build on smooth velocity profiles.

Mental Model

Core Idea

Velocity smoothing gently shapes speed commands so the robot accelerates and decelerates smoothly, avoiding sudden jumps.

Think of it like...

It's like driving a car where you press the gas pedal slowly instead of stomping it, making the ride comfortable and safe.

Velocity commands
  ↓
[Velocity Smoother]
  ↓
Smooth velocity commands
  ↓
Robot actuators

Where the smoother acts as a filter that rounds sharp edges in speed changes.

Build-Up - 7 Steps

1

Foundation

Understanding velocity commands in ROS

Concept: Learn what velocity commands are and how they control robot movement.

In ROS, velocity commands are usually sent as messages (e.g., geometry_msgs/Twist) containing linear and angular speeds. These commands tell the robot how fast to move forward/backward and how fast to turn. Without smoothing, these commands can change abruptly from one message to the next.

Result

You can send direct velocity commands to the robot, but the robot may jerk or move unpredictably if commands change suddenly.

Knowing how velocity commands work is essential before applying smoothing, as smoothing modifies these commands to improve motion quality.

2

Foundation

Why sudden velocity changes cause problems

Concept: Understand the physical and control issues caused by abrupt speed changes.

Sudden changes in velocity cause jerks, which stress mechanical parts and can make the robot unstable. Sensors may produce noisy data during jerks, and control loops may struggle to keep up. This can lead to unsafe or inefficient robot behavior.

Result

Recognizing these problems motivates the need for smoothing velocity commands.

Understanding the real-world impact of abrupt commands helps appreciate why smoothing is necessary for reliable robot operation.

3

Intermediate

Basic velocity smoothing techniques

🤔Before reading on: do you think velocity smoothing changes the robot's top speed or just how quickly it reaches it? Commit to your answer.

Concept: Introduce simple methods like limiting acceleration and deceleration rates to smooth velocity changes.

A common smoothing method is to limit how much the velocity can change between consecutive commands. For example, if the robot is moving at 0.5 m/s, and the next command is 1.5 m/s, the smoother might only allow increasing speed by 0.2 m/s per cycle. This prevents sudden jumps and creates a ramp-up effect.

Result

Velocity commands become gradual ramps instead of sharp steps, reducing jerks.

Knowing that smoothing controls acceleration rather than speed itself clarifies how smooth motion is achieved without limiting performance.

4

Intermediate

Implementing velocity smoothing in ROS nodes

🤔Before reading on: do you think velocity smoothing is best done before or after sending commands to the robot hardware? Commit to your answer.

Concept: Learn how to add a smoothing layer in ROS by subscribing to raw velocity commands and publishing smoothed commands.

Create a ROS node that listens to raw velocity commands on one topic, applies smoothing logic (like acceleration limits), and publishes the smoothed commands on another topic. The robot controller subscribes to the smoothed topic. This separation keeps smoothing modular and flexible.

Result

Robot receives smooth velocity commands, improving motion quality without changing the original command source.

Understanding the modular design of smoothing nodes helps build reusable and maintainable robot control systems.

5

Intermediate

Handling angular velocity smoothing

🤔Before reading on: do you think smoothing linear and angular velocities require the same approach? Commit to your answer.

Concept: Extend smoothing to angular velocities, considering rotational acceleration limits.

Angular velocity smoothing works similarly to linear smoothing but applies to rotational speed. Limiting how fast the robot can start or stop turning prevents jerky rotations. Care must be taken to handle angle wrapping (e.g., from +pi to -pi) correctly.

Result

Robot turns smoothly without sudden spins or stops.

Recognizing that angular smoothing needs special handling prevents common bugs in robot rotation control.

6

Advanced

Adaptive velocity smoothing for dynamic environments

🤔Before reading on: do you think a fixed smoothing rate works well in all situations? Commit to your answer.

Concept: Introduce adaptive smoothing that changes limits based on context like robot speed or environment complexity.

In some cases, fixed acceleration limits are too slow or too fast. Adaptive smoothing adjusts limits dynamically, for example, allowing faster acceleration on open floors but slower near obstacles. This can be done by integrating sensor data or higher-level planners.

Result

Robot moves efficiently and safely, adapting smoothing to current needs.

Understanding adaptive smoothing shows how to balance safety and performance in real-world robotics.

7

Expert

Velocity smoothing internals and latency trade-offs

🤔Before reading on: does velocity smoothing always reduce control latency? Commit to your answer.

Concept: Explore how smoothing algorithms introduce latency and how to balance smoothness with responsiveness.

Smoothing works by filtering velocity commands over time, which inherently delays the robot's response to new commands. Too much smoothing causes sluggish behavior, while too little causes jerks. Experts tune smoothing parameters carefully and may use predictive models to reduce latency impact.

Result

A well-tuned smoother achieves smooth motion without noticeable delay.

Knowing the latency trade-off helps design smoothing that feels natural and responsive in production robots.

Under the Hood

Velocity smoothing works by applying filters or constraints on the velocity command stream. At each control cycle, the smoother compares the new command with the previous output and limits the rate of change based on acceleration constraints. This can be implemented as a simple rate limiter or more complex filters like low-pass filters. Internally, the smoother maintains state of the last output velocity and calculates the next output to ensure smooth transitions.

Why designed this way?

Robots need smooth motion to avoid mechanical stress and maintain control stability. Early robot controllers sent raw commands, causing jerks and hardware wear. Velocity smoothing was introduced as a modular layer to improve motion quality without redesigning hardware or control algorithms. The design balances simplicity, modularity, and effectiveness, allowing easy integration with existing ROS systems.

Raw velocity commands ──▶ [Velocity Smoother] ──▶ Smoothed velocity commands ──▶ Robot actuators

Inside Velocity Smoother:
┌─────────────────────────────┐
│ Previous velocity stored     │
│                             │
│ New command received         │
│                             │
│ Calculate allowed change     │
│ Apply acceleration limits   │
│                             │
│ Output smoothed velocity     │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does velocity smoothing reduce the robot's maximum speed? Commit to yes or no.

Common Belief: Velocity smoothing slows down the robot by limiting its top speed.

Reality: Velocity smoothing does not limit the maximum speed; it only limits how quickly the robot can change speed, allowing it to reach top speed smoothly.

Why it matters: Believing smoothing reduces speed may cause unnecessary performance compromises or incorrect tuning.

Quick: Is velocity smoothing only needed for robots moving very fast? Commit to yes or no.

Common Belief: Only fast-moving robots need velocity smoothing; slow robots don't benefit.

Reality: All robots benefit from smoothing because even small jerks can cause mechanical wear or unstable sensor readings.

Why it matters: Ignoring smoothing on slow robots can lead to unexpected hardware issues and poor control quality.

Quick: Does velocity smoothing eliminate all motion errors? Commit to yes or no.

Common Belief: Velocity smoothing fixes all robot motion problems and guarantees perfect movement.

Reality: Smoothing improves command quality but does not replace good control algorithms or sensor feedback for precise motion.

Why it matters: Overreliance on smoothing can mask deeper control issues and lead to poor system design.

Quick: Can velocity smoothing be applied after the robot hardware controller? Commit to yes or no.

Common Belief: Velocity smoothing can be done anywhere, even after the hardware controller.

Reality: Smoothing must be applied before commands reach hardware to affect motion; applying it after hardware commands has no effect.

Why it matters: Misplacing smoothing causes it to have no impact, wasting effort and causing confusion.

Expert Zone

1

Smoothing parameters often need tuning per robot model and environment; one-size-fits-all rarely works well.

2

Some smoothing algorithms incorporate predictive models to anticipate future commands and reduce latency effects.

3

Combining velocity smoothing with trajectory planning requires careful coordination to avoid conflicting commands.

When NOT to use

Velocity smoothing is not suitable when ultra-low latency or immediate response is critical, such as in high-speed obstacle avoidance. In such cases, direct control or model predictive control (MPC) methods are preferred.

Production Patterns

In production, velocity smoothing is often implemented as a dedicated ROS node or integrated into robot middleware. It is combined with safety layers that monitor acceleration limits and emergency stops. Adaptive smoothing based on sensor feedback is common in autonomous vehicles and delivery robots.

Connections

Signal filtering

Velocity smoothing uses similar principles as signal filtering to remove sharp changes.

Understanding signal filtering helps grasp how smoothing removes abrupt velocity jumps, improving control stability.

Human motor control

Both velocity smoothing and human motor control involve gradual acceleration to avoid jerky movements.

Studying human movement reveals natural smoothing strategies that inspire robotic velocity smoothing algorithms.

Traffic flow management

Velocity smoothing in robots parallels how traffic lights and speed limits smooth vehicle flow to prevent accidents.

Recognizing this connection shows how smoothing reduces sudden changes that cause instability, whether in robots or traffic.

Common Pitfalls

#1 Applying velocity smoothing without considering control loop frequency.

Wrong approach:

def smooth_velocity(current, target):
max_change = 0.1
if abs(target - current) > max_change:
return current + max_change * ((target - current) / abs(target - current))
else:
return target

# Called at irregular intervals causing inconsistent smoothing

Correct approach:

def smooth_velocity(current, target, dt):
max_acceleration = 0.5 # m/s²
max_change = max_acceleration * dt
if abs(target - current) > max_change:
return current + max_change * ((target - current) / abs(target - current))
else:
return target

# Uses time delta to ensure consistent smoothing

Root cause:

Ignoring time between control updates causes uneven smoothing and unexpected jerks.

#2 Smoothing linear velocity but ignoring angular velocity.

Wrong approach:

def smooth_velocity(linear_current, linear_target):
# smooth linear only
return linear_target

# Angular velocity sent raw, causing jerky turns

Correct approach:

def smooth_velocity(linear_current, linear_target, angular_current, angular_target):
# smooth both linear and angular velocities
return linear_target, angular_target

# Both velocities smoothed for consistent motion

Root cause:

Treating linear and angular velocities separately leads to inconsistent robot behavior.

#3 Applying smoothing after sending commands to hardware.

Wrong approach:

# Robot controller subscribes to raw commands
# Smoothing applied in a monitoring node after hardware
# No effect on actual robot motion

Correct approach:

# Smoothing node subscribes to raw commands
# Publishes smoothed commands to hardware controller
# Robot moves smoothly

Root cause:

Misunderstanding data flow causes smoothing to be ineffective.

Key Takeaways

Velocity smoothing shapes robot speed commands to change gradually, preventing jerky movements.

It improves robot safety, hardware longevity, and control stability without limiting maximum speed.

Smoothing is best implemented as a modular layer before commands reach the robot hardware.

Both linear and angular velocities require smoothing for consistent, smooth motion.

Tuning smoothing parameters balances smoothness with responsiveness and depends on robot and environment.

Practice

1. What is the main purpose of velocity smoothing in ROS robot control?

easy

A. To gradually change speed and avoid sudden jumps

B. To increase the maximum speed instantly

C. To stop the robot immediately

D. To ignore acceleration limits

Solution

1. Step 1: Understand velocity smoothing concept

   Velocity smoothing means changing speed gradually to avoid sudden jumps.

2. Step 2: Identify the purpose in robot control

   This gradual change improves safety and comfort by preventing abrupt movements.

3. Final Answer:

   To gradually change speed and avoid sudden jumps -> Option A

4. Quick Check:

   Velocity smoothing = gradual speed change [OK]

Hint: Velocity smoothing means smooth speed changes, not instant jumps [OK]

Common Mistakes:

• Thinking velocity smoothing increases speed instantly
• Confusing smoothing with emergency stop
• Ignoring acceleration limits in smoothing

2. Which of the following is the correct Python function signature for a velocity smoothing function in ROS?

easy

A. def smooth_velocity(current_vel: float, target_vel: float, max_accel: float):

B. def smooth_velocity(current_vel, target_vel, max_accel):

C. def smooth_velocity(current_vel: int, target_vel: int, max_accel: int, dt: int):

D. def smooth_velocity(current_vel: float, target_vel: float, max_accel: float, dt: float) -> float:

Solution

1. Step 1: Check function parameters for velocity smoothing

   The function needs current velocity, target velocity, max acceleration, and time delta (dt) to calculate smoothing.

2. Step 2: Verify correct typing and return type

   Using floats for velocities and acceleration is correct, and the function returns a float for new velocity.

3. Final Answer:

   def smooth_velocity(current_vel: float, target_vel: float, max_accel: float, dt: float) -> float: -> Option D

4. Quick Check:

   Correct parameters and types = def smooth_velocity(current_vel: float, target_vel: float, max_accel: float, dt: float) -> float: [OK]

Hint: Include all needed parameters with correct types and return value [OK]

Common Mistakes:

• Missing dt parameter for time step
• Using int instead of float for velocities
• No return type annotation

3. Given the following code snippet for velocity smoothing, what will be the output if current_vel = 1.0, target_vel = 3.0, max_accel = 1.0, and dt = 1.0?

def smooth_velocity(current_vel, target_vel, max_accel, dt):
    max_change = max_accel * dt
    delta = target_vel - current_vel
    if abs(delta) > max_change:
        delta = max_change if delta > 0 else -max_change
    return current_vel + delta

print(smooth_velocity(1.0, 3.0, 1.0, 1.0))

medium

A. 2.0

B. 3.0

C. 1.0

D. 4.0

Solution

1. Step 1: Calculate maximum allowed velocity change

   max_change = max_accel * dt = 1.0 * 1.0 = 1.0

2. Step 2: Calculate delta and limit it

   delta = target_vel - current_vel = 3.0 - 1.0 = 2.0, which is greater than max_change, so delta is limited to 1.0

3. Step 3: Calculate new velocity

   new velocity = current_vel + delta = 1.0 + 1.0 = 2.0

4. Final Answer:

   2.0 -> Option A

5. Quick Check:

   Velocity change limited by max_accel * dt = 2.0 [OK]

Hint: Limit velocity change by max_accel * dt before adding [OK]

Common Mistakes:

• Adding full delta without limiting by max_change
• Returning target_vel directly
• Ignoring sign of delta

4. Identify the bug in this velocity smoothing function and choose the correct fix:

def smooth_velocity(current_vel, target_vel, max_accel, dt):
    max_change = max_accel * dt
    delta = target_vel - current_vel
    if delta > max_change:
        delta = max_change
    elif delta < max_change:
        delta = -max_change
    return current_vel + delta

medium

A. Change max_change to max_accel / dt

B. Remove the if-else and always set delta = max_change

C. Change 'elif delta < max_change' to 'elif delta < -max_change'

D. Add abs() around delta in the if condition

Solution

1. Step 1: Analyze the conditions for limiting delta

   The function limits delta if it exceeds max_change positively or negatively.

2. Step 2: Identify incorrect condition

   The condition 'elif delta < max_change' is wrong because it triggers for any delta less than max_change, including values that don't need limiting. It should check if delta is less than negative max_change.

3. Step 3: Correct the condition

   Change 'elif delta < max_change' to 'elif delta < -max_change' to correctly limit negative large changes.

4. Final Answer:

   Change 'elif delta < max_change' to 'elif delta < -max_change' -> Option C

5. Quick Check:

   Negative delta limit needs correct comparison [OK]

Hint: Check negative limit uses -max_change, not max_change [OK]

Common Mistakes:

• Using max_change instead of -max_change for negative check
• Removing conditions and causing wrong velocity jumps
• Incorrect calculation of max_change

5. You want to implement velocity smoothing for a robot that receives a list of target velocities every second: [0, 2, 5, 3, 0]. The robot's max acceleration is 1.5 m/s² and the time step is 1 second. Which sequence of smoothed velocities will correctly apply velocity smoothing starting from 0 m/s?

hard

A. [0, 1.5, 3.0, 4.5, 3.0]

B. [0, 1.5, 3.0, 3.0, 1.5]

C. [0, 1.5, 2.5, 3.0, 1.5]

D. [0, 2, 5, 3, 0]

Solution

1. Step 1: Calculate smoothed velocities step-by-step

   Start at 0 m/s. Max change per step = 1.5 m/s. - Step 1: target 0 -> 0 (start) - Step 2: target 2, delta=2-0=2 >1.5, so velocity=0+1.5=1.5 - Step 3: target 5, delta=5-1.5=3.5 >1.5, velocity=1.5+1.5=3.0 - Step 4: target 3, delta=3-3=0 ≤1.5, velocity=3.0 - Step 5: target 0, delta=0-3=-3 < -1.5, velocity=3.0-1.5=1.5

2. Step 2: Compare with options

   The sequence [0, 1.5, 3.0, 3.0, 1.5] matches the calculated sequence.

3. Final Answer:

   [0, 1.5, 3.0, 3.0, 1.5] -> Option B

4. Quick Check:

   Apply max_accel limit each step = [0, 1.5, 3.0, 3.0, 1.5] [OK]

Hint: Apply max acceleration limit stepwise to each velocity [OK]

Common Mistakes:

• Using target velocities directly without smoothing
• Adding max_accel multiple times incorrectly
• Ignoring negative acceleration limits