Consider a unity-feedback configuration with reference input \( R(s) \), plant \( G(s) \), controller \( C(s) \) and error \( E(s) = R(s) - Y(s) \). For unity feedback, the loop transfer function is \( L(s) = C(s)G(s) \), and the error transfer function is

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

The steady-state error for a given reference input is

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

where the last equality follows from the final-value theorem (assuming all closed-loop poles lie strictly in the left half-plane).

A typical design specification in this chapter is of the form

\[ \text{Given } G(s), \text{ design } C(s) \text{ such that } e_{\mathrm{ss}} \text{ for a prescribed input type} \\ \text{ is zero or below a specified bound.} \]

The key observation is that only the low-frequency behaviour of \( L(s) \) determines \( e_{\mathrm{ss}} \). Thus we aim to shape \( L(s) \) near \( s = 0 \) (through gain and integrators) subject to stability constraints from Chapter 7 (for example, via Routh–Hurwitz).

flowchart TD
  RQ["Specify steady-state error requirement (input type, bound)"]
    --> TY["Determine required system type (0,1,2,...)"]
    --> ST["Check plant type from G(s)"]
    --> CT["Choose controller C(s) structure (P, PI, etc.)"]
    --> LG["Compute low-frequency gain L(0), Kv, Ka"]
    --> STAB["Check stability (e.g. Routh-Hurwitz)"]
    --> ITER["Adjust gains/structure until specs satisfied"]
        

From Lesson 2, the type of a unity-feedback system is the number of pure integrators in \( L(s) = C(s)G(s) \). If we factor out the integrators explicitly,

\[ L(s) = \frac{K}{s^{n}}\tilde{L}(s), \qquad \tilde{L}(0) \neq 0,\ \tilde{L}(0) \text{ finite}, \]

then the system is type \( n \). The static error constants are

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

For standard test inputs with unit amplitude:

• Step \( r(t) = u(t) \), \( R(s) = 1/s \):

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

• Ramp \( r(t) = t u(t) \), \( R(s) = 1/s^{2} \):

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

• Parabolic \( r(t) = \tfrac{1}{2}t^{2} u(t) \), \( R(s) = 1/s^{3} \):

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

Using these expressions, one can show the classical table:

\[ \begin{array}{c|ccc} \text{Type } n & e_{\mathrm{ss}}^{\text{step}} & e_{\mathrm{ss}}^{\text{ramp}} & e_{\mathrm{ss}}^{\text{parabolic}} \\ \hline 0 & \text{finite} & \infty & \infty \\ 1 & 0 & \text{finite} & \infty \\ 2 & 0 & 0 & \text{finite} \end{array} \]

Hence:

• Zero steady-state error to step inputs requires type at least 1.
• Zero steady-state error to ramp inputs requires type at least 2.
• Zero steady-state error to parabolic inputs requires type at least 3.

If the plant has type \( n_{\mathrm{plant}} \) and the controller contributes \( n_{\mathrm{ctrl}} \) pure integrators (for example, PI adds one pure integrator), then

\[ n_{\mathrm{type}} = n_{\mathrm{plant}} + n_{\mathrm{ctrl}}. \]

Designing for zero steady-state error thus begins by ensuring the overall type is high enough through the introduction of integral action where needed.

Often we require not necessarily zero, but a maximum steady-state error; for example,

\[ e_{\mathrm{ss}}^{\text{step}} \leq e_{\max}^{\text{step}},\qquad e_{\mathrm{ss}}^{\text{ramp}} \leq e_{\max}^{\text{ramp}}. \]

Using the formulas above for a unit step:

\[ e_{\mathrm{ss}}^{\text{step}} = \frac{1}{1 + K_p} \leq e_{\max}^{\text{step}} \quad \Longrightarrow \quad K_p \geq \frac{1 - e_{\max}^{\text{step}}}{e_{\max}^{\text{step}}}. \]

For a unit ramp:

\[ e_{\mathrm{ss}}^{\text{ramp}} = \frac{1}{K_v} \leq e_{\max}^{\text{ramp}} \quad \Longrightarrow \quad K_v \geq \frac{1}{e_{\max}^{\text{ramp}}}. \]

Thus a steady-state error specification translates to a lower bound on the corresponding static error constant, which in turn constrains the low-frequency gain of \( L(s) \).

