In Chapter 8, Lesson 1 you defined the error signal \( e(t) = r(t) - y(t) \) and studied standard test inputs like step, ramp, and parabolic signals. In this lesson we measure how well a closed-loop system tracks these references in the steady state by introducing:

• Static error constants: gains that map reference amplitude to steady-state error for specific input classes (step, ramp, parabolic, …).
• System type: an integer (Type 0, 1, 2, …) equal to the number of integrators (poles at the origin) in the open-loop transfer function.

These notions are fundamental in servo and robotic systems. For example, a robot joint controller of Type 1 can track constant-velocity ramp commands with finite steady-state error, whereas a Type 2 controller can track the same ramps with zero steady-state error but at the cost of potentially more overshoot and control effort.

flowchart TD
  R["Reference r(t) (step, ramp, etc.)"] --> L["Laplace domain R(s)"]
  L --> OL["Open-loop L(s) = G(s) H(s)"]
  OL --> E["Error E(s) = R(s)/(1 + L(s))"]
  E --> FV["Apply final value theorem to e(t)"]
  FV --> K["Define static constants Kp, Kv, Ka, ..."]
  K --> T["Identify system type: 0, 1, 2, ..."]
  T --> ESS["Predict steady state error e_ss"]
        

Consider a single-input single-output (SISO) LTI feedback system with forward-path transfer function \( G(s) \) and feedback transfer function \( H(s) \). The reference, output, and error in the Laplace domain satisfy:

\[ E(s) = R(s) - H(s) Y(s), \qquad Y(s) = G(s) E(s). \]

Eliminating \( Y(s) \) gives

\[ E(s)\bigl(1 + G(s) H(s)\bigr) = R(s) \quad \Longrightarrow \quad E(s) = \frac{R(s)}{1 + G(s) H(s)}. \]

Denote the open-loop transfer function by \( L(s) = G(s) H(s) \). Then

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

The steady-state error is \( e_{\mathrm{ss}} = \lim_{t \to \infty} e(t) \). For a closed-loop stable system (all poles of \( s E(s) \) in the open left-half plane or at most a simple pole at the origin), the final value theorem gives

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

The entire theory of static error constants and system type is built around this limit for various classes of reference signals \( R(s) \) and the low-frequency structure of \( L(s) \).

We focus on polynomial reference inputs commonly used for performance specification:

\[ \begin{aligned} r_{\text{step}}(t) &= A u(t), & R_{\text{step}}(s) &= \frac{A}{s}, \\[4pt] r_{\text{ramp}}(t) &= A t\, u(t), & R_{\text{ramp}}(s) &= \frac{A}{s^{2}}, \\[4pt] r_{\text{par}}(t) &= \frac{A}{2} t^{2} u(t), & R_{\text{par}}(s) &= \frac{A}{s^{3}}. \end{aligned} \]

For a unity-feedback system (\( H(s) = 1 \)), set \( L(s) = G(s) \). Inserting the step input yields

\[ e_{\mathrm{ss}}^{\text{step}} = \lim_{s \to 0} s \frac{A/s}{1 + L(s)} = A \lim_{s \to 0} \frac{1}{1 + L(s)}. \]

This motivates the position error constant \( K_p \):

\[ K_p := \lim_{s \to 0} L(s). \]

Assuming the limit exists (finite or \( \infty \)), we obtain

\[ e_{\mathrm{ss}}^{\text{step}} = \frac{A}{1 + K_p}. \]

For a unit ramp input (\( A = 1 \)), the error becomes

\[ e_{\mathrm{ss}}^{\text{ramp}} = \lim_{s \to 0} s \frac{1/s^{2}}{1 + L(s)} = \lim_{s \to 0} \frac{1}{s \bigl(1 + L(s)\bigr)}. \]

Multiply numerator and denominator by \( s \):

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

If the limit \( K_v := \lim_{s \to 0} s L(s) \) exists and is positive and finite, then \( s \to 0 \) while \( s L(s) \to K_v \), so

\[ e_{\mathrm{ss}}^{\text{ramp}} = \frac{1}{K_v}. \]

Analogously, for a unit parabolic input \( R_{\text{par}}(s) = 1/s^{3} \) we get

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

If \( K_a := \lim_{s \to 0} s^{2} L(s) \) exists, then

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

