TVC dynamics — gimbal servo bandwidth, time delay: Visual walkthrough

We are answering one question: "When the computer asks the nozzle for an angle, what actually comes out — and how late?"

Step 1 — The physical thing: a nozzle on a pivot

WHAT. Picture a rocket engine nozzle that can swivel on a hinge (a gimbal). We call the swivel angle $δ$ (the Greek letter "delta"). $δ = 0$ means the nozzle points straight down the rocket's axis; a positive $δ$ tilts it a little.

WHY start here. Before any maths, we must know what physical object we are modelling. Every symbol later will be a property of this one hinged nozzle.

PICTURE. Look at the figure: the burnt-orange nozzle hangs from a pivot. The angle $δ$ is the tilt away from the dashed centre line. Four influences act on it — we meet them next.

Figure — TVC dynamics — gimbal servo bandwidth, time delay

Step 2 — Four forces on the hinge → Newton's law for rotation

WHAT. Anything that spins obeys a rotational version of $F = ma$ . For rotation it reads "torque = inertia × angular acceleration." We list every torque acting on the nozzle.

WHY this tool. We need an equation of motion — a rule that predicts how $δ$ changes in time. Newton's second law (rotational form) is exactly the tool that turns "these forces act" into "this is how it moves." No other tool gives us motion from forces.

PICTURE. Each coloured arrow in the figure is one torque:

Actuator torque $M_{a}$ (teal) — the motor pushing the nozzle toward where we want it.
Damping $c \dot{δ}$ (plum) — friction/oil resistance. $\dot{δ}$ means "how fast $δ$ is changing" (the rate, a dot on top = per second). Faster motion → more drag, so it's proportional to $\dot{δ}$ . It always opposes motion.
Stiffness $k δ$ (orange) — a spring-like restoring pull from the structure that wants $δ$ back to zero. Bigger tilt → bigger pull, so proportional to $δ$ .
Inertia $J \ddot{δ}$ — the nozzle's reluctance to change its spin. $\ddot{δ}$ (two dots) = angular acceleration, "how fast the rate itself is changing."

This is a mass–spring–damper, the same maths as a weight bouncing on a spring — that's exactly why the servo turns out to be a second-order system.

Step 3 — The motor is told: "chase the command"

WHAT. The motor doesn't push randomly. It pushes proportionally to how wrong the angle is. Define the command $δ_{c}$ = the angle the computer asked for. The error is $δ_{c} - δ$ . The motor torque is $M_{a} = K (δ_{c} - δ)$ , where $K$ is a gain (how hard it pushes per radian of error).

WHY. This is the simplest possible feedback rule: "the further off you are, the harder I push you toward the target." It's called a proportional inner loop. It's why the nozzle ever moves to the commanded angle at all.

PICTURE. The figure shows two dials — commanded (teal) and actual (orange) — and a red gap between them. The push arrow grows with the gap and shrinks to nothing when they line up.

Substitute $M_{a} = K (δ_{c} - δ)$ into Step 2 and gather the $δ$ terms on the left:

$J \ddot{δ} + c \dot{δ} + k δ = K (δ_{c} - δ)$ $J \ddot{δ} + c \dot{δ} + total stiffness (k + K) δ = K δ_{c}$

Step 4 — Switch to the "frequency lens" (Laplace)

WHAT. We replace "time derivatives" with a single algebra symbol $s$ . The rule: taking a derivative in time = multiplying by $s$ in this new lens. So $\dot{δ} \to s δ$ and $\ddot{δ} \to s^{2} δ$ (with everything starting at rest).

WHY this tool and not another. Solving differential equations directly is hard. The Laplace transform turns calculus (derivatives) into ordinary algebra (multiplying by $s$ ). It answers the question "if I wiggle the input at frequency $ω$ , what comes out?" — which is exactly the bandwidth question we care about. Think of $s$ as a knob for "how fast are we wiggling."

