Steady-State Error: Position, Velocity, Acceleration Error Constants

What is steady-state error and why does it matter in control design?

Steady-state error is the gap between a reference input and the system output after all transients have decayed, measured as time approaches infinity. For a position servo commanded to move 10.000 mm, a steady-state error of 0.05 mm means the motor settles there permanently, not that it is still moving. This is the last of the classic performance specs, and it is covered alongside overshoot, settling time, and rise time in Performance Specs: %OS, Ts, Tr, Tp, Ess (Steady-State Error). This article goes one level deeper: it shows how to calculate that error number directly from your open-loop transfer function, before you ever run a simulation.

Definition of steady-state error in closed-loop systems

Steady-state error, denoted Ess, is defined as e(∞) = lim(t→∞) [r(t) − c(t)], where r(t) is the reference and c(t) is the output. In the Laplace domain, for a unity-feedback system with open-loop transfer function G(s), the error transfer function is E(s) = R(s) / (1 + G(s)). The Final Value Theorem lets you compute e(∞) = lim(s→0) s·E(s) without ever inverting the Laplace transform — this is the workhorse formula for everything that follows.

Why finite error persists even with feedback

Feedback reduces error but cannot always eliminate it, because a proportional controller only produces a nonzero correction signal when there is a nonzero error to act on. If your actuator needs 2 V to hold a motor against a steady load, and your controller gain is K, the error must settle at exactly 2/K volts' worth of reference units to sustain that drive — any less, and the correction vanishes along with the error. Only an integrator in the loop breaks this coupling, since it can hold a nonzero output from a zero input.

Impact on system performance and specification limits

A nonzero Ess shows up directly in acceptance tests — a servo spec might read "±0.1% of full scale at steady state," a thermal loop spec might read "±0.5 °C at the setpoint after 10 minutes." Missing this spec means either increasing gain (with stability cost), adding an integrator (with wind-up risk), or redesigning the loop architecture. Kp, Kv, and Ka are the tools that let you predict which of those paths you need before you write a line of firmware.

How do I calculate position error constant (Kp) for step inputs?

Kp predicts steady-state error to a step input: Kp = lim(s→0) G(s), and Ess = 1 / (1 + Kp). A step is the right test input whenever the reference is a fixed target that holds still — a setpoint temperature, a target position.

Definition and formula for Kp from open-loop transfer function

For open-loop transfer function G(s) = K(s+z1)(s+z2).../[sⁿ(s+p1)(s+p2)...], Kp is simply G(0) — substitute s = 0 directly. If G(s) has no pole at the origin (n = 0), Kp is a finite number set by the ratio of zero products to pole products, scaled by gain K.

Relationship between loop gain and steady-state position error

Because Ess = 1/(1+Kp), doubling Kp does not halve the error — it approaches zero asymptotically. Going from Kp = 9 (Ess = 10%) to Kp = 99 (Ess = 1%) requires an 11x gain increase, not 10x. This nonlinear relationship is why chasing the last fraction of a percent of position error by cranking proportional gain gets expensive in phase margin fast.

Effect of system type on Kp magnitude

If G(s) has one or more poles at s = 0 (an integrator in the forward path), Kp = lim(s→0) G(s) → ∞, which drives Ess to exactly zero for a step input. This is the single most important fact in this article: an integrator in the loop gives perfect step tracking, which is why PI controllers are standard for setpoint regulation.

How do I calculate velocity error constant (Kv) for ramp inputs?

Kv predicts steady-state error to a ramp input — a reference that increases linearly with time, like a constant-velocity trajectory: Kv = lim(s→0) s·G(s), and Ess = 1/Kv.

Definition and formula for Kv from open-loop transfer function

Kv is computed by multiplying G(s) by s before taking the s→0 limit. For a Type 0 system (no pole at origin), s·G(s) → 0 as s→0, so Kv = 0 and Ess = 1/0 → infinite error — the output falls permanently behind a ramping target. For a Type 1 system (exactly one pole at origin), the s in the numerator cancels the pole, leaving a finite nonzero Kv.

Why ramp tracking requires at least one pole at origin

A Type 1 system has zero steady-state error to a step but finite, nonzero error to a ramp, because tracking a ramp means the controller output itself must ramp — and a single integrator's output is proportional to the accumulated error, which settles at a finite nonzero value to sustain a constantly growing command. To drive ramp error to zero, you need a second integrator (Type 2), at which point Kv → ∞.

Trade-off between Kv and system stability

Each additional integrator adds 90° of phase lag at low frequency, eating directly into phase margin. A Type 2 system tracks ramps with zero error but is structurally harder to stabilize — it's common practice to add a compensating zero (lead network) specifically to buy back the phase margin that the second integrator removes.

How do I calculate acceleration error constant (Ka) for parabolic inputs?

Ka predicts steady-state error to a parabolic input — an acceleration ramp, r(t) = ½at²: Ka = lim(s→0) s²·G(s), and Ess = 1/Ka.