Collecting the definitions for a general (possibly non-unity) feedback loop with \( L(s) = G(s) H(s) \):

\[ \boxed{ K_p = \lim_{s \to 0} L(s), \quad K_v = \lim_{s \to 0} s L(s), \quad K_a = \lim_{s \to 0} s^{2} L(s) } \]

Higher-order constants can be defined similarly, but in practice \( K_p, K_v, K_a \) already cover most classical design specifications. Next we show that these limits are controlled almost entirely by the number of integrators in \( L(s) \).

Write the open-loop transfer function as a rational function of \( s \):

\[ L(s) = \frac{N(s)}{D(s)}, \]

where \( N(s) \) and \( D(s) \) are polynomials. Suppose the denominator has \( p \) roots, of which \( \nu \) are at the origin \( s = 0 \), after cancelling any common factors of \( s \) between numerator and denominator. Then we can factor \( L(s) \) as

\[ L(s) = \frac{K \displaystyle\prod_{i=1}^{z} (s - z_i)}{ s^{\nu} \displaystyle\prod_{j=1}^{p - \nu} (s - p_j)}, \qquad \prod_{j=1}^{p - \nu} (-p_j) \neq 0, \]

and write, near \( s = 0 \),

\[ L(s) = \frac{L_0(s)}{s^{\nu}}, \qquad L_0(0) \neq 0. \]

Definition (System type). The system type is the integer \( \nu \ge 0 \) defined by

\[ \nu = \text{(number of poles of } L(s) \text{ at } s = 0) - \text{(number of zeros of } L(s) \text{ at } s = 0). \]

• Type 0: \( \nu = 0 \), no net integrator.
• Type 1: \( \nu = 1 \), one net integrator.
• Type 2: \( \nu = 2 \), two net integrators.
• And so on for higher types.

Physically, each integrator corresponds (in many mechanical systems) to one level of time integration between control input and measured output. For example, in a simple robot joint, torque → angular acceleration → angular velocity → angle, so that model can contain up to two integrators between torque and position.

Using the factorization \( L(s) = L_0(s) / s^{\nu} \) with \( L_0(0) \neq 0 \), expand the static error constants. For small \( s \),

\[ L(s) \sim \frac{L_0(0)}{s^{\nu}}. \]

Hence

\[ \begin{aligned} K_p &= \lim_{s \to 0} L(s) = \begin{cases} L_0(0) & \text{if } \nu = 0, \\ \infty & \text{if } \nu \ge 1, \end{cases} \\[6pt] K_v &= \lim_{s \to 0} s L(s) = \lim_{s \to 0} s \frac{L_0(s)}{s^{\nu}} = \begin{cases} 0 & \text{if } \nu = 0, \\ L_0(0) & \text{if } \nu = 1, \\ \infty & \text{if } \nu \ge 2, \end{cases} \\[6pt] K_a &= \lim_{s \to 0} s^{2} L(s) = \lim_{s \to 0} s^{2} \frac{L_0(s)}{s^{\nu}} = \begin{cases} 0 & \text{if } \nu \le 1, \\ L_0(0) & \text{if } \nu = 2, \\ \infty & \text{if } \nu \ge 3. \end{cases} \end{aligned} \]

Using the formulas from Section 3, the steady-state error behavior for unit step, ramp, and parabolic inputs is as follows:

\[ \begin{array}{c|ccc} \text{Type } \nu & e_{\mathrm{ss}}^{\text{step}} & e_{\mathrm{ss}}^{\text{ramp}} & e_{\mathrm{ss}}^{\text{par}} \\ \hline 0 & \displaystyle \frac{1}{1 + K_p} \text{ (finite)} & \infty & \infty \\[6pt] 1 & 0 & \displaystyle \frac{1}{K_v} \text{ (finite)} & \infty \\[6pt] 2 & 0 & 0 & \displaystyle \frac{1}{K_a} \text{ (finite)} \\[6pt] \nu \ge 3 & 0 & 0 & 0 \text{ for parabolic; check higher-order inputs} \end{array} \]

More generally, if the reference is a polynomial of degree \( m \), so that \( R(s) \propto 1/s^{m+1} \), one can prove the following:

• If \( \nu > m \), then \( e_{\mathrm{ss}} = 0 \).
• If \( \nu = m \), then \( e_{\mathrm{ss}} \) is finite and nonzero.
• If \( \nu < m \), then \( e_{\mathrm{ss}} = \infty \).

Proof sketch. Let \( R(s) = \beta / s^{m+1} \) for some constant \( \beta \neq 0 \). Then

\[ e_{\mathrm{ss}} = \lim_{s \to 0} s \frac{\beta / s^{m+1}}{1 + L(s)} = \beta \lim_{s \to 0} \frac{s^{-m}}{1 + L(s)}. \]

For \( \nu = 0 \), \( L(s) \to L_0(0) \) and \( s^{-m} \) diverges for \( m \ge 1 \), giving infinite steady-state error except for step inputs. For \( \nu \ge 1 \), \( L(s) \sim L_0(0) / s^{\nu} \), so \( 1 + L(s) \sim L(s) \). Hence

\[ e_{\mathrm{ss}} \sim \beta \lim_{s \to 0} \frac{s^{-m}}{L_0(0) / s^{\nu}} = \frac{\beta}{L_0(0)} \lim_{s \to 0} s^{\nu - m}. \]

The exponent \( \nu - m \) determines whether the limit is zero, finite nonzero, or infinite, leading to the three cases above.

flowchart TD
  L["Open-loop L(s) = G(s) H(s)"] --> F["Factor L(s) near s = 0"]
  F --> C["Count net poles at origin: type = nu"]
  C --> T0["type = 0 \n(no integrator)"]
  C --> T1["type = 1 \n(one integrator)"]
  C --> T2["type >= 2 \n(two or more integrators)"]
  T0 --> R0["Finite step error; \ninfinite ramp and higher"]
  T1 --> R1["Zero step error; \nfinite ramp error; \ninfinite parabolic"]
  T2 --> R2["Zero step and ramp error; \nfinite parabolic (for type = 2)"]
        

Python, together with the python-control library, is widely used in robotics for modeling actuators, links, and feedback loops. Below is a utility that, given a SISO transfer function, computes an approximate system type and the static error constants.

import numpy as np
import control as ctl  # python-control, common in robotics/control
# pip install control

def trailing_zeros(coeffs, tol=1e-9):
    """Count trailing zeros (small coefficients) in polynomial coefficient array.
       Coeffs are ordered from highest power down to constant term."""
    k = 0
    for c in coeffs[::-1]:  # start from constant term
        if abs(c) < tol:
            k += 1
        else:
            break
    return k

def system_type_and_static_constants(G, H=1.0, s_eps=1e-6):
    """
    Compute system type (net number of integrators in L(s) = G(s)H(s))
    and approximate {Kp, Kv, Ka}.
    """
    # Build open-loop L(s)
    if isinstance(H, (int, float)):
        L = G * H
    else:
        L = G * H

    num, den = ctl.tfdata(L)  # returns arrays with shape (1, 1, n)
    num = np.squeeze(num).astype(float)
    den = np.squeeze(den).astype(float)

    n_zeros_at_origin = trailing_zeros(num)
    n_poles_at_origin = trailing_zeros(den)
    sys_type = max(n_poles_at_origin - n_zeros_at_origin, 0)

    # Evaluate static error constants numerically
    # (good enough for engineering use if s_eps is small)
    L0 = ctl.evalfr(L, 0)              # L(0)
    Ls = ctl.evalfr(L, s_eps)          # L(s_eps), s_eps small

    Kp = np.real_if_close(L0)
    Kv = np.real_if_close(s_eps * Ls)
    Ka = np.real_if_close((s_eps ** 2) * Ls)

    return {"type": int(sys_type), "Kp": float(Kp),
            "Kv": float(Kv), "Ka": float(Ka)}

# Example: simple robot joint position loop plant
# Motor + load: G(s) = K / (J s^2 + B s)
J = 0.01   # kg m^2
B = 0.1    # N m s/rad
K = 1.0    # gain (N m / control signal)

s = ctl.TransferFunction.s
G_joint = K / (J * s**2 + B * s)  # position / control signal
L_joint = G_joint                 # unity feedback for simplicity