Assume a proportional controller \( C(s) = K \) and a type 0 plant

\[ G(s) = \frac{k_{\mathrm{p}}}{(s + a_{1})(s + a_{2})\cdots(s + a_{m})}, \qquad a_{i} > 0. \]

Then

\[ L(s) = KG(s),\qquad K_p = \lim_{s\to 0} KG(s) = K \frac{k_{\mathrm{p}}}{a_{1}a_{2}\cdots a_{m}}. \]

For a bound \( e_{\max}^{\text{step}} \), the minimum proportional gain is

\[ K \geq \frac{a_{1}a_{2}\cdots a_{m}}{k_{\mathrm{p}}} \frac{1 - e_{\max}^{\text{step}}}{e_{\max}^{\text{step}}}. \]

This illustrates directly how steady-state accuracy requirements constrain the controller gain. Increasing \( K \) improves steady-state accuracy, but Chapter 7 shows that excessively large \( K \) can degrade stability margins and transient behaviour.

Integral control raises the system type by one and forces the steady-state error to constant inputs (reference or disturbance) to vanish, provided the closed-loop system remains asymptotically stable.

For a plant \( G(s) \) of type \( n_{\mathrm{plant}} \), a PI controller has the form

\[ C(s) = K_{\mathrm{p}} + \frac{K_{\mathrm{i}}}{s} = \frac{K_{\mathrm{p}} s + K_{\mathrm{i}}}{s}. \]

The loop transfer function becomes

\[ L(s) = C(s)G(s) = \frac{K_{\mathrm{p}} s + K_{\mathrm{i}}}{s}G(s), \]

which has one additional integrator compared to \( G(s) \). Hence

\[ n_{\mathrm{type,new}} = n_{\mathrm{plant}} + 1. \]

If \( n_{\mathrm{plant}} = 0 \), PI control yields a type 1 system, guaranteeing zero steady-state error for step inputs and finite ramp error.

Integral action also cancels constant biases and disturbances. For example, consider a constant disturbance at the plant input represented as \( d(t) = d_{0} \). With integral action, the controller will continue integrating the error until the control signal compensates for the disturbance, driving the steady-state error to zero (again assuming closed-loop stability).

The main design difficulty is that integral action reduces damping and can lead to overshoot or even instability; therefore, its gain must be chosen carefully, often in combination with proportional action and stability checks.

Consider a first-order plant, representative of many robotic actuators with dominant first-order dynamics:

\[ G(s) = \frac{5}{s + 3}. \]

This is a type 0 plant. Suppose we require:

• Zero steady-state error for a unit step reference.
• Ramp error not exceeding \( e_{\max}^{\text{ramp}} = 0.2 \) for a unit-slope ramp.

Since the plant is type 0, zero step error requires at least one integrator, so we choose a PI controller

\[ C(s) = K_{\mathrm{p}} + \frac{K_{\mathrm{i}}}{s} = \frac{K_{\mathrm{p}} s + K_{\mathrm{i}}}{s}. \]

The loop transfer function is

\[ L(s) = C(s)G(s) = \frac{K_{\mathrm{p}} s + K_{\mathrm{i}}}{s} \frac{5}{s + 3} = \frac{5(K_{\mathrm{p}} s + K_{\mathrm{i}})}{s(s + 3)}. \]

The system is now type 1, so the steady-state error to a unit step is automatically zero. For the ramp error, we compute \( K_v \):

\[ K_v = \lim_{s\to 0} sL(s) = \lim_{s\to 0} \frac{5(K_{\mathrm{p}} s + K_{\mathrm{i}})}{s + 3} = \frac{5 K_{\mathrm{i}}}{3}. \]

Therefore

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

The requirement \( e_{\mathrm{ss}}^{\text{ramp}} \leq 0.2 \) implies

\[ \frac{3}{5 K_{\mathrm{i}}} \leq 0.2 \quad\Longrightarrow\quad K_{\mathrm{i}} \geq 3. \]

Next we check stability. The closed-loop characteristic equation is \( 1 + L(s) = 0 \), or

\[ 1 + \frac{5(K_{\mathrm{p}} s + K_{\mathrm{i}})}{s(s + 3)} = 0 \quad \Longleftrightarrow \quad s(s + 3) + 5(K_{\mathrm{p}} s + K_{\mathrm{i}}) = 0. \]

