Consider a unity-feedback control system with controller transfer function \( G_c(s) \) and plant transfer function \( G_p(s) \). The open-loop transfer function is \( L(s) = G_c(s)G_p(s) \). For a reference input \( r(t) \) and output \( y(t) \), the error signal is \( e(t) = r(t) - y(t) \), with Laplace transforms \( E(s), R(s), Y(s) \).

In a unity-feedback loop, basic block-diagram algebra gives

\[ \begin{aligned} Y(s) &= G_c(s)G_p(s)E(s) = L(s)E(s), \\ E(s) &= R(s) - Y(s) = R(s) - L(s)E(s) \\ &\Rightarrow (1 + L(s))E(s) = R(s) \\ &\Rightarrow \frac{E(s)}{R(s)} = \frac{1}{1 + L(s)}. \end{aligned} \]

The steady-state error (if it exists) is defined as

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

using the Final Value Theorem (studied earlier in the course).

In Chapter 8, we defined the static error constants for unity feedback:

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

and we showed that for a type 0 system (no factor \( 1/s \) in \( L(s) \)), the step steady-state error is

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

which is nonzero (finite) for finite \( K_p \). Proportional control alone can reduce but not completely eliminate steady-state error. The main motivation for integral action is to drive \( e_{\text{ss}} \) to zero for standard inputs such as step signals and constant disturbances.

flowchart TD
  R["Reference r(t)"] --> SUM["Error e(t) = r(t) - y(t)"]
  Y["Output y(t)"] --> SUM
  SUM --> PCTRL["Proportional control only"]
  PCTRL --> PLANT["Plant G_p(s)"]
  PLANT --> Y
  Y --> ESS["Nonzero steady-state error for step"]
  ESS --> MOTIV["Add integral action to remove steady-state error"]
        

A pure integral controller generates the control input \( u(t) \) as

\[ u(t) = K_i \int_0^t e(\tau)\, d\tau, \]

where \( K_i > 0 \) is the integral gain. Taking Laplace transforms (assuming zero initial integral state),

\[ U(s) = \frac{K_i}{s} E(s), \]

so the controller transfer function is

\[ G_c(s) = \frac{U(s)}{E(s)} = \frac{K_i}{s}. \]

For a plant \( G_p(s) \), the open-loop transfer function becomes

\[ L(s) = G_c(s)G_p(s) = \frac{K_i}{s}G_p(s). \]

Compared to proportional control, the integrator introduces an additional factor \( 1/s \) in the loop, which increases the system type by one. Intuitively, the integral term accumulates error over time; any persistent error causes the integral state to grow, adjusting the control signal until the steady-state error is driven to zero (if internal stability is preserved).

Suppose the original open-loop transfer function (with proportional control or no controller) is \( L_0(s) = G_{c0}(s)G_p(s) \). Assume that near the origin, \( L_0(s) \) behaves like

\[ L_0(s) \approx \frac{K_0}{s^n}, \quad n \ge 0, \]

where \( n \) is the system type (number of pure integrators in the open loop). Adding integral control modifies the loop to

\[ L(s) = \frac{K_i}{s} L_0(s) \approx \frac{K_i K_0}{s^{n+1}}, \]

so the type increases from \( n \) to \( n+1 \).

3.1 Steady-state error to a step input

For a unit-step input, \( r(t) = 1(t) \), we have \( R(s) = 1/s \). Then

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

If \( L(s) \) tends to a finite constant \( K_p \) as \( s \rightarrow 0 \) (type 0), then

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

If \( L(s) \) tends to infinity as \( s \rightarrow 0 \) (type \( \ge 1 \)), then

\[ \lim_{s \rightarrow 0} L(s) = \infty \quad \Rightarrow \quad e_{\text{ss}}^{\text{step}} = \lim_{s \rightarrow 0} \frac{1}{1 + L(s)} = 0. \]

Therefore, any internally stable unity-feedback system with at least one integrator in the open loop (type \( \ge 1 \)) has zero steady-state error to a step input. Adding integral action to a type 0 plant yields a type 1 loop, hence zero steady-state error to step references.

