Steady-state error is the difference between a system’s desired output and its actual output after all transient oscillations have died out. You calculate it using the Final Value Theorem: take the Laplace transform of the error signal E(s), multiply by s, and evaluate the limit as s approaches zero. The core formula is e_ss = lim(s→0) [s · E(s)]. Everything else in steady-state error analysis builds on that single expression.
The Core Formula
For a standard unity feedback system with an open-loop transfer function G(s) and a reference input R(s), the error signal in the s-domain is E(s) = R(s) / [1 + G(s)]. Applying the Final Value Theorem gives you:
e_ss = lim(s→0) s · R(s) / [1 + G(s)]
This works because the Final Value Theorem lets you find the time-domain value of a signal as t→∞ without needing to do a full inverse Laplace transform. There is one critical prerequisite: the closed-loop system must be stable, meaning all closed-loop poles must have negative real parts. If the system is unstable, the formula will give you a number, but that number is meaningless because the output is diverging rather than settling.
System Type and Why It Matters
The “type” of a system is simply the number of pure integrators (poles at s = 0) in the open-loop transfer function G(s). A system with no integrators is Type 0. One integrator makes it Type 1. Two integrators make it Type 2. This number tells you, at a glance, which kinds of inputs the system can track with zero steady-state error.
Think of each integrator as giving the system one additional level of “tracking ability.” A Type 0 system can settle to a constant output, but it will always have a nonzero offset when following a step input. A Type 1 system can track a step perfectly but falls behind when following a ramp. A Type 2 system handles both steps and ramps with zero error but struggles with parabolic (accelerating) inputs.
Error Constants: Kp, Kv, and Ka
Rather than grinding through the full limit every time, control engineers define three shorthand constants that capture the system’s tracking capability for the three standard test inputs.
- Position error constant (Kp) = lim(s→0) G(s). This applies to a unit step input, R(s) = 1/s. The steady-state error is e_ss = 1 / (1 + Kp).
- Velocity error constant (Kv) = lim(s→0) s · G(s). This applies to a unit ramp input, R(s) = 1/s². The steady-state error is e_ss = 1 / Kv.
- Acceleration error constant (Ka) = lim(s→0) s² · G(s). This applies to a unit parabolic input, R(s) = 1/s³. The steady-state error is e_ss = 1 / Ka.
When any of these constants evaluates to infinity, the corresponding steady-state error is zero. When a constant evaluates to zero, the steady-state error is infinite, meaning the system cannot track that type of input at all.
The System Type vs. Input Table
Combining system type with the error constants produces a pattern worth memorizing:
- Type 0 system: Kp is a finite constant, Kv = 0, Ka = 0. Step input gives a finite error of 1/(1+Kp). Ramp and parabolic inputs give infinite error.
- Type 1 system: Kp = ∞, Kv is a finite constant, Ka = 0. Step input gives zero error. Ramp input gives a finite error of 1/Kv. Parabolic input gives infinite error.
- Type 2 system: Kp = ∞, Kv = ∞, Ka is a finite constant. Step and ramp inputs give zero error. Parabolic input gives a finite error of 1/Ka.
The pattern is clean: a system of Type N tracks all inputs up to order N with zero error, produces a finite constant error for order N+1, and fails completely for anything higher.
Step-by-Step Calculation Example
Suppose you have a unity feedback system with G(s) = 10 / [s(s + 2)(s + 5)] and a unit ramp input.
First, check the system type. G(s) has one pole at s = 0, so this is a Type 1 system. For a ramp input, you need the velocity error constant Kv.
Calculate Kv = lim(s→0) s · G(s) = lim(s→0) s · 10 / [s(s+2)(s+5)] = lim(s→0) 10 / [(s+2)(s+5)] = 10 / (2·5) = 1.
The steady-state error is e_ss = 1/Kv = 1/1 = 1. The system’s output will permanently lag behind the ramp input by 1 unit. If you had applied a step input instead, the Type 1 system would track it perfectly with zero error. A parabolic input would produce infinite error, meaning the output would fall further and further behind over time.
Non-Unity Feedback Systems
The formulas above assume the feedback path is a direct connection (H(s) = 1). When the feedback transfer function H(s) is something other than 1, you can no longer plug G(s) directly into the error constant formulas. There are two approaches.
The more practical one is to convert the system into an equivalent unity feedback form. You split H(s) into [H(s) – 1] + 1. This creates an inner loop with feedback block H(s) – 1, which you reduce to a single equivalent forward-path transfer function: G₁(s) = G(s) / [1 + G(s)(H(s) – 1)]. Once you have G₁(s), apply the standard Kp, Kv, Ka formulas as if it were a unity feedback system.
One useful shortcut: if H(s) evaluates to 1 at s = 0 (even though H(s) is not identically 1 at all frequencies), the steady-state error is the same as the unity feedback case. This happens, for instance, when a sensor has a transfer function like s+1/s+1 that equals 1 at DC.
Reducing Steady-State Error
If your calculated error is too large, you have two main options. The first is to increase the system’s gain. Looking at the error constant formulas, a larger value of the DC gain in G(s) directly increases Kp, Kv, or Ka, which drives down the error. The tradeoff is that higher gain often reduces stability margins, making the system more oscillatory or even unstable.
The second, more powerful option is to add integral action, which effectively increases the system type. Adding an integrator (a 1/s term) to the controller converts a Type 0 system into Type 1, or a Type 1 into Type 2. This is exactly what the “I” in a PID controller does. The integrator accumulates the error signal over time: if any persistent offset exists, the integral term keeps building until it drives the error to zero. In practice, the integral controller eliminates steady-state error for one additional order of input beyond what the original system could handle.
The risk with adding integrators is the same as with raising gain. Each integrator adds phase lag, which can destabilize the system. Most real-world designs balance steady-state accuracy against transient performance and stability, which is why you rarely see systems above Type 2.
Common Mistakes to Avoid
The most dangerous mistake is applying the Final Value Theorem to an unstable system. The formula will produce a finite number that looks reasonable but has no physical meaning. Always verify that all closed-loop poles are in the left-half plane before trusting your result.
Another frequent error is miscounting the system type. Only poles of the open-loop transfer function G(s)H(s) at exactly s = 0 count. A pole at s = -0.01 is not an integrator, no matter how close it is to the origin. Similarly, students sometimes confuse open-loop and closed-loop transfer functions. The error constants Kp, Kv, and Ka are always computed from the open-loop transfer function, while stability is determined from the closed-loop poles.
Finally, watch the input scaling. The formulas e_ss = 1/(1+Kp), 1/Kv, and 1/Ka assume unit-amplitude inputs. If your step has magnitude A, multiply the result by A. For a ramp of slope A, the error becomes A/Kv.