A classical-control playground that shows how the steady-state error of a unity-feedback loop is determined by the system type N (the number of integrators) and the input signal (step, ramp or parabolic). Sweep the loop gain K and the time constant τ to see how the position, velocity and acceleration constants — and the resulting tracking performance — change.
Parameters
Loop gain K
DC gain of the open-loop transfer function G(s)
System type N
Number of pure integrators 1/s in G(s)
Input signal
Reference signal that the loop has to track
Input amplitude A
Step height / ramp slope / parabolic coefficient
Time constant τ
s
Time constant of the non-integrating pole (τs+1). Sets the response speed
Results
—
System type N
—
Position constant K_p
—
Velocity constant K_v
—
Acceleration constant K_a
—
Steady-state error for the selected input
—
Tracking verdict
—
Unity-feedback loop and tracking response
The block diagram is drawn on the left; the input (blue) and output (green) time histories are drawn on the right. The gap between the two solid lines is the steady-state error. The higher the type N, the smaller the gap.
For a unity-feedback loop with G(s)=K/[s^N(τs+1)], the static error constants are K_p=lim_{s→0}G(s), K_v=lim_{s→0}sG(s) and K_a=lim_{s→0}s²G(s). Adding one integrator raises the system type N by one and drives the steady-state error to a polynomial input one order lower down to zero — at the cost of an extra 90° of phase lag (a loss of phase margin).
Steady-state error and system type
🙋
I keep hearing the phrase "steady-state error" — what does it actually mean? If I tell a motor "stop at 30°", surely it just stops at 30°, right?
🎓
Good question. Whether it really stops at exactly 30° depends on what's inside the controller. The difference between the command and the actual output is called the error e(t), and the value that remains after a long time is the steady-state error e_ss. The first thing you check on any feedback loop is whether this e_ss goes to zero, stays at a finite value, or blows up.
🙋
Wait — the system might not follow the command at all? Why would that happen?
🎓
This is where the most elegant result of classical control comes in: the steady-state error to a polynomial input (step, ramp, parabolic) is determined only by the number of pure integrators 1/s in the open-loop transfer function G(s). That number is called the system type N. A Type 0 system leaves an error even for a step. A Type 1 tracks a step perfectly but lags behind a ramp. A Type 2 also tracks the ramp, and only the parabolic input leaves an error. Try switching "System type N" on the left — all six result cards change dramatically for the same input.
🙋
You're right! Type 0 with a step leaves a finite error, but Type 1 drops it to zero instantly. So if higher is always better, why not just crank it up?
🎓
That's the natural reaction, but it doesn't work that way. Each integrator 1/s adds 90° of phase lag in the frequency domain — 90° for Type 1, 180° for Type 2, 270° for Type 3 — and the Nyquist plot drifts closer and closer to the −1 point, so the phase margin shrinks. The servo starts to oscillate, and a small disturbance can push it unstable. In practice we use the minimum number of integrators that satisfies the spec: Type 1 for "zero step error", Type 2 for precision positioning, and so on.
🙋
I see… what about cranking up the loop gain K? Doesn't that also shrink the error?
🎓
Yes — for Type 0 with a step, e_step = A/(1+K), so a larger K does shrink the error. But it never becomes exactly zero. And if K gets too large the gain-crossover frequency moves up into unmodelled high-frequency dynamics or time delays, and the loop goes unstable. The rule of thumb is: pick the smallest K that meets the steady-state spec, and if that's still not enough, raise the type by one. Try sliding K up to 100 in this tool — the steady-state error keeps shrinking, but it never hits zero.
🙋
What does the time constant τ change? I move the slider but the steady-state number stays the same…
🎓
Sharp eye! That is exactly the beauty of the theorem. τ controls the "speed" of the response — rise time and settling time — but it has absolutely no effect on the final error that remains. Try moving τ from 0.05 to 5 on the canvas. The waveforms look completely different, but the distance (gap) between the input and the output is identical. The steady-state error depends only on the type N and the static error constants K_p / K_v / K_a. That's the first eye-opening lesson when you start studying classical control.
Frequently asked questions
The system type, or TYPE number N, is simply the count of pure integrators 1/s contained in the open-loop transfer function G(s) of a unity-feedback control system. N=0 means no integrator, N=1 means one integrator, N=2 means two, and so on. One of the most important results of classical control theory is that the steady-state error to a polynomial input (step, ramp or parabolic) is determined only by this type N — not by the detailed dynamics of the plant. This tool visualises that relationship directly.
They are called static error constants and are defined as K_p = lim_{s→0} G(s), K_v = lim_{s→0} s·G(s) and K_a = lim_{s→0} s²·G(s). In a Type 0 system K_p is finite (equal to the loop gain K) and K_v = K_a = 0. In a Type 1 system K_p = ∞, K_v = K, K_a = 0. In a Type 2 system K_p = K_v = ∞, K_a = K. Each constant governs the steady-state error for one type of polynomial input, and switching the input in this tool highlights the constant in charge.
A pure integrator 1/s introduces a 90° phase lag in the frequency domain. Each extra type adds another 90° of lag, which pushes the Nyquist plot closer to −1, eats into the phase margin and makes the loop oscillatory or unstable. In practice most servo systems use Type 1, which already gives zero step error with a healthy phase margin; Type 2 is reserved for precision tracking; anything higher is rare and requires extra compensation.
In theory e_step = A/(1+K_p) and e_ramp = A/K_v shrink without bound as K grows. In practice an over-large K pushes the gain-crossover frequency up into unmodelled high-frequency dynamics and time delays, the phase margin collapses, and the loop starts to oscillate. The standard practice is to choose the smallest K that meets the steady-state spec, and to make up the rest by adding integrators (raising the type) or with a feed-forward compensator.
Real-world applications
Servo motor position control: The joints of an industrial robot or the feed axis of a machine tool must stop exactly on the commanded angle. That is precisely the "zero steady-state error to a step" requirement, i.e. Type 1 or higher. Real servo amplifiers embed an integrator inside the PI loop, lifting the system to Type 1 and delivering e_step = 0. For smooth, continuous tracking (cutting feeds, contouring) the application demands Type 2, which is where double-integrator P-PI cascades and feed-forward compensators come in.
HDD and optical-disc tracking: The head of a hard disk or BD/DVD drive has to follow track eccentricity, which is essentially a ramp component. A plain Type 1 controller leaves a finite K_v and a residual error, and the data can no longer be read correctly. Real drives use repetitive control or PI² structures to behave as effectively Type 2, keeping the eccentricity-tracking error below 1 µm.
Air-vehicle and missile guidance: A seeker that has to chase an accelerating target (constant acceleration, i.e. a parabolic input) needs Type 3 — a finite K_a. Classically this cannot be done by stacking pure integrators alone without ruining robustness, so designers combine the integrators with a target-acceleration feed-forward to raise the "effective type". The relationship between type and tracking performance is one of the first things to verify when sizing such high-performance loops.
Process control (temperature, flow): The temperature loop of a chemical plant must reject disturbances (ambient temperature, feedstock temperature) with zero steady-state error, which is why almost every loop contains integral action (PI / PID). This is again the classical trick of "raise to Type 1 so that step disturbances and setpoint changes leave e_ss = 0". A fast P-only loop saves settling time but always leaves a finite offset (the steady-state error of Type 0 to a step), which an operator then has to bias out by hand.
Common misconceptions and warnings
The most common misconception is the belief that "the steady-state error can always be driven to zero by raising the loop gain K". In a Type 0 system K→∞ does give e_step→0, but never strictly zero. Worse, a very high gain consumes phase margin and excites unmodelled dynamics, destabilising the loop. The only way to make e_ss exactly zero is to raise the type by one — i.e. include more integrators in the loop than the order of the input polynomial (the internal-model principle). Gain tuning and type selection are different design knobs and must be treated separately.
The next pitfall is to assume that "memorising the type-vs-input table is enough". That table relies on strong assumptions: unity feedback, continuous time, linear time-invariant dynamics. Real hardware has actuator saturation, sensor quantisation, dead time and disturbances, none of which respect the table. Adding an integrator to lift the system to Type 1 looks great on paper, but if the actuator saturates the integrator winds up and the response collapses. Treat the table as the starting point for the ideal system and always verify on the real plant.
Finally, it is tempting to think that "small steady-state error = good control system". In reality, a good loop balances five competing requirements: (1) steady-state error, (2) transient response (overshoot, settling time), (3) disturbance rejection, (4) noise sensitivity, and (5) robustness. A high-type design with e_ss = 0 is useless if it is slow, oscillatory or noise-sensitive. The fact that τ in this tool does not change the steady-state error is precisely the flip side: steady-state error is just one facet of performance.
How to Use
Set the system type (N) using the slider: N=0 for Type-0, N=1 for Type-1, N=2 for Type-2 systems
Adjust the DC gain (K) and time constant (tau) to modify the open-loop transfer function G(s)=K/((1+tau*s)^1)
Select your input signal type (step, ramp, or parabolic) and observe how steady-state error e_ss changes with system type
Compare position constant K_p, velocity constant K_v, and acceleration constant K_a across different configurations
Worked Example
Consider a Type-1 servo system with K=5 s^-1, tau=0.2s, and a ramp input r(t)=t (velocity of 1 unit/s). The velocity constant K_v = lim(s→0) s*G(s) = 5 s^-1. Steady-state error e_ss = 1/K_v = 0.2 units. For the same system with a step input, e_ss = 0 because Type-1 eliminates position error. Switch to Type-0 with identical K and tau: now e_ss for the step input becomes 1/(1+K) = 1/6 ≈ 0.167 units, and ramp input causes unbounded error.
Practical Notes
Type-1 systems (one integrator in G(s)) eliminate constant-load disturbances and track step references with zero error—standard for motor speed control and voltage regulators
Type-2 systems track ramp inputs with finite error; used in precision positioning (CNC machines, antenna tracking) where acceleration feedforward is costly
Increasing K reduces all steady-state errors proportionally but risks instability; use root-locus or Nyquist to verify phase margin remains above 45° in practice
Time constant tau affects bandwidth and error response speed; smaller tau improves transient but increases noise sensitivity in real hardware