3.2 Steady-state error to a ramp input

For a unit ramp input \( r(t) = t \cdot 1(t) \), we have \( R(s) = 1/s^2 \). Then

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

For a type 0 system, \( L(s) \) is finite near \( s = 0 \), so \( e_{\text{ss}}^{\text{ramp}} = \infty \). For a type 1 system, \( L(s) \approx K_v/s \) as \( s \rightarrow 0 \), and we obtain

\[ e_{\text{ss}}^{\text{ramp}} = \lim_{s \rightarrow 0} \frac{1}{s + K_v} = \frac{1}{K_v}, \quad K_v = \lim_{s \rightarrow 0} sL(s). \]

Thus, adding integral action to a type 0 system not only eliminates step error (making it type 1), but also converts an infinite ramp error into a finite one.

flowchart TD
  A["Start: plant G_p(s), type n"] --> B["Form open loop L_0(s) = G_c0(s) G_p(s)"]
  B --> C["Add integrator: G_c(s) = Ki / s"]
  C --> D["New loop L(s) = (Ki / s) L_0(s)"]
  D --> E["System type becomes n + 1"]
  E --> F["Step ess becomes 0 if closed loop is stable"]
        

Integral action also eliminates steady-state error due to constant disturbances. Consider a unity-feedback loop where a constant disturbance \( d(t) = d_0 \) is added at the plant input. Let the plant be \( G_p(s) \), and the controller have an integrator so that the loop is type 1 (or higher).

A classical way to see disturbance rejection is to write the output as

\[ Y(s) = \frac{L(s)}{1 + L(s)} R(s) + \frac{G_p(s)}{1 + L(s)} D(s), \]

where \( D(s) \) is the Laplace transform of the disturbance. With a constant disturbance \( d(t) = d_0 \), we have \( D(s) = d_0/s \). Suppose the reference is constant (\( R(s) = 1/s \)) and we are interested in the error \( e(t) = r(t) - y(t) \). Using previous relationships,

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

The steady-state error is then

\[ e_{\text{ss}} = \lim_{s \rightarrow 0} sE(s) = \lim_{s \rightarrow 0} \left[ \frac{sR(s)}{1 + L(s)} - \frac{sG_p(s)}{1 + L(s)} D(s) \right]. \]

For constant reference and constant disturbance, both terms have the form \( s \times (\text{constant}/s)/(1 + L(s)) \). If the loop is type 1 or higher, \( L(s) \rightarrow \infty \) as \( s \rightarrow 0 \), and both contributions vanish:

\[ e_{\text{ss}} = 0. \]

This shows that a properly tuned integral controller can cancel steady-state effects of constant disturbances such as constant torque loads on a robot joint, or constant bias forces in a positioning system.

In practice, pure integral control is rarely used alone because it tends to produce slow responses and can destabilize the system. A more common structure is the proportional-integral (PI) controller:

\[ u(t) = K_p e(t) + K_i \int_0^t e(\tau)\, d\tau. \]

The corresponding transfer function is

\[ G_c(s) = K_p + \frac{K_i}{s} = K_p \left(1 + \frac{1}{T_i s}\right), \quad T_i = \frac{K_p}{K_i} \]

where \( T_i \) is the integral time constant.

5.1 Closed-loop characteristic equation for a first-order plant

Consider a first-order plant

\[ G_p(s) = \frac{K}{\tau s + 1}, \]

where \( K > 0 \) is the DC gain and \( \tau > 0 \) is the plant time constant. The open-loop transfer function with a PI controller is

\[ L(s) = G_c(s)G_p(s) = \left(K_p + \frac{K_i}{s}\right)\frac{K}{\tau s + 1} = \frac{K(K_p s + K_i)}{s(\tau s + 1)}. \]

The closed-loop transfer function for unity feedback is

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

The characteristic equation is the denominator of \( T(s) \),

\[ 1 + L(s) = 0 \quad \Rightarrow \quad s(\tau s + 1) + K(K_p s + K_i) = 0. \]

Expanding:

\[ s(\tau s + 1) + K K_p s + K K_i = \tau s^2 + s + K K_p s + K K_i = \tau s^2 + (1 + K K_p)s + K K_i = 0. \]

Thus, the closed-loop characteristic polynomial is

\[ \tau s^2 + (1 + K K_p)s + K K_i. \]

5.2 Matching to a desired second-order prototype

From Chapter 6, a standard second-order prototype has characteristic polynomial

\[ s^2 + 2\zeta \omega_n s + \omega_n^2 = 0, \]

with damping ratio \( \zeta \) and natural frequency \( \omega_n \). To approximately obtain such behavior, we can match coefficients (after scaling by \( \tau \)):

\[ \tau s^2 + (1 + K K_p)s + K K_i \approx \tau \left( s^2 + 2\zeta \omega_n s + \omega_n^2 \right). \]

Matching coefficients gives

\[ \begin{aligned} 1 + K K_p &= 2 \zeta \omega_n \tau, \\ K K_i &= \tau \omega_n^2. \end{aligned} \]

Therefore, for given \( \zeta \), \( \omega_n \), and known \( K, \tau \), we can select

\[ K_p = \frac{2 \zeta \omega_n \tau - 1}{K}, \quad K_i = \frac{\tau \omega_n^2}{K}. \]

This design ensures:

• Zero steady-state error to a step input (due to integral action),
• Approximate second-order transient behavior with specified \( \zeta \) and \( \omega_n \).

In robotics, Python is frequently used together with ROS (Robot Operating System) and control libraries. A common stack includes:

• control (Python Control Systems Library) for transfer-function analysis,
• simple-pid for straightforward PID loops in software,
• ROS topics/services to connect sensors and actuators.

Below we design a PI controller for a first-order actuator model \( G_p(s) = \frac{K}{\tau s + 1} \) and verify numerically that the step steady-state error is approximately zero.

import numpy as np
import matplotlib.pyplot as plt

# Optional: Python Control Systems Library (install via: pip install control)
import control as ctl

# Plant parameters (e.g., simplified DC motor velocity loop)
K = 1.0      # DC gain
tau = 0.5    # time constant [s]

# Desired closed-loop specs (approximate)
zeta = 0.7
omega_n = 3.0

# PI gains from Section 5 formulas
Kp = (2.0 * zeta * omega_n * tau - 1.0) / K
Ki = (tau * omega_n**2) / K

print("Designed gains: Kp =", Kp, ", Ki =", Ki)

# Continuous-time transfer functions
s = ctl.TransferFunction.s
G_p = K / (tau * s + 1)
G_c = Kp + Ki / s    # PI controller

L = G_c * G_p        # open loop
T = ctl.feedback(L, 1)  # closed loop (unity feedback)

# Step response
t = np.linspace(0, 5, 1000)
t, y = ctl.step_response(T, T=t)

e = 1.0 - y          # error to unit step
e_ss = e[-1]
print("Approx steady-state error (step):", e_ss)

plt.figure()
plt.plot(t, y, label="y(t)")
plt.plot(t, np.ones_like(t), "--", label="reference")
plt.xlabel("Time [s]")
plt.ylabel("Output")
plt.title("PI-controlled first-order plant")
plt.legend()
plt.grid(True)
plt.show()
      

In a robotic application (e.g., wheel velocity control), the same PI logic would run at a fixed sample rate in a ROS node, reading encoder feedback, computing the integral of velocity error, and sending PWM or current commands to a motor driver.

In embedded and robotic systems, PI control is often implemented in C++ inside a real-time loop. Popular libraries/frameworks include:

• ros_control for ROS-based joint controllers,
• Eigen for linear algebra,
• vendor-specific motor control SDKs.

Below is a minimal discrete-time PI controller for a first-order plant model, using forward Euler integration for the plant state and integral of the error. This can be adapted into a ROS control loop with appropriate sensor and actuator interfaces.

#include <iostream>
#include <vector>

