Steady-State Error Analysis

In the design of any control system, from an automotive cruise control to a satellite's orientation thruster, one fundamental question is: how accurately does the system track its command? A system that oscillates wildly is useless, but so is one that settles to the wrong final value. Steady-state error is the persistent difference between the desired output and the actual output of a system once all transient behavior has died out. Analyzing this error is not just an academic exercise; it is essential for quantifying a system's precision and determining the necessary controller complexity to meet performance specifications for everyday commands like step changes, ramps, and parabolic trajectories.

Defining Steady-State Error

Steady-state error ($e_{ss}$) is formally defined as the difference between the input (desired value) and the output as time approaches infinity, provided the system is stable. For a standard unity-feedback system, where the output is subtracted directly from the input to generate an error signal, we can analyze this using the Final Value Theorem from Laplace transform theory. This theorem states that if a function $f(t)$ has a limit as $t\to \infty$, then that limit can be found from its Laplace transform $F(s)$ via ${\lim }_{t\to \infty }f(t)={\lim }_{s\to 0}sF(s)$.

Applying this to the error signal $E(s)$ in a unity-feedback system gives us the powerful formula: $$e_{ss}=\underset{t\to \infty }{\lim }e(t)=\underset{s\to 0}{\lim }sE(s).$$ For a system with open-loop transfer function $G(s)$, the error signal for a reference input $R(s)$ is $E(s)=R(s)/(1+G(s))$. This framework allows us to calculate the steady-state error for different standard test inputs systematically, leading directly to the concept of system type.

System Type and Its Fundamental Significance

The system type is a classifying integer (N) equal to the number of free integrators (poles at the origin, $s=0$) present in the open-loop transfer function $G(s)$. This simple number has profound implications for a system's ability to track different inputs with zero error. We categorize systems as Type 0, Type 1, Type 2, and so on.

Think of an integrator as a mathematical accumulator. A Type 0 system (no integrators) has no inherent ability to "remember" or "integrate" past error. A Type 1 system (one integrator) can integrate a constant error over time to produce an output that eventually catches up to a step command. A Type 2 system (two integrators) can integrate the integral of an error, allowing it to catch up to a constantly changing ramp input. The system type sets the ceiling for precision: a Type N system can track a polynomial input of degree N with zero steady-state error. However, higher type numbers make the system more difficult to stabilize, a critical trade-off explored later.

Error Constants: Quantifying the Imperfection

When a system cannot achieve zero steady-state error for a given input, we quantify the remaining error using static error constants. These constants are derived from the open-loop transfer function $G(s)$ and directly correspond to common test inputs. For a unity-feedback system, they are defined as follows.

The position error constant ($K_p$) predicts steady-state error for a step input (e.g., suddenly setting a thermostat to a new temperature). It is defined as: $$K_p=\underset{s\to 0}{\lim }G(s).$$ For a step input of magnitude $A$, the steady-state error is $e_{ss}=A/(1+K_p)$. A Type 0 system will have a finite $K_p$ and thus a finite error. Systems of Type 1 or higher have $K_p=\infty$, leading to zero error for a step.

The velocity error constant ($K_v$) predicts error for a ramp input (e.g., a cruise control tracking a slowly increasing speed). It is defined as: $$K_v=\underset{s\to 0}{\lim }sG(s).$$ For a ramp input with slope $A$ ($R(s)=A/s^2$), the steady-state error is $e_{ss}=A/K_v$. A Type 1 system yields a finite $K_v$, while a Type 0 system has $K_v=0$ (infinite error), and a Type 2 or higher system has $K_v=\infty$ (zero error).

The acceleration error constant ($K_a$) predicts error for a parabolic input (e.g., tracking an object under constant acceleration). It is defined as: $$K_a=\underset{s\to 0}{\lim }{s}^{2}G(s).$$ For a parabolic input $R(s)=A/s^3$, $e_{ss}=A/K_a$. Only a Type 2 system provides a finite $K_a$. Lower types give zero $K_a$ (infinite error), and higher types give infinite $K_a$ (zero error).

A Worked Example

Consider a unity-feedback system with an open-loop transfer function $G(s)=\frac{100(s+2)}{s(s+5)(s+10)}$.

Step 1: Determine System Type. The denominator of $G(s)$ has one factor of $s$. This is a pole at the origin. Therefore, the system type N = 1. We expect zero steady-state error for a step input and a finite error for a ramp.

Step 2: Calculate Error Constants.

• Position Error Constant ($K_p$):

$$K_p=\underset{s\to 0}{\lim }G(s)=\underset{s\to 0}{\lim }\frac{100(s+2)}{s(s+5)(s+10)}=\frac{100\cdot 2}{0\cdot 5\cdot 10}=\infty .$$

