Sending velocity commands in Drone Programming - Deep Dive

Overview - Sending velocity commands

What is it?

Sending velocity commands means telling a drone how fast and in which direction to move. Instead of giving it a fixed position to reach, you give it speed instructions along the x, y, and z axes. This lets the drone move smoothly and react quickly to changes. It is like telling a car how fast to go forward, backward, or sideways rather than where exactly to stop.

Why it matters

Without velocity commands, drones would only move to fixed points, making their motion jerky and less responsive. Velocity commands allow for smooth, continuous control, which is essential for tasks like obstacle avoidance, following moving targets, or flying in tight spaces. This makes drones safer and more effective in real-world situations.

Where it fits

Before learning velocity commands, you should understand basic drone control concepts like coordinate systems and position commands. After mastering velocity commands, you can learn advanced topics like acceleration control, trajectory planning, and autonomous navigation.

Mental Model

Core Idea

Velocity commands tell the drone how fast to move in each direction, letting it glide smoothly instead of jumping between points.

Think of it like...

It's like driving a car using the gas pedal and steering wheel to control speed and direction, rather than telling the car exactly where to park.

Velocity Command Structure:

┌───────────────┐
│ Velocity Cmd  │
│ ┌───────────┐ │
│ │ vx, vy, vz│ │  <-- speeds along X, Y, Z axes
│ └───────────┘ │
│ ┌───────────┐ │
│ │ yaw_rate  │ │  <-- rotation speed around vertical axis
│ └───────────┘ │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding velocity in 3D space

Concept: Velocity is speed with direction, described by three numbers for x, y, and z axes.

Imagine a drone floating in the air. To move it, you tell it how fast to go forward/backward (x), left/right (y), and up/down (z). These three speeds together form the velocity vector. For example, vx=1 means moving forward at 1 meter per second.

Result

You can describe any movement direction and speed using three velocity values.

Understanding velocity as a vector in 3D space is the foundation for controlling drone movement smoothly.

2

Foundation

Difference between position and velocity commands

Concept: Position commands tell where to go; velocity commands tell how fast to move.

Position commands say: 'Go to point (x=5, y=5, z=2)'. Velocity commands say: 'Move at 1 m/s forward, 0.5 m/s right, and 0 m/s up'. Position commands can cause sudden stops; velocity commands create smooth motion.

Result

Velocity commands allow continuous, fluid movement instead of jumping between points.

Knowing this difference helps you choose the right control method for smooth drone flight.

3

Intermediate

Sending velocity commands via drone APIs

🤔Before reading on: do you think velocity commands are sent as absolute positions or speed values? Commit to your answer.

Concept: Velocity commands are sent as speed values, often in a message format defined by the drone's API.

Most drone software uses messages with fields like vx, vy, vz, and yaw_rate. For example, in ROS (Robot Operating System), you publish a Twist message with linear.x, linear.y, linear.z for velocity. The drone reads these and moves accordingly.

Result

You can control drone movement by publishing velocity messages to the correct communication channel.

Understanding the message format and communication method is key to implementing velocity control in real systems.

4

Intermediate

Coordinate frames and velocity directions

🤔Before reading on: do you think velocity commands are relative to the drone or the world? Commit to your answer.

Concept: Velocity commands can be relative to the drone's body or the fixed world frame, affecting how directions are interpreted.

Body frame means vx moves the drone forward relative to where it's facing. World frame means vx moves it east regardless of orientation. You must know which frame your commands use to avoid unexpected movement.

Result

Correct frame choice ensures the drone moves as intended when you send velocity commands.

Knowing coordinate frames prevents confusion and errors in drone control.

5

Advanced

Combining velocity commands with yaw control

🤔Before reading on: do you think yaw (rotation) is controlled separately or combined with velocity? Commit to your answer.

Concept: Yaw rate commands control how fast the drone rotates around its vertical axis, often sent alongside velocity commands.

Velocity commands usually include linear speeds and a yaw rate. For example, vx=1 m/s forward and yaw_rate=0.5 rad/s means move forward while turning slowly. This allows smooth curved paths.

Result

You can make the drone move and turn simultaneously for complex maneuvers.

Combining linear and rotational velocity commands enables natural, fluid drone flight.

6

Advanced

Handling velocity command timing and updates

🤔Before reading on: do you think sending one velocity command is enough or continuous updates are needed? Commit to your answer.

Concept: Velocity commands must be sent repeatedly at a steady rate to maintain control and avoid unintended stops.

Drones usually stop if they stop receiving velocity commands. So, your program must send commands at a fixed frequency (e.g., 10 times per second). This keeps the drone moving smoothly and safely.

Result

Continuous command updates prevent sudden stops and keep the drone responsive.

Understanding timing requirements avoids common control failures in real drone flights.

7

Expert

Velocity command limits and safety constraints

🤔Before reading on: do you think you can send any velocity values or are there limits? Commit to your answer.

Concept: Drones have maximum safe speeds and acceleration limits; commands must respect these to avoid crashes or damage.

