Active Disturbance Rejection Control

If you know PID, you already know 80% of what you need. This explains the other 20% — and why ADRC often does better with less tuning.

On this page: the shift from PID · the model · the three pieces · the math · PID ↔ ADRC · tuning · b₀ per plant · try it

1. The idea, in one shift of mindset

A PID controller is fundamentally reactive: a disturbance pushes the output off target, an error appears, and PID responds to that error. The integral term eventually cancels steady offsets, but only after they've built up.

ADRC turns this around: it estimates the disturbance as it happens and cancels it directly, leaving only a simple, well-behaved system for a basic feedback law to steer.

The clever part is how broadly "disturbance" is defined. It isn't just an external push — it's everything the controller doesn't explicitly model: friction, drag, gravity, coupling between axes, the parts of the true nonlinear plant you ignored, and the external load. All of it gets bundled into a single signal called the total disturbance, estimated live, and subtracted from the control.

2. The model: every plant is a double integrator + "everything else"

Whatever the real plant is, ADRC writes it in one canonical form:

• y — the output you control (position, angle, …)
• u — the control signal you command
• b₀ — the input gain: how strongly u accelerates y
• f — the total disturbance: literally everything else, lumped together

Example — the car in the simulator: ẍ = u − (b/m)·ẋ. Here b₀ = 1 and the drag term −(b/m)·ẋ is simply part of f. You never have to know the mass or drag coefficient — ADRC measures their net effect and cancels it.

3. The three pieces

Read the diagram left-to-right along the top — that's the control path, the same shape as a PID loop. The block underneath is the observer; its three estimates (ẑ₁, ẑ₂, ẑ₃) feed back up into the control path.

① Extended State Observer (ESO) — the heart of ADRC

A small model that runs in parallel with the real plant and, from only the command u and the measurement y, continuously estimates three things:

• ẑ₁ ≈ y — the output (a smooth, de-noised version of the measurement)
• ẑ₂ ≈ ẏ — its rate of change (a clean, model-based derivative)
• ẑ₃ ≈ f — the total disturbance (the "extended" state — the magic one)

② State-feedback control law

A plain PD controller acting on the estimated states — what acceleration we'd like:

③ Disturbance rejection + scaling

Cancel the estimated disturbance and divide by the input gain to get the actual command:

The − ẑ₃ is the move that makes it "active disturbance rejection": the controller subtracts off whatever the observer believes is pushing the plant — drag, gravity, a shove — before the error has a chance to grow.

4. The math, exactly as implemented

Discrete update each timestep dt, for a second-order plant (input → output through two integrations — true of every plant in the simulator). See src/engine/adrcController.js.

# Extended State Observer  (gains place its 3 poles at −ωo):
e   = ẑ₁ − y
ẑ₁ += dt · ( ẑ₂ − 3·ωo·e )
ẑ₂ += dt · ( ẑ₃ − 3·ωo²·e + b₀·u )
ẑ₃ += dt · (        − ωo³·e )

# Control law  (gains place the closed loop at (s + ωc)²):
u₀ = ωc²·(r − ẑ₁) − 2·ωc·ẑ₂
u  = (u₀ − ẑ₃) / b₀          then clamp to [u_min, u_max]

Three implementation details that matter:

• The observer is driven by the actual, saturated u — feeding it the clamped command is ADRC's built-in anti-windup.
• ẑ₁ is seeded to the first measurement so there's no startup jump.
• For angular plants (servo, pendulum) the errors are wrapped to (−180°, 180°], so the ±180° seam is a small error, not a near-full-circle one.

5. Translating your PID intuition

The integral action you'd reach for in PID to reject a constant load is replaced by the live ẑ₃ estimate. That's why, on the simulator's cart-pole, an ADRC nudge recovers with a much smaller swing than PID: it cancels the shove instead of waiting for the error to accumulate.

6. How to tune it

Only three knobs, and a reliable order to set them:

1. Set b₀ from physics first. It's "how much ÿ you get per unit u." You only need it within a factor of ~2 — the ẑ₃ term absorbs the rest. Symptoms of a bad b₀: too large → sluggish; too small → twitchy / oscillatory.
2. Set ωc (controller bandwidth) for the response speed you want. Bigger ωc → faster (rough rule: settling time ≈ 4–6 ⁄ ωc). Push until the control effort saturates or motion gets too aggressive, then ease back.
3. Set ωo (observer bandwidth) to about 3–10× ωc. The observer must out-run the loop so its disturbance estimate stays ahead. Raise it for crisper rejection; lower it if measurement noise starts making u chatter. ωo is the main noise ↔ rejection trade-off.

7. b₀ per plant — the one number that changes

b₀ = ∂ÿ/∂u, read straight off each plant's equation of motion. The bandwidths ωc, ωo are similar across plants; b₀ is the plant-specific one, which is why each model ships its own default.

8. Try it in the simulator

• Watch ẑ₃. Hover the block diagram for tooltips. Apply a disturbance and watch the live ẑ₃ (dist) value track it — that's ADRC "seeing" the load.
• Read the control-split chart. The disturbance-rejection trace (−ẑ₃/b₀) shows how much of u is fighting the disturbance vs the feedback trace doing setpoint tracking. Clean step → feedback dominates; under load → rejection carries it.
• Sweep ωo. On any plant, raise it and watch disturbance rejection sharpen (and noise creep into u); lower it and watch it soften.
• Cart-pole. ADRC folds the unstable gravity term into f and cancels it — raise ωo and the balance visibly stiffens. Click left/right to nudge it.

→ Open the simulator