Definition and formula for Ka from open-loop transfer function

Following the same pattern, Ka requires multiplying G(s) by s² before the limit. A Type 0 or Type 1 system gives Ka = 0 (infinite error, cannot track at all). Only Type 2 gives a finite nonzero Ka; Type 3 gives Ka → ∞ and zero steady-state error.

Requirements for systems to track acceleration commands

Tracking a parabolic command with bounded error requires two poles at the origin at minimum. In practice, Type 3 loops are rare in single-stage designs — three integrators in a forward path is a stability nightmare without careful multi-zero compensation, which is one reason cascade architectures (inner velocity loop, outer position loop) are preferred over a single monolithic Type 3 controller.

Practical implications for high-order reference signals

If your reference trajectory profile includes acceleration segments — a motion-control S-curve, for instance — feedforward (injecting a scaled derivative of the reference directly into the control signal) is usually cheaper and more stable than adding another integrator purely to shrink Ka-driven error.

How does system type (0, 1, 2) determine which errors vanish?

System type is the count of poles G(s) has at s = 0, and it alone determines whether Ess for step, ramp, and parabolic inputs is zero, finite, or infinite — gain and zero locations only set the size of the finite values.

System type classification by pole count at origin

Type 0 has zero poles at the origin, Type 1 has one, Type 2 has two. Count them directly from the denominator of G(s) in factored form; a factor of sⁿ in the denominator makes the system Type n.

Error constant matrix: which constants are finite for each type

Design trade-offs when selecting system type

Every step up in type buys zero error on one more input class but costs phase margin and raises the risk of integrator wind-up during saturation. This directly answers a question every designer eventually asks: no, you cannot get zero steady-state error to step, ramp, and acceleration inputs simultaneously from a single system type — Type 2 zeroes step and ramp error but still has finite ramp-like... no, finite acceleration error, and only Type 3 zeroes all three, at a stability cost that is rarely worth paying outside cascade or feedforward architectures.

How do I use error constants to meet steady-state error specs?

Converting a spec into a required Kp, Kv, or Ka is a direct algebraic inversion of the formulas above — this is the step that turns a paper spec into a firmware gain value.

Converting specification limits to required Kp, Kv, or Ka values

If the spec reads "Ess ≤ 2% for a step input," solve 0.02 = 1/(1+Kp) → Kp ≥ 49. If the spec reads "Ess ≤ 0.5 mm for a ramp input of 10 mm/s," Kv ≥ (10 mm/s)/(0.5 mm) = 20 s⁻¹ (watch units carefully — Kv for a ramp reference carries units of the reference rate over the reference, often 1/s for position loops).

Loop-gain requirements in terms of error constants

Once you have the required Kp, Kv, or Ka, back-solve for the controller gain K in G(s) = K·(...)/sⁿ(...) using the zero/pole structure fixed by your plant. Example: plant G(s) = K/[s(s+5)], Type 1, so Kv = lim(s→0) s·K/[s(s+5)] = K/5. For Kv ≥ 20 s⁻¹, you need K ≥ 100.

Verification using the Final Value Theorem

Always cross-check the algebraic result against a direct Final Value Theorem calculation on the closed-loop E(s) for your actual reference input, especially once a compensator with its own poles and zeros is in the loop — Kp/Kv/Ka formulas assume the standard unity-feedback form, and a sloppy substitution is an easy place to get the wrong constant.

What are common pitfalls when designing for low steady-state error?

The gain and architecture choices that shrink Ess almost always cost something elsewhere in the loop — margin, saturation behavior, or accuracy of the error constant itself.

Increasing loop gain to reduce error vs. stability margins

Pushing K up to satisfy a Kp or Kv target moves the open-loop gain crossover frequency higher, shrinking phase margin and gain margin; verify on a Bode plot or Nyquist plot, not just the error-constant algebra, before committing a gain value to firmware.

Non-unity feedback and sensor gain effects on error constants

All the formulas above assume unity feedback (H(s) = 1); if your sensor has gain H ≠ 1 (a voltage-per-degree thermocouple scaling, an encoder counts-per-mm ratio), the effective error constants scale by H, and a miscalibrated sensor gain silently shifts your real-world Ess away from the value your Kp calculation predicted.

Integrator saturation and wind-up in practical implementations

A Type 1 or Type 2 system that drives Ess to zero in theory still produces large transient error during startup or a large setpoint step, and the integrator term can saturate the actuator command, causing overshoot and slow recovery once the plant catches up — anti-windup clamping (conditional integration, back-calculation) is not optional in any firmware implementation of an integrator-based loop, regardless of how clean the Kp/Kv/Ka numbers look on paper.

Related reading

• Initial Value Theorem: lim(t→0⁺) y(t) = lim(s→∞) sY(s) — distinguishing initial conditions from final tracking.
• Noise Amplification: T(s) at High Frequency — balancing tracking gains against measurement noise.