3.2 Steady-state error analysis

Steady-state error analysis tells you how accurately a control system tracks its desired output once all the transient dynamics have died out. If a system never quite reaches the reference input, that persistent gap is the steady-state error. This topic gives you the tools to predict that error, classify systems by their tracking ability, and design controllers that reduce it.

Steady-state error

Steady-state error ($e_{ss}$) is the difference between the desired output and the actual output after the system has settled. It's the error that remains once all transient oscillations and exponential decays are gone.

Three factors determine $e_{ss}$:

• The input type: step (constant), ramp (linearly increasing), or parabolic (quadratically increasing)
• The system type: how many integrators (poles at $s = 0$) exist in the open-loop transfer function
• The open-loop gain: the magnitude of the transfer function at low frequencies

The relationship between input type and system type is the core of this entire section. A system that perfectly tracks a step input may still accumulate error under a ramp input.

Error constants

Error constants quantify a system's ability to track each class of input. They're all computed from the open-loop transfer function $G(s)H(s)$ by taking limits as $s \to 0$.

Position error constant

$K_p$ predicts steady-state error for a step input:

$K_p = \lim_{s \to 0} G(s)H(s)$

If $K_p$ is finite, the system will have a nonzero steady-state error to a step. If $K_p = \infty$, the error is zero.

Velocity error constant

$K_v$ predicts steady-state error for a ramp input:

$K_v = \lim_{s \to 0} sG(s)H(s)$

The factor of $s$ in front "tests" whether the system has enough integration to keep up with a linearly growing input.

Acceleration error constant

$K_a$ predicts steady-state error for a parabolic input:

$K_a = \lim_{s \to 0} s^2 G(s)H(s)$

The $s^2$ factor tests for the two integrators needed to track a quadratic input with zero error.

For all three constants, a larger value means a smaller steady-state error for the corresponding input type.

System type

The system type equals the number of poles at the origin ($s = 0$) in the open-loop transfer function $G(s)H(s)$. Each pole at the origin acts as a pure integrator ($1/s$). The type number directly determines which inputs the system can track with zero steady-state error.

Type 0 systems

No poles at the origin. $K_p$ is finite, while $K_v = 0$ and $K_a = 0$.

• Step input: finite, nonzero $e_{ss}$
• Ramp input: $e_{ss} = \infty$ (error grows without bound)
• Parabolic input: $e_{ss} = \infty$

Example: $G(s) = \frac{10}{s+5}$ has no $s$ factor in the denominator, so it's Type 0 with $K_p = 10/5 = 2$.

Type 1 systems

One pole at the origin. $K_p = \infty$, $K_v$ is finite, $K_a = 0$.

• Step input: $e_{ss} = 0$
• Ramp input: finite, nonzero $e_{ss}$
• Parabolic input: $e_{ss} = \infty$

Example: $G(s) = \frac{10}{s(s+5)}$ has one $s$ factor in the denominator, making it Type 1 with $K_v = 10/5 = 2$.

Type 2 systems

Two poles at the origin. $K_p = \infty$, $K_v = \infty$, $K_a$ is finite.

• Step input: $e_{ss} = 0$
• Ramp input: $e_{ss} = 0$
• Parabolic input: finite, nonzero $e_{ss}$

Example: $G(s) = \frac{10}{s^2(s+5)}$ is Type 2 with $K_a = 10/5 = 2$.

Ramp vs step inputs

Understanding the input signals is important because each one demands a different level of tracking capability from the system.

• Step input: a sudden jump to a constant value (e.g., setting a thermostat to 72°F). The system just needs to reach and hold a fixed reference.
• Ramp input: a reference that increases linearly with time (e.g., a satellite dish tracking a moving target at constant angular velocity). The system must continuously keep up with a changing setpoint.
• Parabolic input: a reference that increases quadratically (e.g., tracking an accelerating object). This is the most demanding and least common of the three.

Each input type is one degree harder to track than the last, which is why you need one additional integrator for each step up.

Steady-state error formulas

These formulas assume a unity feedback configuration and that the closed-loop system is stable. Always verify stability first; these formulas are meaningless for an unstable system.

Formula for step input

$e_{ss} = \frac{1}{1 + K_p}$

For a Type 0 system with $K_p = 9$, you get $e_{ss} = 1/(1+9) = 0.1$, or 10% of the step magnitude. For Type 1 or higher, $K_p = \infty$, so $e_{ss} = 0$.

