M5-T6: PID controllers

Learning objectives

After this lesson, you should be able to:

• Explain the effect of the $P$, I and $D$ terms and of each on stability and steady-state error.
• Describe the cascaded structure of a multirotor controller and why inner loops must be faster.
• Implement a PID with derivative filtering and anti-windup.
• Tune an attitude loop on a simulated plant and measure rise time, overshoot and settling.

Conceptual explanation

A PID controller computes a command from the error $e=r-y$: $P$ pushes proportionally to the error, I accumulates the error to remove steady offsets, $D$ reacts to the rate of change to add damping.

A multirotor cascades loops because its dynamics do: torque changes angular rate, rate changes attitude, attitude changes acceleration, acceleration changes velocity and position. Each stage is one integrator from the next, and each can be tuned separately.

Engineering intuition

Think of $P$ as a spring, $D$ as a damper, and I as a slowly tightening bias that lifts the vehicle against a constant load such as wind or an off-centre battery. A spring alone oscillates; add damping to calm it; add an integrator to remove the remaining offset, but be gentle: an integrator is a source of lag and a classic cause of overshoot after saturation.

The key engineering rule: inner loops must be faster than outer loops, by a factor of roughly 3–10. An outer loop that tries to move faster than the inner loop can follow sees phase lag and oscillates. When a UAV “wobbles” slowly, the outer loop is too aggressive; when it buzzes, the inner derivative gain is too high or the signal is noisy.

Mathematical formulation

The PID law

Derivative on measurement with filtering

Differentiating a noisy measurement amplifies noise, and differentiating the error makes the output kick on every setpoint step. Use the derivative of the measurement, low-pass filtered with time constant $\tau _{f}$ (often $T_{d}/N$ with $N$ in 5–20):

Anti-windup

When the actuator saturates, the integrator keeps accumulating and then must be “unwound” after saturation ends, causing overshoot. Two standard fixes are clamping (stop integrating when saturated and the error would push further into saturation) and back-calculation (feed the saturation difference back into the integrator):

Attitude loop as an example

For the rotational plant $J\,\dot{\omega }=\tau$ with $\dot{\theta }=\omega$, a PD law $\tau =J(K_{p}\,e-K_{d}\,\omega )$ gives $\ddot{\theta }+K_{d}\,\dot{\theta }+K_{p}\,\theta =K_{p}\,\theta _{\text{ref}}$, a second-order system with natural frequency $\omega _{n}=\sqrt{K_{p}}$ and damping ratio $\zeta =K_{d}/(2\sqrt{K_{p}})$. The Quadrotor Dynamics Simulator uses exactly this structure. Choose $\zeta \approx 0.7\text{–}1$ and $\omega _{n}$ within what the motors and their lag can deliver.

Architecture and data flow

In PX4 the cascade runs as separate modules (position and velocity control in the multicopter position controller; attitude and rate control in their own modules), each with its own parameters. The rate loop runs fastest on the main flight-controller loop; position loops run slower. Knowing where to look for each loop’s gains is the first debugging step: consult the PX4 multicopter PID tuning guide for the exact parameters of your version.

Real-world UAV applications

• Attitude and rate stabilisation in every multirotor autopilot.
• Altitude hold with barometer and accelerometer inputs.
• Gimbal and camera stabilisation.
• Baseline against which LQR and MPC results are judged (lessons M5-T7, M5-T8).

Implementation example

This runs as shown. A PID with filtered derivative-on-measurement and back-calculation anti-windup controls a double-integrator attitude plant with a torque limit. The test shows the windup problem and its fix.

import numpy as np

class PID:
    def __init__(self, kp, ki, kd, dt, umax, tau_f=0.02, kt=None):
        self.kp, self.ki, self.kd, self.dt, self.umax = kp, ki, kd, dt, umax
        self.alpha = tau_f / (tau_f + dt); self.d = 0.0; self.I = 0.0; self.y_prev = None
        self.kt = kt                                            # None: no anti-windup
    def __call__(self, r, y):
        e = r - y
        dy = 0.0 if self.y_prev is None else (y - self.y_prev) / self.dt
        self.y_prev = y
        self.d = self.alpha * self.d + (1 - self.alpha) * dy       # filtered derivative of the MEASUREMENT
        u = self.kp * e + self.I - self.kd * self.d
        u_sat = float(np.clip(u, -self.umax, self.umax))
        self.I += self.ki * self.dt * e
        if self.kt is not None: self.I += self.kt * self.dt * (u_sat - u)   # back-calculation
        return u_sat

def simulate(kt, step=1.0, T=8.0, dt=0.002, J=0.01, umax=0.06):
    pid = PID(kp=0.12, ki=0.15, kd=0.03, dt=dt, umax=umax, kt=kt)
    th = w = 0.0; hist = []
    for k in range(int(T / dt)):
        tau = pid(step if k * dt > 0.5 else 0.0, th)
        w += tau / J * dt; th += w * dt
        hist.append(th)
    hist = np.array(hist)
    return hist.max() / step - 1, abs(hist[-1] - step)

os_no, err_no = simulate(kt=None)
os_aw, err_aw = simulate(kt=1.0 / 0.05)
print(f"overshoot without anti-windup {100*os_no:.0f}%, with {100*os_aw:.0f}%; final error {err_no:.3f} / {err_aw:.3f} rad")
assert os_aw < os_no                                           # anti-windup reduces overshoot after saturation
assert err_aw < 0.05

Common engineering mistakes

Failure modes

Debugging approach

1. Plot setpoint, measurement and output for each loop; look for ringing frequency to identify which loop is oscillating.
2. Do step tests on one loop at a time with the outer loops open.
3. Inspect the gyro spectrum for frame resonances and add notch filters if needed.
4. Check that the log shows controller saturation flags and compare to integrator state.

Practical exercises

1. Derive $\omega _{n}$ and $\zeta$ for the PD attitude loop and choose gains for $\omega _{n}=20\,\mathrm{rad}/\mathrm{s}$, $\zeta =0.8$.
2. Remove derivative filtering in the code and measure the effect on output noise when the measurement has noise.
3. Add a constant disturbance torque and show that the integral term removes the offset.
4. Use the Quadrotor Dynamics Simulator to find Kp at which the attitude loop starts to oscillate with a 0.12 s motor time constant.

Interview questions

Write an answer in your own words, then reveal the model answer. Nothing is sent anywhere.

References and further reading

Primary papers, official documentation and standards. Each claim above that is specific to a tool or version points here.

• PX4: Multicopter PID tuning guide
• $K$. $J$. Åström, $R$. $M$. Murray, Feedback Systems: An Introduction for Scientists and Engineers, Princeton University Press, 2008 (free online at fbswiki.org).
• ArduPilot Copter: Tuning

What’s next