• Velocity Error Constant ($K_v$):

$$K_v=\underset{s\to 0}{\lim }sG(s)=\underset{s\to 0}{\lim }s\cdot \frac{100(s+2)}{s(s+5)(s+10)}=\underset{s\to 0}{\lim }\frac{100(s+2)}{(s+5)(s+10)}=\frac{100\cdot 2}{5\cdot 10}=4.$$

• Acceleration Error Constant ($K_a$):

$$K_a=\underset{s\to 0}{\lim }{s}^{2}G(s)=\underset{s\to 0}{\lim }{s}^2\cdot \frac{100(s+2)}{s(s+5)(s+10)}=\underset{s\to 0}{\lim }\frac{100s(s+2)}{(s+5)(s+10)}=0.$$

Step 3: Compute Steady-State Errors.

• For a unit step input ($A=1$): $e_{ss}=1/(1+\infty )=0$.
• For a unit ramp input ($A=1$): $e_{ss}=1/K_v=1/4=0.25$.
• For a unit parabolic input ($A=1$): $e_{ss}=1/0=\infty$.

This matches our prediction: a Type 1 system perfectly tracks steps, follows ramps with a constant lag of 0.25 units, and cannot track a parabola at all.

The Trade-Off: Accuracy vs. Stability

A key principle in control design is that higher system type reduces steady-state error but complicates stability. Adding integrators (increasing system type) moves poles to the origin and tends to shift the root locus further into the right-half plane, making the closed-loop system more oscillatory and potentially unstable. A Type 2 system can be very accurate but is notoriously more difficult to stabilize than a Type 1 or Type 0 system. The designer's challenge is to add just enough integration (often within a compensator) to meet error specifications while using other design techniques (like lead compensation) to ensure adequate stability margins, such as phase and gain margin. You cannot simply add integrators indefinitely to chase zero error; you will eventually lose control of the system's dynamic response.

Common Pitfalls

1. Misidentifying the System Type: The most common error is to look at the closed-loop transfer function or to miscount poles at the origin in the forward path. Remember: System type (N) is defined by the number of pure integrators (poles at $s=0$) in the open-loop transfer function $G(s)$ for a unity-feedback configuration. Do not include zeros at the origin; they do not affect system type.
2. Forgetting the Unity-Feedback Assumption: All standard formulas for $K_p$, $K_v$, $K_a$, and the resulting $e_{ss}$ calculations assume a unity-feedback structure. If the feedback path is not unity (e.g., it contains a transfer function $H(s)\ne 1$), you must first reduce the system to an equivalent unity-feedback form or use the Final Value Theorem directly on the specific system's error signal $E(s)$.
3. Applying the Final Value Theorem Incorrectly: The Final Value Theorem is only valid if the limit ${\lim }_{s\to 0}sE(s)$ exists and, crucially, if the closed-loop system is stable. Always verify stability before calculating steady-state error. An unstable system does not settle to a steady state, so the calculation is meaningless.
4. Confusing Input Type with Error Constant: Students often try to use $K_p$ for a ramp input. Remember the direct pairing: Step input → $K_p$, Ramp input → $K_v$, Parabolic input → $K_a$. A quick mnemonic: the power of '$s$' in the limit definition of the constant ($s^0$ for $K_p$, $s^1$ for $K_v$, $s^2$ for $K_a$) matches the power of '$s$' in the denominator of the corresponding input Laplace transform ($1/s$, $1/s^2$, $1/s^3$).

Summary

• Steady-state error quantifies a stable control system's precision in tracking a constant, ramp, or parabolic command after transients have settled. It is calculated using the Final Value Theorem: $e_{ss}={\lim }_{s\to 0}sE(s)$.
• The system type (N), defined by the number of free integrators in the open-loop transfer function, determines which inputs can be tracked with zero error. A Type N system can track a polynomial input of degree N with zero steady-state error.
• Static error constants ($K_p$, $K_v$, $K_a$) quantify the non-zero error for step, ramp, and parabolic inputs, respectively. Their formulas are derived from $G(s)$: $K_p={\lim }_{s\to 0}G(s)$, $K_v={\lim }_{s\to 0}sG(s)$, and $K_a={\lim }_{s\to 0}{s}^{2}G(s)$.
• A fundamental design trade-off exists: increasing system type reduces steady-state error but complicates stability, making the system more oscillatory and harder to stabilize. Control design balances accuracy with robust dynamic performance.
• Always verify closed-loop stability before computing steady-state error and ensure you are applying the correct formulas for a unity-feedback system configuration.