info = system_type_and_static_constants(L_joint)
print("System type:", info["type"])
print("Kp, Kv, Ka:", info["Kp"], info["Kv"], info["Ka"])

# You can also simulate a step or ramp response to validate predictions:
t, y_step = ctl.step_response(ctl.feedback(L_joint, 1), T=np.linspace(0, 5, 500))
      

For the joint plant above, the denominator has two powers of \( s \), so the system is nominally Type 1 (one net integrator between error and position once the proportional feedback loop is closed). Accurate classification depends on including the controller transfer function \( G_c(s) \) inside \( G(s) \). This will be revisited when PID control is introduced.

In embedded controllers or ROS nodes for robotic systems (e.g., ros_control based joint controllers), one often uses simple polynomial models for actuators. The following C++ utility assumes a SISO transfer function \( L(s) = N(s)/D(s) \), with numerator and denominator polynomials given as coefficient vectors in descending powers of \( s \).

#include <vector>
#include <cmath>
#include <iostream>

struct StaticErrorConstants {
    int type;    // system type (0, 1, 2, ...)
    double Kp;   // position constant
    double Kv;   // velocity constant
    double Ka;   // acceleration constant
};

int trailingZeros(const std::vector<double>& c, double tol = 1e-9) {
    int k = 0;
    for (int i = static_cast<int>(c.size()) - 1; i >= 0; --i) {
        if (std::fabs(c[i]) < tol) {
            ++k;
        } else {
            break;
        }
    }
    return k;
}

double evalPoly(const std::vector<double>& c, double s) {
    // Horner's rule: c[0] s^n + ... + c[n]
    double val = 0.0;
    for (double a : c) {
        val = val * s + a;
    }
    return val;
}

StaticErrorConstants computeStaticConstants(
    const std::vector<double>& num,
    const std::vector<double>& den,
    double s_eps = 1e-6)
{
    StaticErrorConstants out{0, 0.0, 0.0, 0.0};

    int z_num = trailingZeros(num);
    int z_den = trailingZeros(den);
    int type = z_den - z_num;
    if (type < 0) type = 0;
    out.type = type;

    // Approximate L(0), s L(s), s^2 L(s) numerically
    double L0 = evalPoly(num, 0.0) / evalPoly(den, 0.0);  // may overflow if type > 0
    double Ls = evalPoly(num, s_eps) / evalPoly(den, s_eps);

    out.Kp = L0;                  // may be very large if type >= 1
    out.Kv = s_eps * Ls;
    out.Ka = s_eps * s_eps * Ls;

    return out;
}

int main() {
    // Example: L(s) = 50 / (s (s + 5))  (Type 1 system)
    std::vector<double> num{50.0};      // 50
    std::vector<double> den{1.0, 5.0, 0.0}; // s^2 + 5 s + 0

    StaticErrorConstants c = computeStaticConstants(num, den);
    std::cout << "System type: " << c.type << "\n";
    std::cout << "Kp = " << c.Kp
              << ", Kv = " << c.Kv
              << ", Ka = " << c.Ka << "\n";

    // In a ROS controller, these constants can be logged or used
    // to check if the loop meets tracking specifications.
    return 0;
}
      

This code does not perform symbolic pole-zero cancellation; it assumes the polynomials already reflect the net integrator order. In a full robotics stack, such models might be generated from multibody dynamics packages and then reduced to SISO loops for each joint.

In Java-based robotics systems (for example, using ROSJava or simulation frameworks), one can implement similar utilities to analyze system type and error constants. The following class illustrates the idea.

public final class StaticErrorAnalysis {

    public static int trailingZeros(double[] coeffs, double tol) {
        int k = 0;
        for (int i = coeffs.length - 1; i >= 0; --i) {
            if (Math.abs(coeffs[i]) < tol) {
                k++;
            } else {
                break;
            }
        }
        return k;
    }

    public static double evalPoly(double[] coeffs, double s) {
        double val = 0.0;
        for (double a : coeffs) {
            val = val * s + a;
        }
        return val;
    }

    public static class Result {
        public int type;
        public double Kp, Kv, Ka;
    }