Expanding,

\[ s^{2} + 3s + 5K_{\mathrm{p}} s + 5K_{\mathrm{i}} = 0 \quad\Longrightarrow\quad s^{2} + (3 + 5K_{\mathrm{p}})s + 5K_{\mathrm{i}} = 0. \]

For a second-order polynomial with positive coefficients, asymptotic stability requires

\[ 3 + 5K_{\mathrm{p}} > 0,\qquad 5K_{\mathrm{i}} > 0. \]

Thus any choice with \( K_{\mathrm{i}} > 0 \) and \( K_{\mathrm{p}} > -0.6 \) is stable. Combining with the steady-state requirement \( K_{\mathrm{i}} \geq 3 \), one possible design is

\[ K_{\mathrm{p}} = 1,\qquad K_{\mathrm{i}} = 4. \]

This example illustrates a general analytic design pattern: choose controller structure to meet type requirements, select integral gain from steady-state constraints, and then adjust proportional gain to achieve acceptable transient response while maintaining stability.

flowchart LR
  R["r(s)"] --> SUM["+"] --> C["C(s) = Kp + Ki/s"]
  C --> G["G(s) = 5/(s + 3)"] --> Y["y(s)"]
  SUM -->|"minus y(s)"| NEG["-"]
        

In a robotic manipulator, each joint is often driven by an electric motor with approximately first-order speed dynamics or second-order position dynamics. The position control loop used in industrial servo drives is typically a cascade of loops (current, speed, position), but the outermost position loop is structurally similar to the unity feedback system considered here.

If the joint experiences constant gravity torque or frictional offsets, a proportional controller will leave a nonzero steady-state position error. Integral action in the position loop is required to guarantee zero position error under constant disturbances, which is critical for tasks such as precision assembly or force-controlled contact.

Thus the algebraic conditions for type and error constants directly correspond to physical requirements such as zero static position error or bounded constant velocity tracking error in robotic joints.

Using the python-control library we can prototype the PI design for the plant \( G(s) = 5/(s + 3) \) and verify the steady-state error properties numerically. In a robotics context, python-control can be combined with robot modeling libraries such as roboticstoolbox-python to design joint-level servos.

import numpy as np
import control as ct
import matplotlib.pyplot as plt

# Plant model: approximated joint actuator (continuous time)
s = ct.TransferFunction.s
G = 5 / (s + 3)

# PI controller from the analytic design
Kp = 1.0
Ki = 4.0
C = Kp + Ki / s  # C(s) = Kp + Ki/s

L = C * G               # loop transfer function
T = ct.feedback(L, 1)   # closed-loop from r to y
S = 1 - T               # sensitivity (from r to e)

# Static error constants (step and ramp)
# Kp_static = lim_{s->0} L(s)
Kp_static = ct.dcgain(L)  # dcgain gives G(0) for proper systems

# Kv = lim_{s->0} s L(s)
Kv_tf = s * L
Kv_static = ct.dcgain(Kv_tf)

print("Kp (static) =", Kp_static)
print("Kv (static) =", Kv_static)
print("Predicted ramp error (unit ramp) =", 1.0 / Kv_static)

# Numerical simulation for step and ramp
t = np.linspace(0, 10, 1000)

# Step response (unit step)
t_step, y_step = ct.step_response(T, T=t)
e_step = 1.0 - y_step

# Ramp response: r(t) = t for t >= 0
r_ramp = t
t_ramp, y_ramp, x_ramp = ct.forced_response(T, T=t, U=r_ramp)
e_ramp = r_ramp - y_ramp

print("Approximate steady-state step error =", e_step[-1])
print("Approximate steady-state ramp error =", e_ramp[-1])

# Plot ramp tracking
plt.figure()
plt.plot(t_ramp, r_ramp, label="r(t) = ramp")
plt.plot(t_ramp, y_ramp, label="y(t)")
plt.xlabel("Time [s]")
plt.ylabel("Position")
plt.legend()
plt.title("Ramp tracking with PI controller")
plt.grid(True)
plt.show()
      

The numerical steady-state ramp error should agree closely with the analytic value \( e_{\mathrm{ss}}^{\text{ramp}} = 3/(5K_{\mathrm{i}}) \). Variations arise from finite simulation horizon and numerical effects.

