Ordinary Differential Equations (16): Fundamentals of Control Theory

When you steer a car you constantly correct based on lane position. A thermostat compares room temperature with the setpoint and adjusts a heater. A rocket gimbal nudges its thrust vector to keep the booster vertical. Strip away the hardware and the same idea remains: measure, compare, act. Control theory is the mathematics of that loop — and its native language is the ordinary differential equation.

This chapter shows how the entire ODE toolkit — Laplace transforms (Ch 4), linear systems (Ch 6), eigenvalue stability (Ch 7), nonlinear stability (Ch 8) — collapses into a single unified discipline whose job is no longer to describe dynamics, but to design them.

What You Will Learn#

• Open-loop vs. closed-loop control: why feedback is the central idea
• Transfer functions and how they convert ODEs into algebra
• PID controllers and Ziegler-Nichols tuning
• Root locus: how closed-loop poles move with controller gain
• Bode plots, gain margin, phase margin
• State-space representation of MIMO systems
• Controllability, observability, and the rank tests
• Pole placement and LQR optimal control on an inverted pendulum
• Luenberger observers and the separation principle

Prerequisites#

• Chapter 4 — Laplace transforms (where transfer functions come from)
• Chapter 6 — Linear systems and matrix exponential
• Chapter 7 — Eigenvalue criteria for linear stability

Open Loop vs Closed Loop#

Suppose we want a heater to bring a room from 15°C up to 22°C.

Open loop: send a fixed power $u(t)$ for a fixed time. If the window is open, or the outside is colder than expected, you arrive at the wrong temperature — with no recourse.

Closed loop: measure the temperature, compute the error $e(t) = r(t) - y(t)$ between the reference $r$ and the measured output $y$ , and choose $u(t)$ as a function of $e$ . The system self-corrects against modelling errors and disturbances.

Two consequences of feedback we will derive precisely:

• Disturbance rejection — a step disturbance no longer drives a steady-state error to infinity.
• Sensitivity reduction — relative variations in the plant $G$ affect the closed-loop transfer function $T = CG/(1+CGH)$ by a factor $S = 1/(1+CGH)$ , the sensitivity function.

Transfer Functions#

is the Laplace ratio at zero initial conditions. ODE differentiation becomes multiplication by $s$ , integration becomes division — algebra replaces calculus.

First-order plant#

Step response: $y(t) = K(1 - e^{-t/\tau})$ . Time constant $\tau$ governs how quickly the system tracks a setpoint change.

Second-order plant#

The damping ratio $\zeta$ controls the qualitative shape of the response:

These four cases recur everywhere — circuits, mechanical systems, biology — because every linear system near a stable equilibrium looks like this.

PID Controllers#

Each term has a clean physical role:

• Proportional ($K_p$ ) — a “spring” pulling the output toward the setpoint. Fast but cannot eliminate steady-state error against a constant disturbance.
• Integral ($K_i$ ) — a “memory” that builds while the error is non-zero. Drives steady-state error to exactly zero, but adds a pole at the origin (slows response and risks overshoot).
• Derivative ($K_d$ ) — a “damper” that responds to predicted future error. Improves transient behaviour but amplifies high-frequency measurement noise.

Ziegler-Nichols tuning (a starting point)#

A pragmatic recipe that requires no model:

1. Set $K_i = K_d = 0$ . Increase $K_p$ until the closed-loop response sustains an oscillation — record the ultimate gain $K_u$ and the oscillation period $T_u$ .
2. PID gains:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import numpy as np

class PIDController:
    """Discrete-time PID with optional derivative-on-measurement and
    anti-windup clamping. Use compute(error, dt) each sampling period."""
    def __init__(self, Kp, Ki, Kd, u_min=-np.inf, u_max=np.inf):
        self.Kp, self.Ki, self.Kd = Kp, Ki, Kd
        self.u_min, self.u_max = u_min, u_max
        self.integral = 0.0
        self.prev_error = 0.0

    def compute(self, error, dt):
        self.integral += error * dt
        deriv = (error - self.prev_error) / dt if dt > 0 else 0.0
        self.prev_error = error
        u = self.Kp*error + self.Ki*self.integral + self.Kd*deriv
        # anti-windup: only integrate when not saturated
        if u > self.u_max:
            self.integral -= error * dt
            u = self.u_max
        elif u < self.u_min:
            self.integral -= error * dt
            u = self.u_min
        return u

Root Locus — where the closed-loop poles go#

The root locus plots the closed-loop pole positions in the complex plane as the gain $K$ sweeps from $0$ to $\infty$ . It tells you, visually, the trade-off between speed (poles further left) and damping (poles closer to the real axis).

Two facts to memorize:

• The locus has $n_p - n_z$ asymptotes departing the centroid $\sigma_a = (\sum p_i - \sum z_i)/(n_p - n_z)$ at angles $(2k+1)\pi/(n_p - n_z)$ .
• Where the locus crosses the imaginary axis, the loop has poles $\pm j\omega_c$ — exactly the neutral stability point. Routh-Hurwitz delivers $K_{\text{crit}}$ algebraically.

Bode Plots and Stability Margins#

