Intuition The ONE core idea
A controller is a machine that measures how wrong you are and turns that number into a correction command . Everything in PID is just three different ways of reading one wrongness-signal over time — its size now, its build-up from the past, and its trend into the future.
Before you can read a single line of the PID law, you need to be fluent in a small pile of symbols and pictures. This page builds every one of them from nothing, in the order they depend on each other. If the parent note wrote a symbol without explaining it, this page is where it gets explained .
t
==t == is time , measured in seconds from the moment we switch the controller on (t = 0 ).
Plain words: a clock that only ever ticks forward.
The picture: the horizontal axis of every graph on this page. Left = earlier, right = later.
Why the topic needs it: control is about reacting as things change . Nothing about PID makes sense at a single frozen instant — we always watch a quantity move along the time axis.
When we write something like r ( t ) or y ( t ) , the little "( t ) " just means "this thing has a different value at each moment" — it is a function of time , not a fixed number.
Look at the figure: the same physical machine gives you a whole curve of values, one dot per instant. That curve is the raw material a controller feeds on.
Notice in the figure: the error can be positive or negative, and it crosses through zero. A controller must behave correctly in all three of these cases, which is exactly why the sign of e is tracked so carefully.
Read more about how these three signals wire together in Feedback control loops .
Definition The control signal
u ( t )
==u ( t ) == is the command sent to the actuator — the thruster, reaction wheel, motor or valve that physically pushes the system.
Picture: an arrow leaving the controller box and entering the machine (see the loop diagram below).
Sign: positive u = push one way, negative u = push the other, u = 0 = no push.
Why needed: thinking about error is useless unless it becomes an action . u is the controller's only output — its hands.
The whole job of a PID controller is to compute the rule that turns e ( t ) into u ( t ) . We write this as a function u = f ( e ) : "the command is some recipe applied to the error."
For where u actually goes on a spacecraft, see Reaction wheels & attitude control .
Intuition Why three separate knobs?
Because the three readings of the error (now, past, future) each solve a different problem — and each has a different downside. Separate knobs let you dial in exactly enough of each.
Now a real piece of calculus enters. Do not panic — we build it from a picture.
Intuition WHY an integral, and not something simpler?
We want the controller to remember how long it's been wrong. A single number "how wrong now" forgets history instantly. To remember, we must accumulate — keep a running total of the error. The mathematical name for "area piled up under a curve" is the integral . That is precisely the tool that answers "how much error, added up over all time so far?"
Definition The integral sign
==∫ 0 t e ( τ ) d τ == means: the total signed area between the error curve and zero, from time 0 up to now (t ).
∫ is a stretched "S" for Sum .
τ (Greek "tau") is a dummy variable — a stand-in for "every past instant". We use τ instead of t so we don't confuse the running clock inside the sum with the current time t at the top of the integral .
d τ means "a thin slice of time" — the width of one tiny rectangle.
Signed area: area above zero counts + , area below counts − . So consistent under-shoot piles up positive, and errors on opposite sides can cancel.
In the figure the shaded region is the integral: chop time into thin rectangles of width d τ , each of height e ( τ ) , and add all their areas. A persistent small error slowly fills a big area — that is the "memory" that eventually kills steady-state offset.
t and τ are the same letter, so they mean the same thing."
No. t is fixed while you evaluate the integral (it's the right edge of the shaded region). τ sweeps across the inside from 0 to t . Reusing t for both would be like using one variable name for the finish line and the runner.
The digital version replaces this area with a running sum of rectangles — the reason the flight code says ∑ e j Δ t .
Intuition WHY a derivative, and not something simpler?
We want the controller to anticipate : is the error shrinking fast (about to overshoot) or growing? "How fast is a quantity changing right now?" is answered by exactly one tool — the derivative , the slope of the curve. No other operation reports rate of change at an instant.
Definition The derivative
==d t d e ( t ) == (also written e ˙ , "e-dot") is the slope of the error curve at the current instant — how fast e is rising or falling.
Picture: the tilt of the tangent line touching the error curve.
All cases:
slope > 0 → error growing → trouble getting worse.
slope < 0 → error shrinking → we're approaching target (start braking!).
slope = 0 → error momentarily steady (a peak, a valley, or a plateau).
Why needed: it's the only reading that looks forward . It sees a crash coming before the position is wrong.
The figure shows two points on an error curve and the tangent lines at each. A steep downward tangent (cyan) means "diving toward target fast" — the derivative term reads this and eases off early.
Definition The finite difference (what the computer really does)
A flight computer can't take a true instantaneous slope; it only has samples every Δ t seconds. It approximates:
e ˙ ≈ Δ t e k − e k − 1
==Δ t == ("delta-t") = the time between two samples (the sampling step).
e k = the newest error sample, e k − 1 = the one before it.
Picture: the slope of the straight line joining the last two dots — a two-point approximation of the tangent.
Why needed: it turns the calculus derivative into arithmetic the processor can do. The tiny wiggles this amplifies are why Sensor noise & filtering matters.
Steady state is when the system has stopped changing : y , e , and u all settle to constant values (subscript "ss", e.g. e ss ).
Picture: the wiggly curve flattening into a horizontal line on the right of the graph.
Why needed: the parent note's key argument — "pure P leaves leftover error" — is a steady-state statement. The whole idea of "does the controller actually reach the target?" lives here, and is formalised in Steady-state error and system type .
Intuition The trick used everywhere
"At steady state a rate of change is zero." If u I has settled to a constant, then its rate d t d u I = K i e must be 0 , forcing e = 0 . That one sentence is the entire proof that the integral kills offset — but it only makes sense once you own derivative = rate and steady state = not changing .
d
==d == is an unwanted outside push — gravity, drag, solar torque — that the controller must fight even with no error commanded.
Picture: an amber arrow shoving the system sideways in the loop diagram.
Why needed: without a disturbance, even a lazy controller looks perfect. d is the villain that exposes each term's weakness.
Saturation is when the actuator hits its physical maximum and can't push harder (a thruster already at full throttle).
Picture: the command curve u ( t ) slamming into a flat ceiling.
Why needed: it's the cause of "integrator windup" — the integral keeps piling up commands the actuator can't deliver. Stability of the whole loop is judged with the Stability & the Routh–Hurwitz criterion , and the frequency-domain language for all of it comes from Laplace transforms & transfer functions .
I term uses accumulated past
control signal u = command
Read the diagram top-to-bottom: time gives you the signals, the signals give you the error, the error is read three ways, each reading times a gain becomes part of the command, and the command (fighting the disturbance) moves the system — whose sensor closes the loop back to y . That loop is the parent topic, PID control — proportional, integral, derivative terms .
Test yourself — you're ready for the parent page only if you can answer each without peeking.
What does the "( t ) " in y ( t ) tell you? That y is a function of time — a different value at each instant, i.e. a whole curve, not one number.
Define the error e ( t ) in words and symbols. How wrong you are: setpoint minus measured value, e ( t ) = r ( t ) − y ( t ) .
What does e > 0 vs e < 0 mean physically? e > 0 : below target, push up. e < 0 : above target, push down. e = 0 : on target.
What is u ( t ) and where does it go? The control command; it leaves the controller and drives the actuator (thruster/wheel/valve).
What is a gain K ? A fixed multiplier setting how strongly a term reacts — a volume knob.
What does the integral ∫ 0 t e d τ measure, as a picture? The signed area under the error curve from time 0 to now — the accumulated ("remembered") past error.
Why use the dummy variable τ instead of t inside the integral? t is the fixed upper limit (right edge); τ sweeps across every past instant — two different roles need two names.
What does d t d e (or e ˙ ) measure? The slope/rate of change of the error right now — whether it's growing, shrinking, or steady.
What is Δ t and why does the computer need it? The time between two samples; it converts the calculus integral/derivative into a running sum and a finite difference the processor can compute.
What is "steady state" and the key fact used about it? When everything stops changing (constant values); the key fact is that a rate of change is then zero.
What is a disturbance d ? An unwanted outside push (gravity, drag, torque) the controller must cancel even at zero commanded error.
What is actuator saturation? When the actuator hits its physical maximum and cannot push any harder.