Formula for ramp input

$e_{ss} = \frac{1}{K_v}$

For a Type 1 system with $K_v = 5$, you get $e_{ss} = 1/5 = 0.2$. For Type 0, $K_v = 0$, so $e_{ss} = \infty$. For Type 2 or higher, $K_v = \infty$, so $e_{ss} = 0$.

Formula for parabolic input

$e_{ss} = \frac{1}{K_a}$

Same pattern: finite $K_a$ gives finite error (Type 2), $K_a = 0$ gives infinite error (Type 0 or 1), and $K_a = \infty$ gives zero error (Type 3+).

Steady-state error in unity feedback systems

In a unity feedback system, $H(s) = 1$, so the open-loop transfer function simplifies to just $G(s)$. This makes the analysis straightforward: you compute all error constants directly from $G(s)$ using the limit formulas above.

The standard error formulas ($1/(1+K_p)$, $1/K_v$, $1/K_a$) are derived specifically for unity feedback. Most textbook problems assume this configuration unless stated otherwise.

Steady-state error in non-unity feedback systems

When $H(s) \neq 1$, you can't just plug $G(s)$ into the error constant formulas. You need to use the full open-loop transfer function $G(s)H(s)$ in the limit calculations.

There's a subtlety here: the "error" in a non-unity feedback system isn't simply $R(s) - C(s)$ anymore. The error signal is $E(s) = R(s) - H(s)C(s)$, so what you're computing is the actuating error, not the true output error. To find the actual difference between the reference and the output, you may need to account for $H(s)$ separately.

One common design approach is to shape $H(s)$ so that $H(0) = 1$, which makes the steady-state behavior match the unity feedback case for constant inputs.

Improving steady-state error

Increasing system type

The most direct way to reduce steady-state error is to add integrators to the forward path. Each integrator adds a pole at the origin, raising the system type by one.

• Type 0 → Type 1 (add one integrator): eliminates $e_{ss}$ for step inputs
• Type 0 → Type 2 (add two integrators): eliminates $e_{ss}$ for step and ramp inputs

Adding poles at origin

"Adding poles at the origin" and "adding integrators" mean the same thing. Multiplying the plant or controller transfer function by $1/s$ places a pole at $s = 0$.

The tradeoff: each added integrator contributes $-90°$ of phase lag, which reduces phase margin and can destabilize the system. You rarely see systems above Type 2 in practice because stability becomes very difficult to maintain.

Steady-state error vs transient response

There's a fundamental tension between steady-state accuracy and transient performance. Increasing gain to reduce $e_{ss}$ tends to increase overshoot and can push the system toward instability. Adding integrators eliminates error for certain inputs but adds phase lag, which slows the response and increases overshoot.

Good control design requires balancing both. You don't just minimize steady-state error in isolation; you pick a controller that meets both your accuracy spec and your transient specs (rise time, settling time, overshoot).

Steady-state error in PID control

A PID controller has the form $G_c(s) = K_p + \frac{K_i}{s} + K_d s$, where each term plays a distinct role in shaping both transient and steady-state behavior.

Effect of proportional gain

Increasing the proportional gain $K_p$ raises the open-loop gain, which increases the error constants and reduces $e_{ss}$ for step inputs in Type 0 systems. But proportional control alone can never fully eliminate steady-state error for a step input in a Type 0 system; you'd need $K_p \to \infty$ to get $e_{ss} \to 0$, which is impractical. Higher proportional gain also increases overshoot and can cause oscillations.

Effect of integral gain

The integral term $K_i/s$ adds a pole at the origin, effectively raising the system type by one. This is why integral action eliminates steady-state error for step inputs entirely, and reduces it for ramp inputs. It's the most important PID term for steady-state accuracy.

The cost: integral action introduces phase lag, which can slow the response and increase overshoot. Too much integral gain can also cause integral windup, where the integrator accumulates large error during saturation and causes excessive overshoot when the system recovers.

Effect of derivative gain

The derivative term $K_d \cdot s$ does not affect steady-state error directly because its contribution goes to zero as $s \to 0$. Its role is entirely in the transient response: it adds phase lead, which reduces overshoot and improves settling time. By improving transient behavior, a well-tuned derivative gain gives you more room to increase $K_p$ or $K_i$ without destabilizing the system, indirectly helping steady-state performance.