Consider the standard unity-feedback configuration with reference signal \( r(t) \), plant \( G(s) \), controller \( C(s) \), and output \( y(t) \). The error signal is

\[ e(t) = r(t) - y(t). \]

We define the steady-state error as the long-time limit (if it exists)

\[ e_{\mathrm{ss}} \triangleq \lim_{t \to \infty} e(t). \]

Let \( E(s) = \mathcal{L}\{e(t)\} \). Under the usual assumptions from Chapter 2 (existence of Laplace transforms) and Chapter 7 (closed-loop asymptotic stability), the final value theorem gives

\[ e_{\mathrm{ss}} = \lim_{t \to \infty} e(t) = \lim_{s \to 0} s E(s), \]

provided that \( sE(s) \) has no poles in the closed right-half plane except possibly a simple pole at the origin (which we exclude here by assuming an asymptotically stable closed loop).

For unity feedback (\( H(s) = 1 \)) with open-loop transfer function \( L(s) = C(s)G(s) \), standard block-diagram algebra (Chapter 4) yields

\[ \frac{Y(s)}{R(s)} = \frac{L(s)}{1 + L(s)}, \qquad \frac{E(s)}{R(s)} = 1 - \frac{Y(s)}{R(s)} = \frac{1}{1 + L(s)}. \]

Hence for any reference \( R(s) \) we have

\[ E(s) = \frac{R(s)}{1 + L(s)}, \qquad e_{\mathrm{ss}} = \lim_{s \to 0} s \frac{R(s)}{1 + L(s)}. \]

This simple expression, together with standard test input transforms (introduced in Lesson 1), is the basis for all the steady-state error results in this lesson.

flowchart TD
  A["Specify unity-feedback loop: C(s), G(s)"] --> B["Form open-loop L(s) = C(s)G(s)"]
  B --> C["Compute error transfer E(s)/R(s) = 1 / (1 + L(s))"]
  C --> D["Choose test input: step / ramp / parabolic"]
  D --> E["Write R(s) (1/s, 1/s^2, 1/s^3)"]
  E --> F["Form E(s) = R(s) / (1 + L(s))"]
  F --> G["Apply final value theorem: e_ss = lim_{s->0} s E(s)"]
  G --> H["Express in terms of Kp, Kv, Ka and system type"]
        

In Lesson 2 we introduced the static error constants for a unity-feedback loop with open-loop transfer function \( L(s) = C(s)G(s) \):

\[ K_p \triangleq \lim_{s \to 0} L(s), \qquad K_v \triangleq \lim_{s \to 0} s L(s), \qquad K_a \triangleq \lim_{s \to 0} s^{2} L(s), \]

whenever these limits exist (possibly being infinite). The system type is the number of open-loop poles at the origin:

\[ \text{type} = N \quad \Longleftrightarrow \quad L(s) = \frac{K}{s^{N}} \cdot \frac{N_{\mathrm{p}}(s)}{D_{\mathrm{p}}(s)}, \]

where \( N_{\mathrm{p}}(s) \) and \( D_{\mathrm{p}}(s) \) have no poles at the origin and \( K \neq 0 \). Thus a type 0 system has no integrators, type 1 has one integrator, type 2 has two integrators, and so on.

The static error constants can be interpreted as low-frequency gains of the open loop:

• \( K_p \) is the DC gain of \( L(s) \).
• \( K_v \) is the DC gain of \( sL(s) \) (velocity gain).
• \( K_a \) is the DC gain of \( s^{2}L(s) \) (acceleration gain).

In this lesson we show how these constants enter \( e_{\mathrm{ss}} \) for step, ramp, and parabolic inputs, and how the system type dictates whether \( e_{\mathrm{ss}} \) is finite, zero, or infinite.

Consider a unit step reference: \( r(t) = u(t) \), whose Laplace transform is \( R(s) = \frac{1}{s} \). Then

\[ E(s) = \frac{R(s)}{1 + L(s)} = \frac{1}{s} \cdot \frac{1}{1 + L(s)}. \]