    public static Result compute(double[] num, double[] den, double sEps) {
        Result r = new Result();
        int zNum = trailingZeros(num, 1e-9);
        int zDen = trailingZeros(den, 1e-9);
        r.type = Math.max(zDen - zNum, 0);

        double L0 = evalPoly(num, 0.0) / evalPoly(den, 0.0);
        double Ls = evalPoly(num, sEps) / evalPoly(den, sEps);

        r.Kp = L0;
        r.Kv = sEps * Ls;
        r.Ka = sEps * sEps * Ls;
        return r;
    }

    public static void main(String[] args) {
        // Example: L(s) = 20 (s + 2) / (s^2 (s + 5))  (Type 2)
        double[] num = {20.0, 40.0};      // 20 s + 40
        double[] den = {1.0, 5.0, 0.0, 0.0}; // s^3 + 5 s^2 + 0 s + 0

        Result r = compute(num, den, 1e-6);
        System.out.println("System type = " + r.type);
        System.out.println("Kp = " + r.Kp + ", Kv = " + r.Kv + ", Ka = " + r.Ka);

        // In a robotics middleware layer, this could be combined with
        // Apache Commons Math for more advanced polynomial and matrix operations.
    }
}
      

While Java is not as dominant as C++ or MATLAB in classical control, such utilities can be used for online monitoring of servo performance or automatic selection of controller parameters in robot software architectures.

MATLAB is the de facto standard in many control and robotics labs. The Control System Toolbox provides transfer function objects, and the Robotics System Toolbox can generate linear models from rigid-body manipulators. Below is a MATLAB script that:

1. Defines an open-loop transfer function.
2. Computes system type and static error constants.
3. Prepares for Simulink validation.

% Define Laplace variable and transfer function
s = tf('s');

% Example: L(s) = 50 / (s * (s + 5)) (Type 1 system)
L = 50 / (s * (s + 5));

% Extract numerator and denominator
[num, den] = tfdata(L, 'v');  % row vectors, descending powers of s

% Count trailing zeros in denominator to estimate integrator order
tol = 1e-9;
type = 0;
for k = 1:length(den)
    if abs(den(end - k + 1)) < tol
        type = type + 1;
    else
        break;
    end
end

% Static error constants (approximate for Kv, Ka)
Kp = dcgain(L);            % Kp = L(0) for Type 0; infinite for higher types
s_eps = 1e-6;
Ls = evalfr(L, s_eps);
Kv = s_eps^1 * Ls;
Ka = s_eps^2 * Ls;

fprintf('System type: %d\n', type);
fprintf('Kp = %g, Kv ≈ %g, Ka ≈ %g\n', Kp, Kv, Ka);

% Simulink note:
% Build a unity-feedback loop with:
%   - "Step" or "Ramp" block as reference
%   - "Sum" block for error
%   - "Transfer Fcn" block with numerator num and denominator den
%   - Feedback path of gain 1
% Then measure e(t) using a "Scope" block and compare steady-state error
% against 1/(1 + Kp), 1/Kv, 1/Ka predicted here.

% Robotics note:
% For a robot arm model 'robot' from Robotics System Toolbox, use:
% linSys = linearize('yourSimulinkModel', 'IOset');
% and then apply the same logic to the SISO loop representing a given joint.
      

Simulink models built in this way allow you to visually verify how system type and static error constants manifest in time-domain tracking errors for robotic actuators and other mechatronic systems.

Wolfram Mathematica offers symbolic manipulation of transfer functions and limits, which is useful for verifying theoretical relationships.

(* Define open-loop transfer function L(s) *)
Clear[s];
L[s_] := 50/(s (s + 5));  (* Type 1 system *)

(* System type via smallest power of s in the denominator *)
den[s_] := s (s + 5);
type = Exponent[den[s], s, Min];  (* 1 integrator at s = 0 *)

(* Static error constants *)
Kp = Limit[L[s], s -> 0];           (* position constant *)
Kv = Limit[s L[s], s -> 0];         (* velocity constant *)
Ka = Limit[s^2 L[s], s -> 0];       (* acceleration constant *)

Print["System type: ", type];
Print["Kp = ", Kp, ", Kv = ", Kv, ", Ka = ", Ka];

(* General symbolic result for polynomial input of degree m *)
Clear[m, beta];
R[s_] := beta/s^(m + 1);
ess[s_] := s R[s]/(1 + L[s]);
essLimit = Limit[ess[s] /. L[s] -> L0/s^type, s -> 0,
  Assumptions -> {L0 != 0, type >= 1, m >= 0}];
      