The frequency response $L(j\omega)$ — the same transfer function evaluated on the imaginary axis — has two natural readouts: magnitude (in dB) and phase (in degrees) versus $\omega$ on a log scale.

• Gain margin (GM): how much we can scale $L$ before instability — read off the magnitude at $\omega_p$ .
• Phase margin (PM): how much extra phase lag we can tolerate at $\omega_g$ before the system loses stability.

Rules of thumb: GM > 6 dB (a factor of 2) and PM > 30° (preferably > 45) for a robust design. The Nyquist contour on the right makes the geometric picture explicit: stability requires that the contour does not encircle the critical point $-1 + 0j$ .

State-Space Representation#

Here $\mathbf x \in \mathbb R^n$ is the state vector — enough information to predict the future given $\mathbf u(t)$ . $A$ is the dynamics matrix, $B$ couples the inputs in, $C$ extracts the measured outputs, and $D$ is direct feedthrough (often zero).

Stability, controllability, observability#

Three rank conditions tell you everything about whether you can design a controller at all:

Controllability says you can drive the state to any target with a suitable input. Observability says you can deduce the full state from the output history. They are dual properties under $A \leftrightarrow A^T,\,B \leftrightarrow C^T$ .

Pole Placement and LQR#

If $(A, B)$ is controllable, the state-feedback law $\mathbf u = -K\mathbf x$ produces closed-loop dynamics $\dot{\mathbf x} = (A - BK)\mathbf x$ . We can choose $K$ to put the eigenvalues of $A - BK$ wherever we like.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import numpy as np
from scipy.signal import place_poles

A = np.array([[0, 1, 0, 0],
              [0, -0.1, -1.96, 0],
              [0, 0, 0, 1],
              [0, 0.2, 23.5, 0]])  # inverted pendulum, linearised
B = np.array([[0], [1], [0], [-2]])

K_pp = place_poles(A, B, [-1, -2, -3, -4]).gain_matrix
print('Pole-placement gain K =', K_pp)
print('Closed-loop eigenvalues =', np.linalg.eigvals(A - B @ K_pp))

1
2
3
4
5
6

from scipy.linalg import solve_continuous_are

Q = np.diag([10, 1, 100, 1])      # penalise position and angle heavily
R = np.array([[1.0]])              # modest control penalty
P = solve_continuous_are(A, B, Q, R)
K_lqr = np.linalg.solve(R, B.T @ P)

Compared to pole placement, LQR almost always uses less actuator effort to achieve the same disturbance rejection — and its gains are guaranteed to be stabilising whenever $(A, B)$ is stabilisable and $(A, \sqrt{Q})$ is detectable.

Observers and the Separation Principle#

The estimation error $\tilde{\mathbf x} = \mathbf x - \hat{\mathbf x}$ obeys $\dot{\tilde{\mathbf x}} = (A - LC)\tilde{\mathbf x}$ . If $(A, C)$ is observable, we can place the eigenvalues of $A - LC$ wherever we like — pick them faster than the controller poles so that estimation settles before the controller acts.

The miraculous separation principle says that the closed-loop poles of controller + observer are exactly the union of the controller poles (eigenvalues of $A - BK$ ) and the observer poles (eigenvalues of $A - LC$ ). You can design the two pieces independently.

Worked Example: Inverted Pendulum on a Cart#

Look at $\mathbf{eigvals}(A)$ : one of them sits in the right half-plane (the open-loop pendulum falls). We compute $K_{\text{LQR}}$ from the Riccati equation (above), then simulate $\dot{\mathbf x} = (A - BK)\mathbf x$ from a $0.2$ -rad initial tilt. The bottom row of the state-space figure shows the angle decaying smoothly to zero, the cart settling to the origin, and the actuator effort dropping to a small steady push — the full design loop in fewer than 30 lines of Python.

The Modern Picture#

What we have done in this chapter is replay the ODE story with a goal. Stability theory (Ch 7-8) said whether a system equilibrium survives small perturbations; control theory says how to engineer the equilibrium and the convergence rate to it. The same Laplace transform that gave us closed-form solutions in Chapter 4 now gives us frequency-domain robustness margins. The same matrix exponential from Chapter 6 now powers state-space simulation and observer design.

The frontier extends beyond what we covered:

• Robust control — $H_\infty$ , $\mu$ -synthesis: certify performance under bounded modelling error.
• Adaptive and model-predictive control (MPC) — the controller updates online using a moving-horizon optimisation.
• Nonlinear control — feedback linearisation, sliding mode, control Lyapunov functions.
• Reinforcement learning — the controller is learned from experience rather than designed; ties back to Chapter 18 ’s Neural ODEs.

Summary#

Control theory promotes ODEs from description to design. We no longer just predict how a system will move — we tell it where to go.

References#

• Ogata, Modern Control Engineering, Pearson (2010).
• Franklin, Powell & Emami-Naeini, Feedback Control of Dynamic Systems, Pearson (2015).
• Astrom & Murray, Feedback Systems, Princeton (2008). (Free PDF.)
• Skogestad & Postlethwaite, Multivariable Feedback Control, Wiley (2005).

Previous Chapter: Chapter 15: Population Dynamics

Next Chapter: Chapter 17: Physics and Engineering Applications

This is Part 16 of the 18-part series on Ordinary Differential Equations.