Applying the final value theorem:

\[ e_{\mathrm{ss}}^{\text{step}} = \lim_{s \to 0} s E(s) = \lim_{s \to 0} s \cdot \frac{1}{s} \cdot \frac{1}{1 + L(s)} = \lim_{s \to 0} \frac{1}{1 + L(s)} = \frac{1}{1 + K_p}, \]

assuming \( K_p = \lim_{s \to 0} L(s) \) is finite. Two important cases:

• Type 0 system: \( K_p \) is finite (nonzero DC gain), so \( e_{\mathrm{ss}}^{\text{step}} = \frac{1}{1 + K_p} \) is nonzero but finite.
• Type 1 or higher system: \( L(s) \sim \frac{K}{s^{N}} \) near the origin with \( N \ge 1 \), so \( K_p = \infty \) and \( e_{\mathrm{ss}}^{\text{step}} = 0 \). Intuitively, at least one integrator is required in the open loop to eliminate step error.

Thus, to guarantee zero steady-state error to a constant position or speed command, the open-loop system must be at least type 1.

For a unit ramp reference \( r(t) = t\,u(t) \), we have \( R(s) = \frac{1}{s^{2}} \), so

\[ E(s) = \frac{R(s)}{1 + L(s)} = \frac{1}{s^{2}} \cdot \frac{1}{1 + L(s)}. \]

The steady-state error is

\[ e_{\mathrm{ss}}^{\text{ramp}} = \lim_{s \to 0} s E(s) = \lim_{s \to 0} \frac{1}{s(1 + L(s))} = \lim_{s \to 0} \frac{1}{s + sL(s)}. \]

Define the velocity error constant \( K_v = \lim_{s \to 0} s L(s) \) (if the limit exists and is finite). Since \( L(s) \) is rational and the closed loop is stable, this limit exists whenever the open-loop type is at least 1. Then, as \( s \to 0 \), the term \( s \) in the denominator vanishes and we obtain

\[ e_{\mathrm{ss}}^{\text{ramp}} = \frac{1}{K_v}, \qquad K_v = \lim_{s \to 0} s L(s). \]

The dependence on system type is immediate:

• Type 0: \( L(s) \) finite at the origin, so \( sL(s) \to 0 \) and \( K_v = 0 \). The denominator \( s + sL(s) \) tends to zero, so \( e_{\mathrm{ss}}^{\text{ramp}} = \infty \).
• Type 1: \( L(s) \sim \frac{K}{s} \) near zero, so \( sL(s) \to K_v = K \), finite and nonzero. Then \( e_{\mathrm{ss}}^{\text{ramp}} = \frac{1}{K_v} \) is finite but nonzero.
• Type 2 or higher: \( L(s) \sim \frac{K}{s^{N}} \) with \( N \ge 2 \), hence \( sL(s) \sim \frac{K}{s^{N-1}} \to \infty \) and \( K_v = \infty \), giving \( e_{\mathrm{ss}}^{\text{ramp}} = 0 \).

Therefore, exact tracking of linearly increasing references (e.g., constant-velocity motion) requires at least a type 2 open loop; a type 1 loop yields a finite, nonzero steady-state ramp error determined by \( K_v \).

A unit parabolic input corresponds to a constant acceleration: \( r(t) = \tfrac{1}{2}t^{2} u(t) \), with Laplace transform \( R(s) = \frac{1}{s^{3}} \). Then

\[ E(s) = \frac{1}{s^{3}} \cdot \frac{1}{1 + L(s)}. \]

The steady-state error is

\[ e_{\mathrm{ss}}^{\text{parabolic}} = \lim_{s \to 0} s E(s) = \lim_{s \to 0} \frac{1}{s^{2}(1 + L(s))} = \lim_{s \to 0} \frac{1}{s^{2} + s^{2}L(s)}. \]

Define the acceleration error constant \( K_a = \lim_{s \to 0} s^{2} L(s) \). If this limit exists and is finite, the denominator tends to \( K_a \) as \( s \to 0 \), and hence