Sending velocity commands beyond the drone's capabilities can cause instability or hardware stress. Flight controllers enforce limits, rejecting or clipping commands. Advanced control software also smooths commands to avoid sudden changes.

Result

Safe velocity commands keep the drone stable and protect hardware during flight.

Knowing and respecting velocity limits is critical for reliable and safe drone operation.

Under the Hood

When you send velocity commands, the drone's flight controller reads the desired speeds and converts them into motor speeds. It uses sensors like gyroscopes and accelerometers to adjust motor power, maintaining stable flight while achieving the commanded velocity. The controller runs a loop many times per second, constantly updating motor outputs based on velocity commands and sensor feedback.

Why designed this way?

Velocity commands allow smooth, continuous control, which is easier for flight controllers to handle than jumping between positions. This design reduces sudden movements and improves stability. Early drones used position commands but struggled with jerky motion, so velocity control became standard for better flight quality.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Velocity Cmd  │──────▶│ Flight Ctrl   │──────▶│ Motor Speeds  │
│ (vx, vy, vz)  │       │ (PID loops)   │       │ (PWM signals) │
└───────────────┘       └───────────────┘       └───────────────┘
         ▲                      ▲                      ▲
         │                      │                      │
         │                      │                      │
         │                      │                      │
         │                      │                      │
         │                      │                      │
         └──────────────────────┴──────────────────────┘
                  Sensor Feedback (gyro, accel)

Myth Busters - 4 Common Misconceptions

Quick: Do you think sending a single velocity command makes the drone keep moving forever? Commit yes or no.

Common Belief: Once you send a velocity command, the drone will keep moving at that speed until told otherwise.

Reality: Drones usually require continuous velocity commands; if commands stop, the drone will hover or stop for safety.

Why it matters: Assuming one command lasts leads to unexpected stops or crashes when the drone suddenly stops moving.

Quick: Do you think velocity commands always use the drone's facing direction? Commit yes or no.

Common Belief: Velocity commands are always relative to the drone's current facing direction (body frame).

Reality: Some systems use world frame coordinates, meaning velocity directions are fixed to the environment, not the drone's orientation.

Why it matters: Confusing frames causes the drone to move in wrong directions, making control unpredictable.

Quick: Do you think you can send any velocity value without limits? Commit yes or no.

Common Belief: You can send any velocity values you want; the drone will just try to follow them exactly.

Reality: Drones have maximum velocity and acceleration limits; commands beyond these are clipped or ignored for safety.

Why it matters: Ignoring limits can cause unstable flight or damage to the drone.

Quick: Do you think yaw rotation is controlled separately from velocity? Commit yes or no.

Common Belief: Yaw (rotation) must be controlled separately and cannot be combined with velocity commands.

Reality: Yaw rate is often included in the same velocity command message, allowing simultaneous movement and rotation.

Why it matters: Not combining yaw with velocity limits smooth flight paths and maneuverability.

Expert Zone

1

Velocity commands often need filtering or smoothing to avoid sudden jumps that destabilize the drone.

2

Some advanced drones support acceleration commands layered on top of velocity for even smoother control.

3

Latency in command transmission can cause drift; experts compensate by predictive control or sensor fusion.

When NOT to use

Velocity commands are not ideal when precise positioning is required, such as landing or docking. In those cases, position or waypoint commands are better. Also, for very slow or hovering tasks, direct attitude or thrust control may be preferred.

Production Patterns

In real systems, velocity commands are combined with sensor feedback loops and safety checks. They are sent at fixed rates via communication protocols like MAVLink. Developers often implement state machines that switch between velocity control and position control depending on mission phase.

Connections

PID Control

Velocity commands are inputs to PID controllers that stabilize drone motion.

Understanding velocity commands helps grasp how PID loops convert desired speeds into motor actions.

Vector Mathematics

Velocity commands use vector components to represent direction and magnitude.

Knowing vector math clarifies how combining vx, vy, vz creates complex 3D movements.

Human Motor Control

Like how humans adjust muscle speed and direction to move smoothly, velocity commands guide drone motors.

Studying human movement control reveals parallels in continuous feedback and smooth velocity adjustments.

Common Pitfalls

#1 Sending velocity commands only once and expecting continuous movement.

Wrong approach:

send_velocity_command(vx=1, vy=0, vz=0) # sent once

Correct approach:

while flying:
send_velocity_command(vx=1, vy=0, vz=0) # sent repeatedly at fixed rate

Root cause:

Misunderstanding that drones require continuous command updates to maintain velocity.

#2 Mixing coordinate frames and sending velocity in world frame when drone expects body frame.

Wrong approach:

send_velocity_command(vx=1, vy=0, vz=0, frame='world') # drone expects body frame

Correct approach:

send_velocity_command(vx=1, vy=0, vz=0, frame='body') # matches drone's expected frame

Root cause:

Confusing coordinate frames leads to unexpected drone movement directions.

#3 Sending velocity values beyond drone's maximum speed.

Wrong approach:

send_velocity_command(vx=10, vy=10, vz=10) # exceeds max speed

Correct approach:

send_velocity_command(vx=2, vy=2, vz=1) # within safe limits

Root cause:

Ignoring drone hardware and software limits causes instability or command rejection.

Key Takeaways

Velocity commands control drone speed and direction continuously, enabling smooth flight.

They differ from position commands by specifying how fast to move, not where to go.

Coordinate frames matter: commands can be relative to the drone or the world, affecting direction.

Velocity commands must be sent repeatedly at a steady rate to maintain motion.

Respecting velocity limits and combining yaw control ensures safe and natural drone maneuvers.

Practice

1. What does sending a velocity command to a drone usually control?
send_velocity(x_speed, y_speed, z_speed, duration)

easy

A. The drone's battery level

B. The speed and direction the drone moves in each axis

C. The drone's camera angle

D. The drone's GPS coordinates

Solution

1. Step 1: Understand velocity command parameters

   The parameters x_speed, y_speed, and z_speed represent how fast the drone moves along each axis.

2. Step 2: Connect parameters to drone movement

   These speeds control the drone's direction and speed, while duration controls how long it moves.

3. Final Answer:

   The speed and direction the drone moves in each axis -> Option B

4. Quick Check:

   Velocity commands = speed and direction control [OK]

Hint: Velocity commands set speed and direction, not camera or battery [OK]

Common Mistakes:

• Confusing velocity with camera control
• Thinking velocity sets GPS location directly
• Assuming velocity changes battery level

2. Which of the following is the correct syntax to send a velocity command moving the drone forward at 2 m/s for 5 seconds?

easy

A. send_velocity(5, 0, 0, 2)

B. send_velocity(0, 2, 0, 5)

C. send_velocity(0, 0, 2, 5)

D. send_velocity(2, 0, 0, 5)

Solution

1. Step 1: Identify forward direction axis

   Forward movement is usually along the X-axis, so x_speed should be 2.

2. Step 2: Check duration and other speeds

   Y and Z speeds are zero, duration is 5 seconds, matching the command.

3. Final Answer:

   send_velocity(2, 0, 0, 5) -> Option D

4. Quick Check:

   X-axis speed = 2, duration = 5 [OK]

Hint: Forward speed is X-axis; duration is last parameter [OK]

Common Mistakes:

• Mixing up X and Y axes
• Putting duration in wrong position
• Setting speed on wrong axis

3. What will be the drone's movement after running this code?

send_velocity(0, -3, 0, 4)

medium

A. The drone moves left at 3 m/s for 4 seconds

B. The drone moves backward at 3 m/s for 4 seconds

C. The drone moves right at 3 m/s for 4 seconds

D. The drone moves upward at 3 m/s for 4 seconds

Solution

1. Step 1: Identify axis for Y speed

   The Y-axis controls left-right movement; negative means left.

2. Step 2: Interpret speed and duration

   Speed is 3 m/s left for 4 seconds, no movement on X or Z axes.

3. Final Answer:

   The drone moves left at 3 m/s for 4 seconds -> Option A

4. Quick Check:

   Negative Y speed = left movement [OK]

Hint: Negative Y speed means left movement [OK]

Common Mistakes:

• Confusing negative Y with backward
• Mixing Y and Z axes
• Assuming negative means right

4. Identify the error in this velocity command code:

send_velocity(1, 0, 0)

medium

A. Missing duration parameter

B. Wrong order of speed parameters

C. Negative speed value not allowed

D. Extra parameter included

Solution

1. Step 1: Check function parameters

   The function requires four parameters: x_speed, y_speed, z_speed, and duration.

2. Step 2: Identify missing parameter

   Only three parameters are given; duration is missing, causing an error.

3. Final Answer:

   Missing duration parameter -> Option A

4. Quick Check:

   Duration required as 4th parameter [OK]

Hint: Velocity commands need 4 parameters: x, y, z, duration [OK]

Common Mistakes:

• Forgetting duration parameter
• Swapping speed and duration order
• Using negative duration

5. You want the drone to move diagonally upward forward at 1 m/s on X and Z axes for 3 seconds, but keep Y speed zero. Which command is correct?

hard

A. send_velocity(1, 1, 0, 3)

B. send_velocity(0, 1, 1, 3)

C. send_velocity(1, 0, 1, 3)

D. send_velocity(1, 0, 0, 1)

Solution

1. Step 1: Assign speeds to correct axes

   X speed = 1 (forward), Y speed = 0 (no sideways), Z speed = 1 (upward).

2. Step 2: Check duration matches requirement

   Duration is 3 seconds, matching the problem statement.

3. Final Answer:

   send_velocity(1, 0, 1, 3) -> Option C

4. Quick Check:

   X=1, Y=0, Z=1, duration=3 [OK]

Hint: Set speeds on X and Z, zero on Y, duration last [OK]

Common Mistakes:

• Mixing Y and Z speeds
• Wrong duration value
• Setting zero on wrong axis