In embedded robotic controllers (for example, using ROS 2 and ros2_control), the servo loop is implemented in discrete time. The code fragment below simulates a discrete-time PI controller acting on a first-order joint model \( \dot{y}(t) = -3 y(t) + 5 u(t) \), a time-domain counterpart of \( G(s) = 5/(s + 3) \).

#include <iostream>
#include <vector>

// Simple first-order joint model: y_dot = -3 y + 5 u
// Discretized with forward Euler for illustration.

struct PIController {
    double Kp;
    double Ki;
    double integral;

    PIController(double Kp_, double Ki_)
        : Kp(Kp_), Ki(Ki_), integral(0.0) {}

    double update(double r, double y, double dt) {
        double e = r - y;
        integral += e * dt;
        double u = Kp * e + Ki * integral;
        return u;
    }
};

int main() {
    double dt = 0.001;          // 1 ms control period
    double T  = 5.0;            // simulation horizon
    int N = static_cast<int>(T / dt);

    double y = 0.0;             // joint position
    double r = 1.0;             // unit step reference

    PIController pi(1.0, 4.0);  // gains as in the analytic design

    std::vector<double> e_hist;
    e_hist.reserve(N);

    for (int k = 0; k < N; ++k) {
        double t = k * dt;

        // For ramp tracking, replace r = 1.0 with r = t
        double u = pi.update(r, y, dt);

        // Plant integration: y_dot = -3 y + 5 u
        double y_dot = -3.0 * y + 5.0 * u;
        y += dt * y_dot;

        double e = r - y;
        e_hist.push_back(e);
    }

    std::cout << "Approximate steady-state error (last sample): "
              << e_hist.back() << std::endl;

    return 0;
}
      

This skeleton can be embedded in a ROS node or any real-time loop where the joint state is read from encoders and the control signal is written to motor drivers. The steady-state error can be inspected numerically to validate the analytic design.

Java is often used in educational robotics platforms (e.g. FRC robots). The following class structure represents a PI controller and a simple simulation loop, suitable for integration into a periodic control task.

public class PIController {
    private double Kp;
    private double Ki;
    private double integral;

    public PIController(double Kp, double Ki) {
        this.Kp = Kp;
        this.Ki = Ki;
        this.integral = 0.0;
    }

    public double update(double r, double y, double dt) {
        double e = r - y;
        integral += e * dt;
        return Kp * e + Ki * integral;
    }
}

public class JointSimulation {
    // y_dot = -3 y + 5 u
    private double y;

    public JointSimulation() {
        this.y = 0.0;
    }

    public void step(double u, double dt) {
        double yDot = -3.0 * y + 5.0 * u;
        y += dt * yDot;
    }

    public double getY() {
        return y;
    }

    public static void main(String[] args) {
        double dt = 0.001;
        double T  = 5.0;
        int N = (int) (T / dt);

        PIController controller = new PIController(1.0, 4.0);
        JointSimulation joint = new JointSimulation();

        double r = 1.0; // unit step

        for (int k = 0; k < N; ++k) {
            double u = controller.update(r, joint.getY(), dt);
            joint.step(u, dt);
        }

        double eFinal = r - joint.getY();
        System.out.println("Approximate steady-state error: " + eFinal);
    }
}
      

In a practical robot, the JointSimulation class would be replaced by actual hardware interaction through libraries such as WPILib or vendor-specific motor controller APIs, but the PI logic remains the same.

MATLAB and Simulink are standard tools for control analysis in robotics and mechatronics. The script below constructs the PI controller and plant, verifies static error constants, and suggests the structure of a Simulink model for more detailed experiments.

% Plant and PI controller
s = tf('s');
G = 5 / (s + 3);          % first-order plant
Kp = 1;
Ki = 4;
C = Kp + Ki / s;          % PI controller

L = C * G;
T = feedback(L, 1);       % closed-loop from r to y
S = 1 - T;                % sensitivity from r to e

% Static error constants
Kp_static = dcgain(L);      % position constant
Kv_static = dcgain(s * L);  % velocity constant

fprintf('Kp (static) = %g\n', Kp_static);
fprintf('Kv (static) = %g\n', Kv_static);
fprintf('Predicted ramp error (unit ramp) = %g\n', 1 / Kv_static);