\[ e_{\mathrm{ss}}^{\text{parabolic}} = \frac{1}{K_a}. \]

The system-type dependence:

• Type 0: \( s^{2}L(s) \to 0 \), so \( K_a = 0 \) and \( e_{\mathrm{ss}}^{\text{parabolic}} = \infty \).
• Type 1: \( L(s) \sim \frac{K}{s} \), so \( s^{2}L(s) \sim Ks \to 0 \), again \( K_a = 0 \) and \( e_{\mathrm{ss}}^{\text{parabolic}} = \infty \).
• Type 2: \( L(s) \sim \frac{K}{s^{2}} \), so \( s^{2}L(s) \to K_a = K \) finite, giving finite but nonzero \( e_{\mathrm{ss}}^{\text{parabolic}} = \frac{1}{K_a} \).
• Type 3 or higher: \( s^{2}L(s) \to \infty \), so \( K_a = \infty \) and \( e_{\mathrm{ss}}^{\text{parabolic}} = 0 \).

Exact tracking of parabolic trajectories (constant acceleration) thus requires at least a type 3 open loop. A type 2 loop yields finite error proportional to \( 1/K_a \).

The results for unit step, ramp, and parabolic inputs can be summarized compactly in terms of \( K_p, K_v, K_a \) and system type:

This table is a core design guideline: desired tracking performance for a given class of reference signals immediately implies a minimum required system type.

flowchart TD
  S["Choose input class: step / ramp / parabolic"] --> T["Determine required system type"]
  T --> T0["Type 0: \nfinite step error only"]
  T --> T1["Type 1: \nzero step, \nfinite ramp error"]
  T --> T2["Type 2: \nzero step and ramp; \nfinite parabolic error"]
  T --> T3["Type 3+: \nzero error for \nstep, ramp, parabolic"]
  T0 --> D0["Increase integrators \nto reduce step error"]
  T1 --> D1["Increase Kv or \nmove to type 2 \nto reduce ramp error"]
  T2 --> D2["Increase Ka or \nmove to type 3+ \nto reduce parabolic error"]
        

In robotic and mechatronic systems, the reference signals correspond to physically meaningful motion profiles:

• Step input: sudden change in desired joint angle or end-effector position.
• Ramp input: constant-velocity motion, e.g., uniform rotation of a robot joint.
• Parabolic input: constant-acceleration trajectory, often used in polynomial trajectory generation for smooth motions.

A simple rigid robot joint (single axis) with inertia \( J \), viscous friction \( b \), torque input \( u(t) \), and position \( \theta(t) \) can be modeled (Chapter 3) as

\[ J \ddot{\theta}(t) + b \dot{\theta}(t) = u(t), \]

which in the Laplace domain gives the plant

\[ G(s) = \frac{\Theta(s)}{U(s)} = \frac{1}{Js^{2} + bs} = \frac{1}{s(Js + b)}. \]

With a proportional-derivative (PD) position controller \( C(s) = K_{\mathrm{p}} + K_{\mathrm{d}} s \) and unity feedback, the open loop is

\[ L(s) = C(s)G(s) = \frac{K_{\mathrm{p}} + K_{\mathrm{d}} s}{s(Js + b)}. \]

Factoring out the pole at the origin shows that this is a type 1 loop. Therefore:

• Step inputs: \( e_{\mathrm{ss}}^{\text{step}} = 0 \) (perfect position tracking in steady state).
• Ramp inputs: finite velocity error \( e_{\mathrm{ss}}^{\text{ramp}} = 1/K_v \).
• Parabolic inputs: \( e_{\mathrm{ss}}^{\text{parabolic}} = \infty \).

This is consistent with practical servo experience: PD position loops track constant setpoints exactly but exhibit steady lag when asked to follow constant-velocity or accelerating trajectories. To reduce ramp error, engineers often add integral action (PI or PID control) to increase the system type while preserving stability.

