PID controllers

Why this matters

The textbook PID formula is short, but a controller that really flies must handle things the formula does not mention: commands beyond the motors’ limits, sudden setpoint changes and sensor noise. Chapter 11 of Åström and Murray (2021) and Åström and Hägglund (2006) cover these in detail, and PX4 uses the same techniques in its own control loops.

Two forms of PID

• Parallel form: three separate gains $K_p,K_i,K_d$.
• Standard (ideal) form: an overall gain $K$ multiplying all three terms.

The PX4 PID tuning guide explains that the rate loop supports both: setting MC_ROLLRATE_K = 1 gives the parallel form, while setting P = 1 gives the standard form, which separates the overall gain from the I and D tuning. Know which form is in use before borrowing gains from elsewhere.

Integral windup

Motors can only give so much thrust. When the command exceeds the limit, the actual signal saturates, but the I term keeps accumulating error. Once the target is reached, the large accumulated I pushes far past it: integral windup. Two common fixes:

• Clamping: stop integrating while saturated and the error still pushes the same way. PX4 uses this in its velocity loop (Controller Diagrams).
• Back-calculation: feed the difference between the command and the saturated value back to reduce I (Åström and Murray, section 11.4).

KP, KI, KD, AMAX, DT = 1.5, 0.4, 2.0, 3.0, 0.01

def climb(anti_windup):
    z = v = integ = 0.0
    zs = []
    for _ in range(int(40 / DT)):
        e = 10 - z
        a_cmd = KP * e + KI * integ - KD * v
        a = max(-AMAX, min(AMAX, a_cmd))
        pushing_further = (a_cmd > AMAX and e > 0) or (a_cmd < -AMAX and e < 0)
        if not (anti_windup and pushing_further):
            integ += e * DT
        v += a * DT
        z += v * DT
        zs.append(z)
    settle = next(i * DT for i in range(len(zs)) if all(abs(x - 10) <= 0.2 for x in zs[i:]))
    return max(zs) - 10, settle

for label, flag in (("without anti-windup", False), ("with clamping", True)):
    over, ts = climb(flag)
    print(f"{label:<20} overshoot {over:.2f} m, within 0.2 m after {ts:.1f} s")

without anti-windup  overshoot 4.14 m, within 0.2 m after 11.0 s
with clamping        overshoot 1.58 m, within 0.2 m after 9.8 s

Derivative on measurement and filtering

If the D term uses the error, a setpoint step makes the derivative spike momentarily. Åström and Murray recommend applying D (and possibly P) to the measurement instead, called setpoint weighting. Also, the derivative amplifies high-frequency noise, so it must be filtered: $K_{d}s/(1+s{T}_f)$ with $T_f=T_d/N$ and $N$ around 5–20. PX4 applies a low-pass filter to the D term of the rate loop.

KP, KD, DT, N = 1.5, 2.0, 0.01, 10
TF = (KD / KP) / N                     # s derivative filter time constant

steps = [0.0, 10.0, 10.0, 10.0]        # setpoint at each time step
meas = [0.0, 0.0, 0.02, 0.08]          # measurement (just starting to move)

def d_term(signal, sign, filtered):
    d, peak = 0.0, 0.0
    for k in range(1, len(signal)):
        raw = sign * KD * (signal[k] - signal[k - 1]) / DT
        d = d + DT / (TF + DT) * (raw - d) if filtered else raw
        peak = max(peak, abs(d))
    return peak

err = [r - y for r, y in zip(steps, meas)]
print(f"D on error, unfiltered:   peak {d_term(err, 1, False):7.1f}")
print(f"D on error, filtered N={N}: peak {d_term(err, 1, True):7.1f}")
print(f"D on measurement, filtered: peak {d_term(meas, -1, True):7.1f}")

D on error, unfiltered:   peak  2000.0
D on error, filtered N=10: peak   139.5
D on measurement, filtered: peak     1.1

Tuning order

The PX4 guide says to tune the rate loop first, because it affects every flight mode, then the attitude, velocity and position loops. Test with step inputs while hovering; the guide says a well-tuned drone follows immediately without oscillating or overshooting. General guidance:

• P speeds up the response, but too much causes oscillation.
• I removes steady error, such as an offset centre of gravity, but too much causes slow overshoot.
• D damps oscillation but amplifies noise, so filter it and watch motor temperature.

Module lab

Common mistakes

Summary

• PID comes in parallel and standard forms; know which the autopilot uses.
• Clamping or back-calculation anti-windup reduces overshoot under saturation.
• Use derivative on measurement and a filter with $T_f=T_d/N$ ($N$ = 5–20).
• Tune the rate loop first, then the outer loops.

Check your understanding

1. A standard-form PID has $K=2$, $T_i=4$ s. What is $K_i$ in parallel form?
2. When does integral windup occur?
3. With $K_d=2$, $K_p=1.5$ and $N=10$, what is $T_f$?
4. Why compute the D term from the measurement rather than the error?
5. Which loop does the PX4 guide say to tune first?