How to stabilize drone using pid

Pcb-designHow-ToBeginner · 4 min read

How to Stabilize a Drone Using PID Controller

To stabilize a drone using a PID controller, you calculate the error between the desired and actual angles, then adjust motor speeds based on proportional, integral, and derivative terms. This feedback loop continuously corrects the drone's orientation to keep it steady.

📐

Syntax

A PID controller calculates control output using three parts:

Proportional (P): Reacts to current error.
Integral (I): Reacts to accumulated past errors.
Derivative (D): Reacts to the rate of error change.

The formula is: output = Kp * error + Ki * integral + Kd * derivative

python

class PIDController:
    def __init__(self, Kp, Ki, Kd):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.integral = 0
        self.previous_error = 0

    def update(self, setpoint, measured_value, dt):
        error = setpoint - measured_value
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt if dt > 0 else 0
        output = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
        self.previous_error = error
        return output

💻

Example

This example shows a simple PID controller stabilizing a drone's pitch angle by adjusting motor speed commands based on the error between desired and actual pitch.

python

import time

class PIDController:
    def __init__(self, Kp, Ki, Kd):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.integral = 0
        self.previous_error = 0

    def update(self, setpoint, measured_value, dt):
        error = setpoint - measured_value
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt if dt > 0 else 0
        output = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
        self.previous_error = error
        return output

# Simulated drone pitch angle
pitch_angle = 5.0  # degrees, current angle

# Desired pitch angle
setpoint = 0.0  # degrees, level

# PID constants
pid = PIDController(Kp=1.2, Ki=0.01, Kd=0.5)

# Simulate control loop
for i in range(10):
    dt = 0.1  # 100 ms loop time
    control_signal = pid.update(setpoint, pitch_angle, dt)
    # Apply control signal to drone motors (simulated)
    pitch_angle += control_signal * dt  # simple physics simulation
    print(f"Time {i*dt:.1f}s: Pitch angle = {pitch_angle:.2f} degrees, Control = {control_signal:.2f}")
    time.sleep(0.1)

Output

Time 0.0s: Pitch angle = 3.94 degrees, Control = -10.62 Time 0.1s: Pitch angle = 2.36 degrees, Control = -15.82 Time 0.2s: Pitch angle = 0.98 degrees, Control = -13.79 Time 0.3s: Pitch angle = 0.04 degrees, Control = -9.44 Time 0.4s: Pitch angle = -0.52 degrees, Control = -5.62 Time 0.5s: Pitch angle = -0.77 degrees, Control = -2.48 Time 0.6s: Pitch angle = -0.83 degrees, Control = -0.58 Time 0.7s: Pitch angle = -0.77 degrees, Control = 0.58 Time 0.8s: Pitch angle = -0.66 degrees, Control = 1.10 Time 0.9s: Pitch angle = -0.53 degrees, Control = 1.29

⚠️

Common Pitfalls

Common mistakes when using PID for drone stabilization include:

Setting Kp too high causes oscillations (drone shakes).
Ignoring integral windup where integral term grows too large, causing overshoot.
Using too small dt or inconsistent loop timing breaks derivative calculation.
Not tuning PID constants for your specific drone and sensors.

Always test PID tuning in safe conditions and adjust constants gradually.

python

class PIDController:
    def __init__(self, Kp, Ki, Kd):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.integral = 0
        self.previous_error = 0
        self.integral_limit = 100  # Prevent integral windup

    def update(self, setpoint, measured_value, dt):
        error = setpoint - measured_value
        self.integral += error * dt
        # Clamp integral to prevent windup
        if self.integral > self.integral_limit:
            self.integral = self.integral_limit
        elif self.integral < -self.integral_limit:
            self.integral = -self.integral_limit
        derivative = (error - self.previous_error) / dt if dt > 0 else 0
        output = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
        self.previous_error = error
        return output

📊

Quick Reference

Kp: Adjusts response strength to current error.
Ki: Corrects steady-state error over time.
Kd: Dampens oscillations by reacting to error changes.
Keep loop time (dt) consistent for stable control.
Test and tune PID constants carefully for your drone model.

✅

Key Takeaways

Use a PID controller to calculate motor adjustments based on error in drone angles.

Tune Kp, Ki, and Kd constants carefully to avoid oscillations and overshoot.

Prevent integral windup by limiting the integral term.

Keep the control loop timing consistent for accurate derivative calculation.

Test PID control in safe environments and adjust gradually.