We now implement the steady-state error computation in Python using the python-control library. The example corresponds to a unity-feedback servo with open loop \( L(s) = \dfrac{10}{s(0.5s + 1)} \), which is type 1 and can represent a simplified robot joint with viscous friction and a proportional controller.

import numpy as np
import control as ct

# Open-loop L(s) = 10 / (s (0.5 s + 1))
s = ct.TransferFunction.s
G = 10 / (s * (0.5 * s + 1.0))
C = 1.0
L = C * G

# Error transfer E(s)/R(s) = 1 / (1 + L(s)) for unity feedback
E_over_R = ct.feedback(1, L)

# Static error constants via low-frequency gain
Kp = ct.dcgain(L)
Kv = ct.dcgain(s * L)       # well-defined here (type 1)
Ka = ct.dcgain(s**2 * L)    # will be zero for this example

print("Kp =", Kp)
print("Kv =", Kv)
print("Ka =", Ka)

def ss_error_step():
    """Numerical steady-state error for unit step input."""
    t, e = ct.step_response(E_over_R)
    return e[-1]

def ss_error_ramp(t_final=50.0):
    """Numerical steady-state error for unit ramp input r(t) = t."""
    t = np.linspace(0.0, t_final, 2000)
    r = t
    t_out, e, _ = ct.forced_response(E_over_R, T=t, U=r)
    return e[-1]

def ss_error_parabolic(t_final=50.0):
    """Numerical steady-state error for unit parabolic input r(t) = 0.5 t^2."""
    t = np.linspace(0.0, t_final, 2000)
    r = 0.5 * t**2
    t_out, e, _ = ct.forced_response(E_over_R, T=t, U=r)
    return e[-1]

print("Step e_ss (simulated):      ", ss_error_step())
print("Ramp e_ss (simulated):      ", ss_error_ramp())
print("Parabolic e_ss (simulated): ", ss_error_parabolic())

# Theoretical values for comparison
e_step_theory = 1.0 / (1.0 + Kp)
e_ramp_theory = 1.0 / Kv
print("Step e_ss (theory):         ", e_step_theory)
print("Ramp e_ss (theory):         ", e_ramp_theory)
      

In robotics-oriented Python workflows, the python-control library is often combined with packages such as roboticstoolbox-python to obtain linearized joint or end-effector dynamics. Once a linear model \( G(s) \) is available, the procedure above directly yields \( K_p, K_v, K_a \) and the corresponding steady-state errors for standard motion commands.

In embedded robot controllers (e.g., ROS / ROS 2 nodes), it is common to reason about steady-state error using the static error constants computed offline. At run time, the controller can check whether the design meets specified tracking tolerances by evaluating formulas for \( e_{\mathrm{ss}} \). The snippet below illustrates a small C++ utility:

#include <iostream>
#include <limits>
#include <cmath>

enum class InputType { Step, Ramp, Parabolic };

struct ErrorConstants {
    double Kp;  // position error constant
    double Kv;  // velocity error constant
    double Ka;  // acceleration error constant
};

double steadyStateError(InputType input, const ErrorConstants& k)
{
    switch (input) {
    case InputType::Step:
        if (std::isinf(k.Kp)) {
            return 0.0;
        }
        return 1.0 / (1.0 + k.Kp);

    case InputType::Ramp:
        if (k.Kv <= 0.0) {
            return std::numeric_limits<double>::infinity();
        }
        return 1.0 / k.Kv;

    case InputType::Parabolic:
        if (k.Ka <= 0.0) {
            return std::numeric_limits<double>::infinity();
        }
        return 1.0 / k.Ka;

    default:
        return std::numeric_limits<double>::quiet_NaN();
    }
}

int main()
{
    // Example: type-1 joint servo with Kp finite, Kv finite, Ka = 0
    ErrorConstants jointServo{20.0, 5.0, 0.0};

    std::cout << "Step e_ss      = "
              << steadyStateError(InputType::Step, jointServo) << "\n";
    std::cout << "Ramp e_ss      = "
              << steadyStateError(InputType::Ramp, jointServo) << "\n";
    std::cout << "Parabolic e_ss = "
              << steadyStateError(InputType::Parabolic, jointServo) << "\n";

    return 0;
}
      