% Step response (zero steady-state error)
figure;
step(T);
title('Step response with PI controller');

% Ramp response via lsim
t = 0:0.01:10;
r_ramp = t;   % unit-slope ramp
[y_ramp, t_out] = lsim(T, r_ramp, t);

figure;
plot(t_out, r_ramp, 'LineWidth', 1.5); hold on;
plot(t_out, y_ramp, 'LineWidth', 1.5);
grid on;
xlabel('Time (s)');
ylabel('Position');
legend('r(t) = ramp', 'y(t)');
title('Ramp tracking with PI controller');

% Simulink notes:
% A corresponding Simulink model uses:
%  - Sum block (r - y)
%  - Discrete or continuous PI controller block
%  - Transfer Fcn block for G(s)
%  - Scope blocks to view y(t) and e(t)
      

In the Robotics System Toolbox, similar transfer functions can be used to linearize joint dynamics about a configuration and then connect them to high-level motion planning blocks.

Mathematica provides symbolic and numeric tools for steady-state error analysis via TransferFunctionModel and related functions.

(* Define Laplace variable and models *)
s = LaplaceTransformVariable;
G = TransferFunctionModel[5/(s + 3), s];
Kp = 1;
Ki = 4;
C = TransferFunctionModel[(Kp*s + Ki)/s, s];

(* Loop transfer, closed loop, and error transfer *)
L = SystemsModelSeriesConnect[C, G];
T = SystemsModelFeedbackConnect[L, 1];  (* r to y *)
S = 1 - T;                              (* r to e *)

(* Static error constants via low-frequency gain *)
KpStatic = SystemsModelGain[L, 0];           (* position constant *)
KvStatic = SystemsModelGain[s*L, 0];         (* velocity constant *)

Print["Kp (static) = ", KpStatic];
Print["Kv (static) = ", KvStatic];
Print["Predicted ramp error = ", 1.0/KvStatic];

(* Numerical verification for ramp input *)
tmax = 10;
ramp[t_] := t;
resp = OutputResponse[T, ramp[t], {t, 0, tmax}];

Plot[{ramp[t], resp}, {t, 0, tmax},
     PlotLegends -> {"r(t) = ramp", "y(t)"},
     AxesLabel -> {"t", "position"},
     PlotLabel -> "Ramp tracking with PI controller"];
      

Symbolic tools can also be used to derive \( K_p \) and \( K_v \) directly from the transfer functions in terms of \( K_{\mathrm{p}} \) and \( K_{\mathrm{i}} \), enabling parameter studies.

Problem 1 (Gain Design for Bounded Step Error): A type 0 plant is given by \( G(s) = \frac{4}{(s + 1)(s + 4)} \) under unity feedback with proportional control \( C(s) = K \). Design the minimum value of \( K \) such that the steady-state error to a unit step satisfies \( e_{\mathrm{ss}}^{\text{step}} \leq 0.05 \).

Solution:

The loop transfer is

\[ L(s) = K G(s) = K \frac{4}{(s + 1)(s + 4)}. \]

For a type 0 system, the position constant is

\[ K_p = \lim_{s\to 0} L(s) = K \frac{4}{(1)(4)} = K. \]

Therefore

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

The specification \( e_{\mathrm{ss}}^{\text{step}} \leq 0.05 \) implies

\[ \frac{1}{1 + K} \leq 0.05 \quad\Longrightarrow\quad 1 + K \geq 20 \quad\Longrightarrow\quad K \geq 19. \]

Thus the minimum proportional gain satisfying the step error bound, neglecting transient constraints, is \( K = 19 \).

Problem 2 (Required Type for Ramp Tracking): For a robotic gantry axis, the specification requires zero steady-state error tracking of a constant-velocity profile \( r(t) = v_{0} t \) (ramp), and finite steady-state error for a parabolic profile. What is the minimum system type required?

Solution:

From the type table:

• Zero ramp error requires \( e_{\mathrm{ss}}^{\text{ramp}} = 0 \), which occurs for type at least 2.
• Finite parabolic error occurs at type 2 (since \( e_{\mathrm{ss}}^{\text{parabolic}} = 1/K_a \)).