Symbolic tools such as Mathematica are especially useful for proving general results like the polynomial-input theorem discussed in Section 5 and for exploring the effect of uncertain parameters on system type and tracking accuracy.

Problem 1 (Type and Static Constants for a First-Order Loop). Consider a unity-feedback system with \( G(s) = \dfrac{10}{s + 10} \).
(a) Determine the system type.
(b) Compute \( K_p, K_v, K_a \).
(c) Compute the steady-state error for a unit-step input.

Solution.

(a) The open-loop transfer function is \( L(s) = G(s) = 10/(s + 10) \). There is no pole at the origin, hence \( \nu = 0 \), a Type 0 system.

(b) Evaluate the static constants:

\[ K_p = \lim_{s \to 0} \frac{10}{s + 10} = 1, \quad K_v = \lim_{s \to 0} s \frac{10}{s + 10} = 0, \quad K_a = \lim_{s \to 0} s^{2} \frac{10}{s + 10} = 0. \]

(c) For a unit step, \( A = 1 \), the steady-state error is

\[ e_{\mathrm{ss}}^{\text{step}} = \frac{1}{1 + K_p} = \frac{1}{2}. \]

As expected for a Type 0 system, the ramp and parabolic steady-state errors are infinite because \( K_v = K_a = 0 \).

Problem 2 (Type 1 Robot Joint Servo). A simplified DC-motor position servo has open-loop transfer function

\[ L(s) = \frac{50}{s (s + 5)}. \]

(a) Determine the system type.
(b) Compute \( K_p, K_v, K_a \).
(c) Determine the unit-step and unit-ramp steady-state errors.

Solution.

(a) The denominator \( s (s + 5) \) has one pole at the origin. There is no zero at the origin in the numerator. Thus \( \nu = 1 \), a Type 1 system.

(b) Static constants:

\[ \begin{aligned} K_p &= \lim_{s \to 0} \frac{50}{s (s + 5)} = \infty, \\[4pt] K_v &= \lim_{s \to 0} s \frac{50}{s (s + 5)} = \lim_{s \to 0} \frac{50}{s + 5} = 10, \\[4pt] K_a &= \lim_{s \to 0} s^{2} \frac{50}{s (s + 5)} = \lim_{s \to 0} \frac{50 s}{s + 5} = 0. \end{aligned} \]

(c) For the step input, \( e_{\mathrm{ss}}^{\text{step}} = 1/(1 + K_p) = 0 \), i.e., zero steady-state position error. For the unit ramp,

\[ e_{\mathrm{ss}}^{\text{ramp}} = \frac{1}{K_v} = \frac{1}{10} = 0.1. \]

The parabolic steady-state error is infinite because \( K_a = 0 \). This is consistent with the general Type 1 classification: zero error for steps, finite error for ramps, and infinite error for parabolas.

Problem 3 (Type 2 System and Parabolic Input). Consider a unity-feedback system with

\[ L(s) = \frac{20 (s + 2)}{s^{2} (s + 5)}. \]

(a) Determine the system type.
(b) Compute \( K_p, K_v, K_a \).
(c) Determine the unit-parabolic steady-state error.

Solution.

(a) The denominator has \( s^{2} \) as a factor, and the numerator is nonzero at \( s = 0 \). Thus \( \nu = 2 \), a Type 2 system.

(b) Static constants:

\[ \begin{aligned} K_p &= \lim_{s \to 0} L(s) = \lim_{s \to 0} \frac{20 (s + 2)}{s^{2} (s + 5)} = \infty, \\[4pt] K_v &= \lim_{s \to 0} s L(s) = \lim_{s \to 0} \frac{20 s (s + 2)}{s^{2} (s + 5)} = \lim_{s \to 0} \frac{20 (s + 2)}{s (s + 5)} = \infty, \\[4pt] K_a &= \lim_{s \to 0} s^{2} L(s) = \lim_{s \to 0} \frac{20 s^{2} (s + 2)}{s^{2} (s + 5)} = \lim_{s \to 0} \frac{20 (s + 2)}{s + 5} = \frac{40}{5} = 8. \end{aligned} \]