In a ROS-based robotic controller, the ErrorConstants structure can be populated from parameters determined by offline analysis of \( L(s) \). The controller algorithm can then verify that the expected steady-state error for a desired motion profile remains below specified tolerances before executing a trajectory.

Java is often used in educational simulators and GUI-based tools for control. The following class provides a simple API for computing steady-state errors from \( K_p, K_v, K_a \), which could be integrated into a visualization tool that displays tracking performance for different system types.

public class SteadyStateErrorCalculator {

    public enum InputType {
        STEP,
        RAMP,
        PARABOLIC
    }

    public static double steadyStateError(InputType input,
                                          double Kp, double Kv, double Ka) {
        switch (input) {
            case STEP:
                if (Double.isInfinite(Kp)) {
                    return 0.0;
                }
                return 1.0 / (1.0 + Kp);

            case RAMP:
                if (Kv <= 0.0) {
                    return Double.POSITIVE_INFINITY;
                }
                return 1.0 / Kv;

            case PARABOLIC:
                if (Ka <= 0.0) {
                    return Double.POSITIVE_INFINITY;
                }
                return 1.0 / Ka;

            default:
                return Double.NaN;
        }
    }

    public static void main(String[] args) {
        double Kp = 20.0;  // type-1 controller, finite Kp
        double Kv = 5.0;
        double Ka = 0.0;

        System.out.println("Step e_ss      = " +
                steadyStateError(InputType.STEP, Kp, Kv, Ka));
        System.out.println("Ramp e_ss      = " +
                steadyStateError(InputType.RAMP, Kp, Kv, Ka));
        System.out.println("Parabolic e_ss = " +
                steadyStateError(InputType.PARABOLIC, Kp, Kv, Ka));
    }
}
      

Libraries such as EJML or Apache Commons Math can be used alongside this class to derive \( L(s) \) and its low-frequency limits from state-space models of robotic manipulators or servo drives.

11.1 MATLAB/Simulink

In MATLAB, the Control System Toolbox provides direct support for transfer functions and steady-state analysis. For the same type 1 example \( L(s) = \dfrac{10}{s(0.5s + 1)} \):

% Open-loop transfer function
s = tf('s');
G = 10 / (s * (0.5*s + 1));
C = 1;
L = C*G;

% Error transfer E(s)/R(s) for unity feedback
E_over_R = feedback(1, L);

% Static error constants
Kp = dcgain(L);
Kv = dcgain(s*L);
Ka = dcgain(s^2*L);

fprintf('Kp = %g\n', Kp);
fprintf('Kv = %g\n', Kv);
fprintf('Ka = %g\n', Ka);

% Numerical steady-state errors
[et, t_step] = step(E_over_R);
e_step_ss = et(end);

t = linspace(0, 50, 2000);
r_ramp = t;           % unit ramp
[er_ramp, t_ramp] = lsim(E_over_R, r_ramp, t);
e_ramp_ss = er_ramp(end);

r_par = 0.5*t.^2;    % unit parabolic
[er_par, t_par] = lsim(E_over_R, r_par, t);
e_par_ss = er_par(end);

fprintf('Step e_ss (sim)      = %g\n', e_step_ss);
fprintf('Ramp e_ss (sim)      = %g\n', e_ramp_ss);
fprintf('Parabolic e_ss (sim) = %g\n', e_par_ss);

% Theoretical values
fprintf('Step e_ss (theory)   = %g\n', 1/(1 + Kp));
fprintf('Ramp e_ss (theory)   = %g\n', 1/Kv);
      

In Simulink, the same analysis can be performed by building the block diagram C(s)–G(s) with a unity feedback loop and injecting Step, Ramp, or Polynomial Reference blocks while measuring the error signal. The final value of the error waveform on a Scope block corresponds to \( e_{\mathrm{ss}} \). For robotic applications, the Robotics System Toolbox can generate linearized joint-space models which are then connected to classical control blocks.

