Poles, Zeros & the Step Response

From algebra to motion: what a pole actually does

Pick up a guitar string, pull it sideways, and let go. It doesn't jump to its resting position — it springs back, overshoots, swings the other way, and decays into stillness over a second or two. A car's suspension does the same when you hit a pothole; so does a drone correcting a gust, a thermostat chasing a setpoint, a hard-drive head slamming to a track. Every one of these is a system released from a disturbance, and every one of them has a characteristic *signature* — how fast, how bouncy, how long until it settles. The astonishing claim of control theory is that this entire signature is encoded in a handful of numbers called poles.

Recall the transfer function H(s) = N(s)/D(s), a ratio of two polynomials in the Laplace variable s. The poles are the roots of the denominator D(s) — the values of s that make H(s) blow up to infinity. The zeros are the roots of the numerator N(s) — the values that make H(s) vanish. Geometrically we drop them onto the complex s-plane: the horizontal axis is the real part σ, the vertical axis is the imaginary part jω. A pole is an ✕, a zero is an ◯. That little constellation of marks *is* the system's personality.

Why does a root of the denominator control *time* at all? Because of one fact about the Laplace transform: a simple pole at s = p contributes a term of the form A·e^(p·t) to the output. The pole *is* the exponent. If you do a partial-fraction expansion of the response, every pole hands you one exponential mode, and the total motion is just the sum of those modes. So reading poles is reading exponents — and an exponent is a complete description of an exponential curve.

Real poles vs. complex pairs: decay vs. ringing

Poles come in exactly two flavours, and the difference is the difference between a closing door and a plucked string. A real pole sits on the horizontal axis, say at s = −3. Its mode is e^(−3t): a pure exponential that slides smoothly toward zero, no bounce, no wobble. The more negative the pole, the faster the decay. A pole at −10 dies more than three times quicker than one at −3, because its time constant τ = 1/|p| is smaller.