int main() {
    // Plant: x_dot = -(1/tau) * x + (K/tau) * u
    double K = 1.0;
    double tau = 0.5;

    // PI gains (for example, from analytic design)
    double Kp = 1.1;
    double Ki = 3.0;

    double dt = 0.001;      // sampling period [s]
    int    N  = 5000;       // number of steps (5 s)

    double x = 0.0;         // plant state (output y = x)
    double integral_e = 0.0;
    double r = 1.0;         // reference (step)
    double u = 0.0;         // control input

    std::vector<double> t_vec, y_vec, e_vec;

    for (int k = 0; k < N; ++k) {
        double t = k * dt;
        double y = x;
        double e = r - y;

        // PI controller
        integral_e += e * dt;
        u = Kp * e + Ki * integral_e;

        // Plant integration (forward Euler)
        double x_dot = -(1.0 / tau) * x + (K / tau) * u;
        x += x_dot * dt;

        t_vec.push_back(t);
        y_vec.push_back(y);
        e_vec.push_back(e);
    }

    std::cout << "Final output y(T) = " << y_vec.back() << std::endl;
    std::cout << "Final error e(T)  = " << e_vec.back() << std::endl;
    return 0;
}
      

In a robot joint controller, the same core logic is executed at each sampling instant, with y measured from joint encoders and u sent to the motor driver. The integral term must be carefully limited to avoid windup when actuators saturate (anti-windup strategies are addressed in a later chapter).

Java is sometimes used in control contexts (e.g., industrial HMIs, high-level control layers). Numerical integration and PI logic can be implemented using standard Java constructs or with libraries such as Apache Commons Math for ODE integration.

The following example simulates a discrete PI controller acting on a first-order plant model.

public class PiControlDemo {
    public static void main(String[] args) {
        double K = 1.0;
        double tau = 0.5;

        double Kp = 1.1;
        double Ki = 3.0;

        double dt = 0.001;
        int N = 5000;

        double x = 0.0;  // plant state
        double integralE = 0.0;
        double r = 1.0;  // step reference

        double y = 0.0;
        double e = 0.0;
        double u = 0.0;

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

            y = x;
            e = r - y;

            integralE += e * dt;
            u = Kp * e + Ki * integralE;

            double xDot = -(1.0 / tau) * x + (K / tau) * u;
            x += xDot * dt;

            if (k % 500 == 0) {
                System.out.printf("t = %.3f, y = %.3f, e = %.3f%n", t, y, e);
            }
        }

        System.out.printf("Final output y(T) = %.4f%n", y);
        System.out.printf("Final error e(T)  = %.4f%n", e);
    }
}
      

Java-based robotic frameworks (such as those used in some industrial robot APIs) embed the same PI logic inside their servo-cycle implementations.

MATLAB and Simulink are standard tools in control engineering and robotics. MATLAB provides analytic tools for transfer-function design, while Simulink allows block-diagram simulation of controllers and plants.

9.1 MATLAB script

% Plant
K = 1.0;
tau = 0.5;
s = tf('s');
G_p = K / (tau * s + 1);

% Desired dynamics
zeta = 0.7;
omega_n = 3.0;

% PI gains
Kp = (2 * zeta * omega_n * tau - 1) / K;
Ki = (tau * omega_n^2) / K;

fprintf('Kp = %.3f, Ki = %.3f\n', Kp, Ki);

G_c = Kp + Ki / s;      % PI controller
T   = feedback(G_c * G_p, 1);  % closed loop

figure;
step(T);
grid on;
title('PI-controlled first-order plant');
      

9.2 Simulink model

A typical Simulink implementation uses:

• A Sum block to compute e(t) = r(t) - y(t),
• An Integrator block or a PID Controller block configured in PI mode (P and I gains set to Kp and Ki),
• A block representing the plant G_p(s) (e.g., via Transfer Fcn),
• Scopes to observe y(t), e(t), and u(t).

For robotic actuators, the Simulink model can be deployed to real-time targets using Simulink Real-Time or similar frameworks.

