Feedback Control Fundamentals

An open-loop controller fires a pre-computed command and ignores what actually happens. Spray a fixed voltage on a motor and hope it reaches the right speed. Simple, but brittle — any friction change, load variation, or temperature drift sends the output somewhere unexpected.

A closed-loop controller measures the real output and adjusts. The difference is profound: instead of betting on a perfect model, you correct errors as they arise. Think of driving a car: you don't compute the exact steering angle to stay in your lane — you watch the road and steer continuously. Closed-loop is why spacecraft navigate despite thruster mismatches and why thermostats handle a suddenly opened door. Feedback trades complexity for robustness.

Every closed-loop system has the same five actors:

1. Reference $r(t)$ — the desired output (setpoint). "I want the arm at 90°."
2. Error $e(t) = r(t) - y(t)$ — how far off you are right now.
3. Controller $C(s)$ — computes the control action $u(t)$ from $e(t)$.
4. Plant $P(s)$ — the physical system being controlled (motor, arm, heater).
5. Sensor — measures the true output $y(t)$ and feeds it back.

The controller never touches the plant directly; it only ever sees the error signal. That signal encodes everything: if $e > 0$ the output is too low, if $e < 0$ it overshot. Sensor accuracy matters enormously — feedback is only as good as your measurement.

The canonical feedback loop: reference enters on the left, sensor closes the loop on the bottom.

Feedback serves two distinct jobs, and good controller design must handle both.

Setpoint tracking: The reference changes (e.g., a new joint angle is commanded). The controller must drive $e \to 0$ quickly and smoothly. Fast tracking is good; oscillation on the way is not.

Disturbance rejection: Something hits the plant from outside — a gust of wind, a load dropped onto a conveyor, a temperature spike. The controller must sense the output deviation and correct it without being told anything about the disturbance. This is feedback's killer advantage: it compensates for disturbances it has never seen.

A badly designed controller can excel at one and fail at the other. High-bandwidth designs track fast but amplify sensor noise; low-bandwidth designs reject noise but respond sluggishly to disturbances.

Engineers characterize a closed-loop step response with four numbers:

These metrics pull in opposite directions. Aggressive gains shrink $t_r$ but balloon %OS. Adding integral action zeroes $e_{ss}$ but may slow $t_s$. Real control design is managing these trade-offs, not maximizing a single metric.

A controller that reduces steady-state error but drives the plant into growing oscillations is worse than useless — it is dangerous. Stability means the output remains bounded and eventually settles.

For a linear system, stability is determined by the poles of the closed-loop transfer function $T(s) = \frac{C(s)P(s)}{1 + C(s)P(s)}$. Poles in the left half-plane → stable (decaying transients). Poles in the right half-plane → unstable (exponentially growing). Poles on the imaginary axis → marginally stable (sustained oscillation).

Practical stability margins — gain margin and phase margin — tell you how much you can perturb the loop gain or phase before instability. A phase margin below ~30° usually means the system will ring badly under any small model error.

The closed-loop transfer function $T(s) = \frac{CP}{1+CP}$ has a remarkable property: when the loop gain $|CP| \gg 1$, $T(s) \approx 1$ regardless of what $P$ does. The plant's exact dynamics are divided away by the feedback. Halve the motor's torque constant? The controller sees more error and applies more effort, largely compensating.

Open-loop control requires a precise model — any mismatch translates directly into error. Feedback inverts this: the controller corrects in real time, so only the sensor noise and bandwidth matter, not the perfect knowledge of every friction coefficient and moment of inertia. This is why feedback is the backbone of every production robot: you cannot model everything, but you can always measure and correct.

Suppose you want a DC motor to hold a joint at $r = 90°$. A proportional feedback law:

$u(t) = K_p \, e(t) = K_p \bigl(r - y(t)\bigr)$

At $t=0$, the error is large so the motor gets a big command. As the joint approaches 90°, the error shrinks and so does the command — the motor naturally decelerates. If $K_p$ is too small, the response is sluggish. Too large, and the motor overshoots, corrects, overshoots again — oscillation.

# Minimal proportional position control simulation
import numpy as np

Kp = 5.0          # proportional gain
dt = 0.01         # time step (s)
y  = 0.0          # initial angle (deg)
r  = 90.0         # setpoint (deg)

for _ in range(500):
    e = r - y
    u = Kp * e    # control signal
    y += u * dt   # first-order plant: dy/dt = u
    print(f"y={y:.2f}  e={e:.2f}")

This tiny loop captures the full feedback idea: measure, compute error, act, repeat.

Feedback control is engineering's most powerful idea for managing uncertainty. The loop — reference, error, controller, plant, sensor — is replicated in every autopilot, thermostat, and robotic joint on the planet.

Key takeaways:

• Open-loop is fragile; closed-loop corrects errors automatically.
• Error $e = r - y$ is the fundamental signal driving the controller.
• Performance is measured by rise time, overshoot, settling time, and steady-state error.
• Stability is non-negotiable; gain and phase margins quantify robustness.
• Feedback robustness comes from the $1/(1+CP)$ denominator suppressing plant uncertainty.

Next: we'll attach specific math to the controller block — the PID controller — which is how 95% of industrial loops are actually implemented.