Problem 3 (PI Design with Stability Check): For the plant \( G(s) = \frac{2}{s + 2} \), design a PI controller \( C(s) = K_{\mathrm{p}} + K_{\mathrm{i}}/s \) such that:

• The steady-state error for a unit step is zero.
• The steady-state error for a unit ramp satisfies \( e_{\mathrm{ss}}^{\text{ramp}} \leq 0.25 \).
• The closed-loop system is asymptotically stable.

Solution:

As the plant is type 0, PI control yields type 1, guaranteeing zero step error. The loop transfer is

\[ L(s) = C(s)G(s) = \frac{K_{\mathrm{p}} s + K_{\mathrm{i}}}{s} \frac{2}{s + 2} = \frac{2(K_{\mathrm{p}} s + K_{\mathrm{i}})}{s(s + 2)}. \]

The velocity constant is

\[ K_v = \lim_{s\to 0} sL(s) = \lim_{s\to 0} \frac{2(K_{\mathrm{p}} s + K_{\mathrm{i}})}{s + 2} = \frac{2K_{\mathrm{i}}}{2} = K_{\mathrm{i}}. \]

Therefore \( e_{\mathrm{ss}}^{\text{ramp}} = 1 / K_v = 1 / K_{\mathrm{i}} \). The requirement \( e_{\mathrm{ss}}^{\text{ramp}} \leq 0.25 \) implies

\[ \frac{1}{K_{\mathrm{i}}} \leq 0.25 \quad\Longrightarrow\quad K_{\mathrm{i}} \geq 4. \]

The characteristic equation \( 1 + L(s) = 0 \) yields

\[ s(s + 2) + 2(K_{\mathrm{p}} s + K_{\mathrm{i}}) = 0 \quad\Longrightarrow\quad s^{2} + (2 + 2K_{\mathrm{p}})s + 2K_{\mathrm{i}} = 0. \]

Asymptotic stability requires \( 2 + 2K_{\mathrm{p}} > 0 \) and \( 2K_{\mathrm{i}} > 0 \), so \( K_{\mathrm{p}} > -1 \) and \( K_{\mathrm{i}} > 0 \). Combining these with \( K_{\mathrm{i}} \geq 4 \), a simple design is \( K_{\mathrm{p}} = 1 \), \( K_{\mathrm{i}} = 4 \).

Problem 4 (Effect of Additional Integrator): A plant \( G(s) = \frac{1}{s^{2} + 2s + 1} \) has no integrators and is controlled by \( C(s) = K/s^{2} \). What is the type of the closed-loop system? Briefly discuss potential consequences for stability and steady-state error.

Solution:

The plant is type 0; the controller contributes two integrators, so the loop transfer function is type 2. Therefore:

• Zero steady-state error for both step and ramp inputs.
• Finite steady-state error for parabolic inputs.

However, introducing two integrators drastically reduces damping. The characteristic polynomial will be at least fourth order and can easily become unstable for moderate values of \( K \). Thus, although steady-state accuracy improves, robust stability typically worsens. Careful gain selection via Routh–Hurwitz or other methods is crucial.

Problem 5 (Design Workflow Sketch): Summarize a general workflow for designing a controller to achieve: (i) zero step error, (ii) bounded ramp error, and (iii) closed-loop stability for a given plant.

Solution (outline):

1. Determine plant type from \( G(s) \).
2. Increase type via integral action so that overall type satisfies the desired zero-error requirement (for example, type at least 1 for zero step error).
3. Translate ramp error bound into a constraint on \( K_v \) and hence on controller gains.
4. Derive the closed-loop characteristic polynomial and apply Routh–Hurwitz to ensure stability for the chosen gains.
5. Refine gains using transient performance criteria (settling time, overshoot) while maintaining the steady-state error constraints.

In this lesson we treated steady-state accuracy not only as an analysis concept but as an explicit design constraint. Using system type and static error constants \( K_p, K_v, K_a \), we derived algebraic conditions on loop integrators and low-frequency gain to synthesize controllers achieving zero or bounded steady-state error. Integral action was seen to be essential for eliminating bias and constant disturbances, especially in robotic joint servos, but it must be balanced against stability requirements derived from the closed-loop characteristic polynomial. These ideas prepare the ground for Chapter 9, where we will design for both transient and steady-state specifications using root-locus methods.