A complex-conjugate pair is where the drama lives. Poles with an imaginary part always come in mirror-image pairs, s = −σ ± jω_d (a polynomial with real coefficients can't have a lone complex root). Their two exponential modes, e^((−σ+jω_d)t) and e^((−σ−jω_d)t), combine — via Euler's formula — into a single real, *oscillating* envelope: e^(−σt)·cos(ω_d·t + φ). The real part −σ is the decay rate; the imaginary part ω_d is the damped oscillation frequency in rad/s. So the pair gives you a sine wave whose amplitude shrinks exponentially: ringing that fades. That is exactly the guitar string, the suspension, the overshooting drone.

        jω  (imaginary)
         |        x  ← complex pole at -σ + jω_d
         |       /:
         |      / :  ω_d  (sets oscillation rate)
  STABLE |    /φ  :         UNSTABLE
  (LHP)  |  /     :          (RHP)
 --------+--------+----------------> σ (real)
      -σ |        0
         |  \     :
         |    \   :
         |      \ :
         |        x  ← its mirror twin at -σ - jω_d

  distance from origin ω_n = sqrt(σ^2 + ω_d^2)   (natural frequency)
  angle from -axis     ζ   = cos(angle) = σ / ω_n (damping ratio)

The canonical second-order system

Almost every textbook — and an astonishing amount of real hardware — boils down to one master template, the standard second-order system. Two parameters say it all: the natural frequency ω_n (how fast it would oscillate with no damping, in rad/s) and the damping ratio ζ (a dimensionless number from 0 to ∞ measuring how much the bounce is suppressed). Its closed-loop transfer function is:

                 ω_n^2
  H(s) = -----------------------------
          s^2 + 2·ζ·ω_n·s + ω_n^2

  Poles (roots of denominator):
     s = -ζ·ω_n  ±  ω_n·sqrt(ζ^2 - 1)

  ζ = 0       poles on jω-axis     -> pure, undying oscillation (marginal)
  0 < ζ < 1   complex pair         -> UNDERDAMPED: overshoots, then rings
  ζ = 1       repeated real pole    -> CRITICALLY damped: fastest, no overshoot
  ζ > 1       two distinct real     -> OVERDAMPED: slow, sluggish, no overshoot

  damped frequency:  ω_d = ω_n · sqrt(1 - ζ^2)   (only when ζ < 1)

Watch what ζ does geometrically. At ζ = 0 the poles sit dead on the imaginary axis at ±jω_n — no decay, the system rings forever. As ζ climbs toward 1, the poles swing along a circle of radius ω_n toward the negative-real axis, picking up more and more decay. At ζ = 1 they collide on the real axis (critical damping — the fastest you can go with zero overshoot). Beyond ζ = 1 they split into two separate real poles and the system gets sluggish (overdamped). The single number ζ is literally the cosine of the angle the pole makes with the negative-real axis: ζ = cos(θ).

The four numbers everyone quotes — with real arithmetic

When you stare at a step response on a scope, you're really reading four quantities off the curve. Here are the standard formulas for an underdamped second-order system (0 < ζ < 1), and then we'll plug in real numbers so they stop being symbols.

1. Rise time t_r — roughly how long to first reach the target. A handy approximation: t_r ≈ (1.8) / ω_n. Bigger ω_n, faster rise. (For 0–100% on an underdamped system, t_r = (π − θ)/ω_d, where θ = arccos ζ.)
2. Peak overshoot M_p — how far it shoots past the target, as a fraction: M_p = exp( −ζ·π / sqrt(1 − ζ^2) ). Note it depends ONLY on ζ, not on ω_n. Damping alone sets bounciness.
3. Settling time t_s — when it stays within ±2% of final. t_s ≈ 4 / (ζ·ω_n). The product ζ·ω_n is exactly σ, the real part of the pole — so settling is governed by how far LEFT the poles sit.
4. Peak time t_p — the instant of maximum overshoot: t_p = π / ω_d, where ω_d = ω_n·sqrt(1 − ζ^2) is the damped frequency. Half an oscillation period gets you to the first peak.

WORKED EXAMPLE — a small positioning servo
  Design target: ω_n = 10 rad/s,  ζ = 0.5

  Poles:   s = -ζ·ω_n ± jω_n·sqrt(1-ζ^2)
             = -(0.5)(10) ± j(10)sqrt(1-0.25)
             = -5 ± j8.66          (a complex pair, underdamped)

  Damped frequency:
     ω_d = 10·sqrt(0.75) = 8.66 rad/s

  Rise time (approx):
     t_r ~ 1.8 / 10        = 0.18 s

  Peak overshoot:
     M_p = exp(-0.5*pi / sqrt(1-0.25))
         = exp(-1.5708 / 0.8660)
         = exp(-1.814) = 0.163   ->  16.3% overshoot

  Peak time:
     t_p = pi / 8.66       = 0.363 s

  Settling time (2%):
     t_s = 4 / (0.5*10)    = 0.80 s

  READ-OUT: this servo reaches its target in ~0.18 s,
  overshoots by 16%, peaks at 0.36 s, and rings down
  to within 2% by 0.80 s.  Want less overshoot? Raise ζ.
  Want it all faster? Raise ω_n (push the poles further out).

Notice the clean division of labour. ω_n is the throttle: push the poles radially outward (further from the origin) and every time — rise, peak, settle — shrinks in proportion, while the *shape* stays identical. ζ is the suspension stiffness: rotate the poles toward the real axis and the overshoot collapses without touching the speed scale. Two knobs, two independent effects. This is the whole reason engineers think in (ω_n, ζ) rather than in raw pole coordinates.

Where zeros and pole location change the story

So far poles have written the script. But zeros are co-authors, and they specialise in plot twists. A zero doesn't add a new mode of its own — it *re-weights* the modes the poles already provide, and it can do so dramatically. A zero in the left-half plane that sits *close* to the poles tends to pile on extra overshoot and a sharper, faster rise — the response leans forward. Push the zero far to the left and its influence fades; the second-order formulas above hold cleanly.

The genuinely surprising case is a right-half-plane zero (a positive real zero). It causes inverse response: when you command the output up, it first dips *down* before recovering and climbing to target. This isn't a glitch — it's physics. A bicycle steered left first leans the wrong way; a hydroelectric turbine asked for more power first sees a momentary pressure drop; a boiler's drum level dips when you add cold feedwater before rising. RHP zeros are notoriously hard to control fast, because the system genuinely starts by going the wrong direction. They are a fundamental performance limit, not a tuning problem you can wish away.

And the location of the *poles* themselves draws the hardest line in all of control — the line of stability. It is brutally simple: every pole must lie in the left half of the s-plane (negative real part). Why? Because a pole at s = p gives a mode e^(p·t). If the real part of p is negative, e^(p·t) decays to zero and the system settles. If the real part is positive, e^(p·t) grows without bound — the output runs away to the rails, oscillating bigger and bigger until something saturates, clips, or breaks. A single pole crossing into the right-half plane is the difference between a drone that hovers and a drone that flips over and dives.

Why this is a design tool, not just analysis

Here is the payoff, and the reason this rung matters. Everything so far reads poles to *predict* behaviour. But the real power of feedback control is the reverse: you get to *move the poles wherever you want them*. Wrapping a controller around a plant changes the denominator of the closed-loop transfer function — which means it relocates the poles. Slow plant ringing too much? Add feedback that drags the poles further left and rotates them toward the real axis. The whole design game is: decide where you want the poles (from your specs on overshoot and settling time), then choose controller gains that put them there.

1. Write down your performance specs: e.g. 'overshoot ≤ 5%, settle within 0.5 s'.
2. Translate them into a target region for the poles: overshoot ≤ 5% means ζ ≥ 0.69 (a pole angle); t_s ≤ 0.5 s means ζ·ω_n ≥ 8, i.e. poles to the left of σ = −8.
3. Pick controller gains (or use pole-placement / root-locus methods, the topic of later rungs) so the closed-loop poles land in that region.
4. Simulate the step response, confirm the four numbers, then build and verify on a scope — the curve should match your prediction.

That loop — spec → pole region → gains → measured curve — is the daily work of a control engineer, and it rests entirely on the bridge you just crossed: poles are exponents, exponents are curves, and curves are the four numbers your customer cares about. The s-plane stops being abstract the moment you realise you can grab a pole and drag it to make a real machine behave.