Wolfram Mathematica offers symbolic and numeric tools for control system analysis via Control` functionality. Below is a simple PI design and step-response simulation for the same first-order plant.

(* Parameters *)
K = 1.0;
tau = 0.5;
zeta = 0.7;
omegaN = 3.0;

(* PI gains *)
Kp = (2 zeta omegaN tau - 1)/K;
Ki = (tau omegaN^2)/K;

s = LaplaceTransformVariable["s"];

plant = TransferFunctionModel[ K/(tau s + 1), s];
controller = TransferFunctionModel[ Kp + Ki/s, s];

loop = SystemsModelSeries[controller, plant];
closedLoop = SystemsModelFeedback[loop];

{t, y} = Transpose @ OutputResponse[closedLoop, UnitStep[t], {t, 0, 5}];

ListLinePlot[
  {Transpose[{t, y}], Transpose[{t, ConstantArray[1, Length[t]]}]},
  PlotLegends -> {"y(t)", "reference"},
  AxesLabel -> {"t", "y"},
  PlotLabel -> "PI-controlled first-order plant"
]
      

Mathematica can also perform symbolic derivations of steady-state error by manipulating transfer functions symbolically and applying the Final Value Theorem.

Problem 1 (Type change by integral action):

Consider a unity-feedback system with open-loop transfer function \( L_0(s) = \dfrac{K}{\tau s + 1} \), where \( K > 0 \) and \( \tau > 0 \). The system is controlled only by proportional gain \( K \).

1. Determine the system type and the steady-state error to a unit-step input.
2. Now add pure integral control with gain \( K_i \), i.e. \( G_c(s) = K_i/s \). Determine the new system type and the step steady-state error (assume closed-loop stability).

Solution:

(1) The open-loop transfer function is

\[ L_0(s) = \frac{K}{\tau s + 1}. \]

Near \( s = 0 \), we have \( L_0(0) = K \), so there is no integrator term. The system is type 0. The step steady-state error is

\[ e_{\text{ss}}^{\text{step}} = \frac{1}{1 + K_p}, \quad K_p = \lim_{s \rightarrow 0} L_0(s) = K, \]

hence \( e_{\text{ss}}^{\text{step}} = 1/(1 + K) \).

(2) With integral control, the open-loop transfer function becomes

\[ L(s) = G_c(s)G_p(s) = \frac{K_i}{s} \frac{K}{\tau s + 1} = \frac{K K_i}{s(\tau s + 1)}. \]

There is now one factor \( 1/s \) in the loop, so the system is type 1. For a unit step,

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

Since \( L(s) \sim (K K_i)/(s) \) as \( s \rightarrow 0 \), we have \( L(s) \rightarrow \infty \) and thus \( e_{\text{ss}}^{\text{step}} = 0 \).

Problem 2 (PI design for specified second-order behavior):

For the plant \( G_p(s) = \dfrac{2}{s + 2} \), design a PI controller \( G_c(s) = K_p + K_i/s \) such that the closed-loop characteristic polynomial is equivalent to \( s^2 + 4s + 4 \) (which corresponds to \( \zeta = 1 \), \( \omega_n = 2 \)).

Solution:

Here \( K = 2 \) and \( \tau = 1/2 \), since \( G_p(s) = 2/(s + 2) = 2/((1/0.5)s + 1) \). The general closed-loop characteristic polynomial with PI is (from Section 5)

\[ \tau s^2 + (1 + K K_p)s + K K_i. \]

Substituting \( \tau = 1/2 \), \( K = 2 \) gives

\[ \frac{1}{2} s^2 + (1 + 2K_p)s + 2K_i. \]

Multiplying by 2 to match \( s^2 + 4s + 4 \):

\[ s^2 + 2(1 + 2K_p)s + 4K_i \equiv s^2 + 4s + 4. \]

Equating coefficients:

\[ 2(1 + 2K_p) = 4 \quad \Rightarrow \quad 1 + 2K_p = 2 \quad \Rightarrow \quad K_p = \frac{1}{2}. \]

\[ 4K_i = 4 \quad \Rightarrow \quad K_i = 1. \]

Thus, a PI controller with \( K_p = 0.5 \) and \( K_i = 1 \) yields the desired characteristic polynomial.

Problem 3 (Ramp error with and without integral action):

A unity-feedback system has plant \( G_p(s) = \dfrac{1}{s(s + 3)} \) and proportional controller \( G_c(s) = K_p \).

1. Determine the system type and the steady-state error to a unit ramp input.
2. Suppose we instead use \( G_c(s) = K_i/s \) (pure integral control). Determine the new system type and the steady-state error to a unit ramp input (assuming stability).

Solution:

(1) With proportional control, the open-loop is

\[ L_0(s) = K_p \frac{1}{s(s + 3)}. \]

There is one factor \( 1/s \) in the plant already, so the loop is type 1. For a type 1 system, the ramp steady-state error is finite and given by \( e_{\text{ss}}^{\text{ramp}} = 1/K_v \), where

\[ K_v = \lim_{s \rightarrow 0} s L_0(s) = \lim_{s \rightarrow 0} s \frac{K_p}{s(s + 3)} = \frac{K_p}{3}. \]

Hence,

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

(2) With pure integral control,

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

The loop now has two integrators, so it is type 2. For a type 2 system, the ramp error is zero (and the parabolic error is finite, if the system is stable). More formally,

\[ K_v = \lim_{s \rightarrow 0} s L(s) = \lim_{s \rightarrow 0} s \frac{K_i}{s^2(s + 3)} = \infty, \]

so \( e_{\text{ss}}^{\text{ramp}} = 1/K_v = 0 \). Thus, adding integral action increases the type from 1 to 2 and eliminates ramp error.

Problem 4 (Integral action and constant disturbance):

Consider the unity-feedback system with plant \( G_p(s) = \dfrac{1}{\tau s + 1} \) and PI controller \( G_c(s) = K_p + K_i/s \). A constant disturbance \( d(t) = d_0 \) is added at the plant input, and the reference is a unit step.

1. Derive the expression for \( E(s) \) in terms of \( R(s) \) and \( D(s) \).
2. Show that \( e_{\text{ss}} = 0 \) if the closed-loop system is stable.

Solution:

(1) The output is

\[ Y(s) = \frac{L(s)}{1 + L(s)} R(s) + \frac{G_p(s)}{1 + L(s)} D(s) \]

and the error is \( E(s) = R(s) - Y(s) \), so

\[ \begin{aligned} E(s) &= R(s) - \frac{L(s)}{1 + L(s)} R(s) - \frac{G_p(s)}{1 + L(s)} D(s) \\ &= \frac{R(s)}{1 + L(s)} - \frac{G_p(s)}{1 + L(s)} D(s). \end{aligned} \]

(2) For a step reference and constant disturbance, we have \( R(s) = 1/s \), \( D(s) = d_0/s \). Then

\[ e_{\text{ss}} = \lim_{s \rightarrow 0} sE(s) = \lim_{s \rightarrow 0} \left[ \frac{s R(s)}{1 + L(s)} - \frac{s G_p(s)}{1 + L(s)} D(s) \right]. \]

Each term is of the form \( \dfrac{\text{constant}}{1 + L(s)} \) as \( s \rightarrow 0 \). Because the PI controller includes an integrator, \( L(s) \rightarrow \infty \) as \( s \rightarrow 0 \), so the denominator tends to infinity and both terms vanish. Thus

\[ e_{\text{ss}} = 0. \]

• Integral control implements \( u(t) = K_i \int_0^t e(\tau)\, d\tau \), corresponding to a controller transfer function \( G_c(s) = K_i/s \).
• Adding integral action increases the system type by one, which guarantees zero steady-state error to a step input (and finite or zero error to higher-order inputs) under closed-loop stability.
• Integral action also eliminates steady-state error due to constant disturbances in unity feedback systems.
• PI control (\( K_p + K_i/s \)) combines proportional and integral actions, enabling both transient shaping (via \( K_p \)) and zero steady-state error (via \( K_i \)).
• For first-order plants, PI gains can be selected by matching the closed-loop characteristic polynomial to a desired second-order prototype.
• Integral and PI control can be implemented straightforwardly in Python, C++, Java, MATLAB/Simulink, and Mathematica, and are widely used in robotic actuators for accurate tracking and disturbance rejection.