(c) For a unit-parabolic input, the steady-state error is \( e_{\mathrm{ss}}^{\text{par}} = 1/K_a = 1/8 \). This matches the general Type 2 rule: zero steady-state error for step and ramp inputs, finite nonzero error for parabolic inputs.

Problem 4 (General Polynomial Input Theorem). Let a unity-feedback system have open-loop transfer function \( L(s) = L_0(s)/s^{\nu} \) with \( L_0(0) \neq 0 \) and integer \( \nu \ge 1 \). Let the reference be a polynomial of degree \( m \ge 0 \), so that \( R(s) = \beta / s^{m+1} \) for some \( \beta \neq 0 \). Show that

• \( e_{\mathrm{ss}} = 0 \) if \( \nu > m \).
• \( e_{\mathrm{ss}} \) is finite and nonzero if \( \nu = m \).
• \( e_{\mathrm{ss}} = \infty \) if \( \nu < m \).

Solution.

From Section 5 we have

\[ e_{\mathrm{ss}} = \lim_{s \to 0} s \frac{R(s)}{1 + L(s)} = \beta \lim_{s \to 0} \frac{s^{-m}}{1 + L(s)}. \]

For \( \nu \ge 1 \), \( L(s) \sim L_0(0)/s^{\nu} \) as \( s \to 0 \), so \( 1 + L(s) \sim L(s) \). Thus

\[ e_{\mathrm{ss}} \sim \beta \lim_{s \to 0} \frac{s^{-m}}{L_0(0)/s^{\nu}} = \frac{\beta}{L_0(0)} \lim_{s \to 0} s^{\nu - m}. \]

If \( \nu - m > 0 \), the factor \( s^{\nu - m} \to 0 \) and \( e_{\mathrm{ss}} = 0 \). If \( \nu - m = 0 \), the factor is 1, yielding a finite nonzero limit. If \( \nu - m < 0 \), \( s^{\nu - m} \to \infty \), so \( e_{\mathrm{ss}} = \infty \). This completes the proof.

Problem 5 (Effect of Sensor Dynamics on Type). A robot joint is controlled by a unity-feedback loop with plant

\[ G(s) = \frac{K}{s (s + 2)}, \]

and a first-order sensor dynamics

\[ H(s) = \frac{1}{0.1 s + 1}. \]

(a) Determine the system type of the loop with ideal sensor \( H(s) = 1 \).
(b) Determine the system type when the sensor dynamics are included, \( L(s) = G(s) H(s) \).
(c) Compare the steady-state step and ramp errors in both cases.

Solution.

(a) With ideal sensor, open loop is \( L_{\text{ideal}}(s) = K/(s (s + 2)) \). There is one pole at the origin and no zero at the origin, so \( \nu = 1 \): a Type 1 system.

(b) With sensor dynamics,

\[ L(s) = \frac{K}{s (s + 2)} \cdot \frac{1}{0.1 s + 1} = \frac{K}{s (s + 2) (0.1 s + 1)}. \]

The additional factor \( 0.1 s + 1 \) introduces no new pole at the origin. Therefore the number of poles at the origin is still 1, and the system remains Type 1.

(c) Since the system type is unchanged, the qualitative steady-state behavior is the same: zero error for step inputs and finite nonzero error for ramp inputs. However, the precise values of \( K_v \) and the ramp error \( 1/K_v \) will change because the low-frequency gain of \( L(s) \) is modified by the sensor dynamics. Detailed numerical values require choosing a specific gain \( K \) and evaluating \( K_p, K_v \) as in previous problems.

In this lesson you learned how static error constants \( K_p, K_v, K_a \) quantify steady-state tracking accuracy for step, ramp, and parabolic inputs, and how these constants are determined in a simple way by the system type — the net number of integrators in the open-loop transfer function. We showed that a Type 0 system can achieve only finite step accuracy, Type 1 eliminates step error and yields finite ramp error, and Type 2 eliminates both step and ramp error while leaving a finite parabolic error. These results extend to polynomial inputs of arbitrary degree.

You also saw how to compute system type and static error constants in Python, C++, Java, MATLAB/Simulink, and Mathematica, with an eye toward robotic motion-control applications. In the next lesson, these tools will be used systematically to compute and design for steady-state error specifications in practical control problems.