11.2 Wolfram Mathematica

Mathematica is convenient for symbolic derivations of steady-state error. The following code computes \( e_{\mathrm{ss}} \) for step, ramp, and parabolic inputs for a generic type 1 open loop \( L(s) = \dfrac{k}{s(s + a)} \):

(* Symbolic steady-state error for a type-1 loop L(s) = k / (s (s + a)) *)

Clear[s, k, a];
L[s_] := k/(s (s + a));

(* Unit step: R(s) = 1/s *)
Estep[s_] := (1/s) * 1/(1 + L[s]);
EssStep = Limit[s*Estep[s], s -> 0,
                Assumptions -> {k > 0, a > 0}];

(* Unit ramp: R(s) = 1/s^2 *)
Eramp[s_] := (1/s^2) * 1/(1 + L[s]);
EssRamp = Limit[s*Eramp[s], s -> 0,
                Assumptions -> {k > 0, a > 0}];

(* Unit parabolic: R(s) = 1/s^3 *)
Epar[s_] := (1/s^3) * 1/(1 + L[s]);
EssPar = Limit[s*Epar[s], s -> 0,
               Assumptions -> {k > 0, a > 0}];

{EssStep, EssRamp, EssPar}
      

Mathematica returns explicit expressions that can be simplified symbolically to the familiar formulas \( e_{\mathrm{ss}}^{\text{step}} = 0 \), \( e_{\mathrm{ss}}^{\text{ramp}} = 1/K_v \), and \( e_{\mathrm{ss}}^{\text{parabolic}} = \infty \) for this type 1 loop.

Problem 1 (Type 0 system, all three inputs). A unity-feedback system has plant \( G(s) = \dfrac{10}{s + 2} \) and \( C(s) = 1 \). Compute \( K_p, K_v, K_a \) and the steady-state error for unit step, unit ramp, and unit parabolic inputs.

Solution. The open-loop transfer function is \( L(s) = G(s) = \dfrac{10}{s + 2} \), which is type 0 (no poles at the origin). Then

\[ K_p = \lim_{s \to 0} L(s) = \frac{10}{2} = 5, \qquad K_v = \lim_{s \to 0} s L(s) = 0, \qquad K_a = \lim_{s \to 0} s^{2} L(s) = 0. \]

Therefore,

• Step: \( e_{\mathrm{ss}}^{\text{step}} = \frac{1}{1 + K_p} = \frac{1}{6} \).
• Ramp: \( e_{\mathrm{ss}}^{\text{ramp}} = \infty \) since \( K_v = 0 \).
• Parabolic: \( e_{\mathrm{ss}}^{\text{parabolic}} = \infty \) since \( K_a = 0 \).

Problem 2 (Type 1 system, step and ramp). Consider a unity-feedback system with plant \( G(s) = \dfrac{50}{s(s + 5)} \) and \( C(s) = 1 \). Determine the system type, compute \( K_p, K_v \), and find the steady-state errors for unit step and unit ramp inputs.

Solution. We have \( L(s) = \dfrac{50}{s(s + 5)} \). There is one pole at the origin, so the system is type 1. Then

\[ K_p = \lim_{s \to 0} L(s) = \lim_{s \to 0} \frac{50}{s(s + 5)} = \infty, \]

and

\[ K_v = \lim_{s \to 0} s L(s) = \lim_{s \to 0} \frac{50}{s + 5} = \frac{50}{5} = 10. \]

Thus

• Step: \( e_{\mathrm{ss}}^{\text{step}} = \frac{1}{1 + K_p} = 0 \).
• Ramp: \( e_{\mathrm{ss}}^{\text{ramp}} = \frac{1}{K_v} = 0.1 \).

Problem 3 (Type 2 system, parabolic input). A unity-feedback system has open-loop transfer function \( L(s) = \dfrac{100}{s^{2}(s + 5)} \). Determine the system type and compute the steady-state errors for unit step, unit ramp, and unit parabolic inputs.