PICTURE. The figure shows the swap: the wiggly time-domain equation on the left becomes a clean polynomial-in- $s$ on the right, like putting on glasses that make the blur snap into a formula.

Applying the rule and dividing through by $J$ :

$(\ddot{δ} s^{2} + damping/inertia \frac{c}{J} s + stiffness/inertia \frac{k + K}{J}) δ (s) = \frac{K}{J} δ_{c} (s)$

Rearranged into "output over input" — the transfer function (the servo's input-to-output rule):

$\frac{δ ( s )}{δ _{c} ( s )} = \frac{K / J}{s ^{2} + \frac{c}{J} s + \frac{k + K}{J}}$

Step 5 — Name the two numbers that control everything

WHAT. The messy fractions $\frac{k + K}{J}$ and $\frac{c}{J}$ hide two meaningful numbers. We give them names by matching to the universal second-order template $s^{2} + 2 ζ ω_{n} s + ω_{n}^{2}$ .

WHY. Every second-order system in physics — springs, circuits, servos — shares one shape. By naming $ω_{n}$ (speed) and $ζ$ (settling style) we can reason about all of them the same way without re-deriving. It's a change of vocabulary, not new physics.

PICTURE. The figure matches terms by colour: the constant term becomes $ω_{n}^{2}$ , the middle coefficient becomes $2 ζ ω_{n}$ .

Assuming the motor is strong ( $K ≫ k$ ) the steady gain is $\approx 1$ (ask for $5°$ , eventually get $5°$ ), leaving the clean servo lag:

$G_{servo} (s) = \frac{ω _{n}^{2}}{s ^{2} + 2 ζ ω _{n} s + ω _{n}^{2}}$

Step 6 — Bandwidth: the fastest wiggle the servo can follow

WHAT. Feed the servo a sine wiggle at frequency $ω$ . At slow $ω$ the nozzle follows faithfully (output size = input size). Speed up and eventually the nozzle can't keep up — its output shrinks. Bandwidth $ω_{B}$ is where the output has fallen to $1/ 2 \approx 0.707$ of the input (called " $- 3$ dB").

WHY $1/ 2$ ? That's the standard "half-power" line: at $1/ 2$ of amplitude the power (amplitude squared) is exactly half. It's the agreed border between "faithfully following" and "visibly lagging." (This is the same thinking used to read Bode plots.)

PICTURE. The magnitude curve $∣ G (j ω) ∣$ starts flat at $1$ , sometimes bumps up (if under-damped it resonates), then rolls off. The dashed line at $0.707$ crosses at $ω_{B}$ .

To find where the output is $1/ 2$ , we set $s = j ω$ (a pure wiggle at frequency $ω$ ; the $j$ tracks phase). Since $s^{2} = (j ω)^{2} = - ω^{2}$ :

$∣ G ∣^{2} = \frac{ω _{n}^{4}}{( ω _{n}^{2} - ω ^{2} ) ^{2} + ( 2 ζ ω _{n} ω ) ^{2}} = \frac{1}{2}$

Let $x = (ω / ω_{n})^{2}$ to tidy it into a quadratic:

$(1 - x)^{2} + 4 ζ^{2} x = 2 \Rightarrow x^{2} - 2 x (1 - 2 ζ^{2}) - 1 = 0$

Solve for $x$ (positive root only, since $x$ is a square and must be positive):

Step 7 — Edge cases: what happens at the extremes of $ζ$

WHAT. A formula you trust must survive its extreme inputs. We test three regimes of damping.

WHY. The parent warned "don't confuse $ω_{B}$ with $ω_{n}$ ." The reason is entirely in how $ζ$ bends the bandwidth formula. We must see all cases so no scenario surprises us.

PICTURE. Three magnitude curves on one plot:

$ζ = 0.5$ (under-damped): $1 - 2 ζ^{2} = 0.5 > 0$ . The curve bumps up (resonance) before falling → $ω_{B} \approx 1.27 ω_{n}$ , bigger than $ω_{n}$ .
$ζ = 0.707$ (critical sweet spot): flattest possible curve, $ω_{B} = ω_{n}$ exactly.
$ζ = 1$ (over-damped, sluggish): $1 - 2 ζ^{2} = - 1 < 0$ , curve droops early → $ω_{B} \approx 0.64 ω_{n}$ , smaller than $ω_{n}$ .

Recall Quick check on the bandwidth cases

For $ζ = 0.5$ , is $ω_{B}$ bigger or smaller than $ω_{n}$ ? ::: Bigger — about $1.27 ω_{n}$ , because the under-damped resonance pushes the roll-off later. For $ζ = 1$ , bigger or smaller? ::: Smaller — about $0.64 ω_{n}$ ; heavy damping rolls off early.

Step 8 — The delay: same shape, arriving late, and it steals phase

WHAT. The nozzle response is not only lagged, it is shifted in time by a delay $τ$ (sensor sampling, computation, valve transport). In the frequency lens a pure delay is the factor $e^{- s τ}$ . Its size is $1$ (it changes nothing about amplitude), but it rotates the phase by $- ω τ$ .

WHY it's dangerous. A control loop goes unstable when its total phase lag reaches $- 180°$ at the crossover frequency $ω_{c}$ (where the loop gain passes $1$ ). The delay adds pure phase lag for free — it silently spends your phase margin without touching the magnitude plot where you'd notice it.

PICTURE. Two identical sine waves: the input, and the output shifted right by $τ$ . The shift looks small in seconds but at high frequency covers a big fraction of a cycle → large phase angle.

Because $e^{- s τ}$ is transcendental (not a polynomial), root-locus tools can't chew it directly, so we replace it with a rational stand-in — the first-order Padé:

$e^{- s τ} \approx \frac{1 - \frac{τ}{2} s}{1 + \frac{τ}{2} s}$

The minus sign in the numerator creates a right-half-plane zero at $s = 2/ τ$ — the mathematical fingerprint of "the output first jerks the wrong way," which is the true destabilising sting of delay.

The one-picture summary

Everything on one canvas: the physical hinge (Step 1–3) becomes a second-order transfer function (Step 4–5), whose magnitude curve gives the bandwidth $ω_{B}$ (Step 6–7), while the delay $e^{- s τ}$ rides alongside quietly rotating the phase (Step 8). The full servo the computer really talks to is the product $e^{- s τ} G_{servo} (s)$ .

$\frac{δ ( s )}{δ _{c} ( s )} = late, steals phase e^{- s τ} can only move so fast \frac{ω _{n}^{2}}{s ^{2} + 2 ζ ω _{n} s + ω _{n}^{2}}$

This feeds straight into the autopilot loop, and its bandwidth must sit below the first bending mode.

Recall Feynman retelling — the whole walkthrough in plain words

We start with a nozzle hanging on a hinge. Three things resist it moving — its own heaviness (inertia), oily friction (damping), and a springy structure pulling it back (stiffness) — and one motor pushes it. The motor is simple-minded: it shoves harder the further the nozzle is from where we asked. Writing that down gives a bouncing-spring equation, and every bouncing-spring equation has two personality numbers: how fast it can swing ( $ω_{n}$ ) and whether it overshoots or crawls ( $ζ$ ). If we wiggle the command quickly, at some speed the nozzle can no longer keep up — that speed is the bandwidth. Under-damped servos even show off with a little resonant bump before giving up; heavily damped ones tire early. Finally, there's a reaction delay: the nozzle does the right thing, just a beat late. That lateness doesn't shrink the motion, but it rotates the timing — and in a feedback loop, enough rotation flips help into wobble. So the golden rules fall out on their own: make the servo fast enough, keep the delay tiny, and never let the bandwidth crash into the bendy parts of the rocket.