Why a model — and why a ratio?
Imagine you are tuning the cruise control on a car. You press a little harder on the throttle pedal; a few seconds later the speed creeps up. Press harder still and it climbs faster. Somewhere inside that car is a *relationship* — a rule that turns pedal position (the input) into speed (the output). You cannot steer what you cannot predict, so before any controller can be designed, that relationship has to be written down. That written-down rule is what engineers call a model.
The honest physics of that car is a differential equation: forces, inertia, drag, all tangled together with derivatives. Differential equations are powerful but clumsy to manipulate — to combine two of them you have to solve, substitute, and pray. The great trick of control engineering is to run every signal through the Laplace transform, which turns d/dt into a tidy multiplication by s. In that transformed world a whole differential equation becomes an *algebraic* equation, and the input–output rule becomes a simple ratio of two polynomials.
That ratio is the transfer function, written G(s) = Y(s) / X(s) — the Laplace transform of the output divided by the Laplace transform of the input, assuming the system starts at rest. It is the single most important object in this entire track. Every later tool you will meet — poles and zeros, the root locus, the Bode plot — is just a different way of *reading* G(s). Learn to write it and you have unlocked all of them at once.
Worked example 1: an RC circuit becomes G(s)
Let's earn the formula with the humblest circuit in electronics: a resistor R in series with a capacitor C, with the output taken across the capacitor. Drive the input with voltage v_in(t); read the output v_out(t) across C. This little RC pair is a low-pass filter, the heartbeat of every audio tone control and sensor smoother — and it is the perfect first plant to model.
R
v_in o──[ /\/\/ ]──┬──────o v_out
│
─┴─ C (current i flows through both)
───
│
GND o──────────────┴──────o GND
Same current i in R and C -> one differential equation links v_in and v_out.Two physical facts are all we need. First, the same current i flows through both parts (it's a series loop). Second, Kirchhoff's voltage law says the input is split between the resistor and the capacitor: v_in = i·R + v_out. The current into a capacitor is i = C · dv_out/dt — that derivative is where the *dynamics*, the lag, the personality of the system, all come from. Substitute it in and you get one clean differential equation.
Time domain: v_in(t) = R·C · dv_out/dt + v_out(t)
Apply Laplace ( d/dt -> s , zero initial charge ):
V_in(s) = R·C·s·V_out(s) + V_out(s)
= (R·C·s + 1) · V_out(s)
Transfer function:
V_out(s) 1
G(s) = ──────── = ───────────── ( let tau = R·C )
V_in(s) R·C·s + 1
1
= ───────────────
tau·s + 1Look at what just happened. A circuit, a piece of physical hardware, has been compressed into the symbol 1/(τs + 1). The product τ = RC is the time constant — with R = 10 kΩ and C = 1 µF, τ = 10 ms, so the filter takes about 50 ms (five time constants) to fully settle after a jolt. That one number, baked right into G(s), already tells you the speed of the system before you draw a single graph.
Worked example 2: the mass-spring-damper — and why control is universal
Now leave electronics entirely. Picture a block of mass m on a table, tied to the wall by a spring (stiffness k) and a shock absorber (damping b). You push it with a force f(t); it responds with a displacement x(t). This is a car suspension, a building swaying in wind, a robot arm settling onto a target — and it should have *nothing* to do with the RC circuit above. Watch what the same recipe does to it.
wall ║ Newton's second law:
║ /\/\/\ spring k ┌──────┐
║─────────────────┤ m │ ── f(t) push m·x'' + b·x' + k·x = f(t)
║ ===[ damper b ]==┤ │ -> x(t)
║ └──────┘ (x'' = acceleration, x' = velocity)
Laplace (rest start): (m·s^2 + b·s + k) · X(s) = F(s)
X(s) 1
G(s) = ───── = ───────────────────
F(s) m·s^2 + b·s + kThere it is — the punchline of the whole rung. The RC circuit gave a *first-order* G(s) (one power of s); the mass-spring-damper gives a *second-order* G(s) (an s² term, because acceleration is a second derivative). But both are nothing more than 1 / (polynomial in s). A thermal plant — an oven whose temperature lags the heater — produces the very same algebra. Electrical, mechanical, thermal: once they wear the costume of a transfer function, the mathematics cannot tell them apart.
Block-diagram algebra: snapping the boxes together
A real system is never one box. The cruise control has an amplifier, then a motor, then the car body — three transfer functions chained nose to tail. A block diagram draws each as a labelled box with an arrow in and an arrow out, and the beauty of working in the s-domain is that combining them is pure schoolbook algebra. There are only three rules you ever need, and the third is the whole reason control exists.
(1) SERIES (cascade) — outputs feed inputs, gains multiply:
X ──►[ G1 ]──►[ G2 ]──► Y G_total = G1 · G2
(2) PARALLEL — same input, outputs add:
┌►[ G1 ]┐
X ──┤ (+)──► Y G_total = G1 + G2
└►[ G2 ]┘
(3) FEEDBACK (closed loop) — the big one:
X ─►(+)──►[ G ]──┬──► Y G
▲ │ G_total = ───────────
│ │ 1 + G·H
└──[ H ]◄──┘ (negative feedback)The first two rules are obvious once you see them: chained boxes multiply their gains (a 10× amplifier into a 3× stage is 30×), and parallel paths add. The third is the jewel. Take the forward path G, feed the output back through a measuring block H, and subtract it from the input — that is exactly the feedback loop from rung 1. A short loop of algebra collapses the whole tangle into a single closed-loop transfer function.
Derivation of the closed-loop formula (negative feedback):
error E = X - H·Y (input minus measured output)
output Y = G·E (forward path acts on the error)
Substitute E: Y = G·(X - H·Y)
Y = G·X - G·H·Y
Y + G·H·Y = G·X
Y·(1 + G·H) = G·X
Y G
───── ─── = ─────── <- closed-loop transfer function
X 1 + G·HPutting it together: a full loop in one symbol
Let's reduce a complete control loop and feel the machinery click. Suppose a controller K (a plain gain for now) drives our RC plant G(s) = 1/(τs+1), and we measure the output perfectly so H = 1. Plug the pieces into series-then-feedback and watch the closed loop emerge as a single, readable transfer function.
Forward path: K · G(s) = K / (tau·s + 1)
Feedback: H = 1 (unity feedback)
Closed loop:
K·G K/(tau·s+1)
T(s) = ───────── = ────────────────────
1 + K·G 1 + K/(tau·s+1)
Multiply top & bottom by (tau·s + 1):
K K/(1+K)
T(s) = ───────────────── = ──────────────────────
tau·s + 1 + K [tau/(1+K)]·s + 1
New time constant: tau' = tau / (1 + K) <- feedback made it FASTERRead the result. Closing the loop did two things at once: it sped the system up (the time constant shrank by a factor of 1+K) and it changed where the pole sits (from s = -1/τ to s = -(1+K)/τ, sliding deeper into the stable left half-plane). Crank K higher and the system reacts faster still — for a moment it looks like free performance. The next rungs reveal the catch: on higher-order plants, too much gain drags poles toward instability, and the whole art of control is choosing K wisely. But the *object* you tune is always this one — a transfer function you built with three steps of algebra.
- Write each block's transfer function from its physics (RC, mass-spring, motor, controller K).
- Multiply boxes in series to collapse the forward path into one G(s).
- Apply the feedback formula G/(1+GH) to fold the loop into one closed-loop T(s).
- Read its denominator: those roots are the poles that decide stability and speed — the subject of the next rung.