Solution. Two poles at the origin imply type 2. We compute

\[ K_p = \lim_{s \to 0} L(s) = \infty, \qquad K_v = \lim_{s \to 0} s L(s) = \lim_{s \to 0} \frac{100}{s(s + 5)} = \infty, \]

and

\[ K_a = \lim_{s \to 0} s^{2} L(s) = \lim_{s \to 0} \frac{100}{s + 5} = \frac{100}{5} = 20. \]

Hence

• Step: \( e_{\mathrm{ss}}^{\text{step}} = 0 \).
• Ramp: \( e_{\mathrm{ss}}^{\text{ramp}} = 0 \).
• Parabolic: \( e_{\mathrm{ss}}^{\text{parabolic}} = \frac{1}{K_a} = 0.05 \).

Problem 4 (Robot joint with PD control). A simplified robot joint has plant \( G(s) = \dfrac{1}{Js^{2} + bs} \) and a PD controller \( C(s) = K_{\mathrm{p}} + K_{\mathrm{d}} s \) with unity feedback. (i) Determine the system type. (ii) State the steady-state errors for unit step, unit ramp, and unit parabolic inputs in terms of \( K_p, K_v, K_a \).

Solution. First, rewrite

\[ G(s) = \frac{1}{Js^{2} + bs} = \frac{1}{s(Js + b)}. \]

Then

\[ L(s) = C(s)G(s) = \frac{K_{\mathrm{p}} + K_{\mathrm{d}} s}{s(Js + b)}. \]

There is exactly one pole at the origin, so the loop is type 1. Consequently,

• Step: since \( K_p = \infty \), we have \( e_{\mathrm{ss}}^{\text{step}} = 0 \).
• Ramp: \( e_{\mathrm{ss}}^{\text{ramp}} = \frac{1}{K_v} \), where \( K_v = \lim_{s \to 0} sL(s) \) depends on \( K_{\mathrm{p}}, K_{\mathrm{d}}, J, b \).
• Parabolic: type 1 gives \( K_a = 0 \), hence \( e_{\mathrm{ss}}^{\text{parabolic}} = \infty \).

In practice, to reduce ramp error for such a joint, an integral term is added to \( C(s) \), increasing the system type to 2 and improving tracking of constant-velocity trajectories.

Problem 5 (Design for ramp tracking accuracy). A unity-feedback system with proportional control has open-loop transfer function \( L(s) = \dfrac{k}{s(s + 4)} \). Design the gain \( k \) such that the steady-state error to a unit ramp does not exceed \( 0.02 \).

Solution. The system is type 1, so \( e_{\mathrm{ss}}^{\text{ramp}} = \frac{1}{K_v} \), where

\[ K_v = \lim_{s \to 0} s L(s) = \lim_{s \to 0} \frac{k}{s + 4} = \frac{k}{4}. \]

The requirement \( e_{\mathrm{ss}}^{\text{ramp}} \le 0.02 \) becomes

\[ \frac{1}{K_v} \le 0.02 \quad \Longleftrightarrow \quad \frac{1}{k/4} \le 0.02 \quad \Longleftrightarrow \quad \frac{4}{k} \le 0.02 \quad \Longleftrightarrow \quad k \ge 200. \]

Thus any proportional gain \( k \ge 200 \) yields the desired ramp-tracking accuracy, assuming the closed loop remains stable (which must be verified using the tools from Chapters 6 and 7).

In this lesson we rigorously derived steady-state error formulas for unity-feedback systems subjected to unit step, ramp, and parabolic inputs. Using the final value theorem, we showed that \( e_{\mathrm{ss}} \) is determined by low-frequency properties of the open-loop transfer function \( L(s) \), which are captured by the static error constants \( K_p, K_v, K_a \). We related these constants to the system type (number of integrators in the open loop) and summarized the resulting performance for standard test inputs in a compact table. Finally, we translated the theory into multi-language code examples and examined its implications for robotic servo systems, where steady-state error directly quantifies position, velocity, and acceleration tracking accuracy.