Consider a single-input single-output (SISO) feedback system with reference signal \( r(t) \), output \( y(t) \), control input \( u(t) \), and error \( e(t) = r(t) - y(t) \). Abstractly, the plant (physical process) implements an input-output operator

\[ y(t) = \mathcal{G}\{u(\cdot)\}(t), \]

while the controller computes \( u(t) \) from the error and possibly its history. For linear time-invariant (LTI) plants and controllers, the closed-loop system can be represented by linear differential equations. The main design goals are:

• Stability: bounded initial conditions and bounded inputs should not lead to unbounded outputs; trajectories should remain well-behaved over time.
• Accuracy: the error \( e(t) \) should be small in steady state, typically quantified by the steady-state error \( e_{\mathrm{ss}} = \lim_{t \to \infty} e(t) \) when this limit exists.
• Performance: the transient response should be fast and well-damped (short rise and settling times, limited overshoot), and the control effort \( u(t) \) should remain within actuator capabilities.

A conceptual view of the feedback loop and its objectives is:

flowchart TD
  R["Reference r(t)"] --> E["Error e(t) = r(t) - y(t)"]
  E --> C["Controller: computes u(t)"]
  C --> U["Control input u(t)"]
  U --> P["Physical plant (dynamics)"]
  P --> Y["Output y(t)"]
  Y --> E
        

In the rest of this lesson we give mathematically precise definitions of stability, accuracy, and performance for linear systems described by ordinary differential equations.

We start from a general nonlinear system

\[ \dot{x}(t) = f(x(t), t), \quad x(t) \in \mathbb{R}^n, \]

where \( x(t) \) is the state vector. An equilibrium point \( x_{\mathrm{eq}} \) satisfies \( f(x_{\mathrm{eq}}, t) = 0 \) for all \( t \). For simplicity in this lesson we mostly consider the equilibrium at the origin \( x_{\mathrm{eq}} = 0 \).

2.1 Lyapunov Stability and Asymptotic Stability

The classical Lyapunov definition of stability for the equilibrium \( x_{\mathrm{eq}} = 0 \) is:

\[ \text{The origin is (Lyapunov) stable if } \\ \forall \varepsilon > 0 \; \exists \delta > 0 \text{ such that } \|x(0)\| < \delta \Rightarrow \|x(t)\| < \varepsilon \text{ for all } t \ge 0. \]

Intuitively, small perturbations of the initial state remain small for all time. Asymptotic stability strengthens this:

\[ \text{The origin is asymptotically stable if it is stable and} \\ \lim_{t \to \infty} x(t) = 0 \quad \text{whenever } \|x(0)\| \text{ is sufficiently small.} \]

In control design, we almost always aim for asymptotic stability of the closed-loop equilibrium corresponding to correct tracking (e.g. \( y(t) \to r(t) \)).

2.2 Linear Time-Invariant Systems

A linear time-invariant (LTI) state-space model has the form

\[ \dot{x}(t) = A x(t) + B u(t), \quad y(t) = C x(t) + D u(t), \]

where \( A \in \mathbb{R}^{n \times n} \) and \( x(t) \in \mathbb{R}^n \). With zero input \( u(t) \equiv 0 \), the homogeneous dynamics are

\[ \dot{x}(t) = A x(t). \]

The solution (which you may know from linear ODE theory) is \( x(t) = e^{A t} x(0) \). Stability is then determined by the eigenvalues of \( A \), but a full treatment of this is postponed to later chapters. For the scalar case, the analysis is simple and illustrates the idea clearly.

2.3 Scalar Example

Consider the scalar LTI system

\[ \dot{x}(t) = a\,x(t), \quad a \in \mathbb{R}. \]

Solving this first-order linear ODE gives

\[ x(t) = e^{a t} x(0). \]

We can classify stability directly:

• If \( a < 0 \), then \( e^{a t} \to 0 \) as \( t \to \infty \) and the origin is asymptotically stable.
• If \( a > 0 \), then \( e^{a t} \to \infty \) as \( t \to \infty \) and the origin is unstable.
• If \( a = 0 \), then \( x(t) = x(0) \) (marginally stable in this simple case).

For more complex linear systems arising in control, we will later connect stability to eigenvalues of \( A \) and to pole locations in the complex plane.

In feedback control, the central accuracy measure is the error signal

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

where \( r(t) \) is the reference (desired output) and \( y(t) \) is the actual output.

3.1 Steady-State Error

Assuming the closed-loop system is asymptotically stable and all signals are bounded, the steady-state error for a given reference input is defined as

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

whenever this limit exists. For many tracking tasks we require \( e_{\mathrm{ss}} = 0 \) (perfect tracking), whereas for others it is enough that \( |e_{\mathrm{ss}}| \) be below a specified tolerance.

3.2 Example: First-Order Plant with Constant Input

Consider a scalar plant with state variable \( x(t) \) and output \( y(t) = x(t) \):

\[ \dot{x}(t) = -a\,x(t) + b\,u(t), \quad a > 0, \; b > 0. \]

Suppose we simply set \( u(t) = r \) for a constant reference \( r \) (no feedback yet). The equilibrium is obtained by solving \( \dot{x}(t) = 0 \):

\[ 0 = -a\,x_{\mathrm{eq}} + b\,r \quad \Rightarrow \quad x_{\mathrm{eq}} = \frac{b}{a}\,r. \]

The steady-state error is

\[ e_{\mathrm{ss}} = r - y_{\mathrm{eq}} = r - x_{\mathrm{eq}} = r - \frac{b}{a}r = \left(1 - \frac{b}{a}\right) r. \]

Unless \( b = a \), the error is nonzero. This motivates feedback: by letting \( u(t) \) depend on the error, we can improve both stability and accuracy.

Stability and steady-state accuracy are necessary but not sufficient. Two controllers can both be stable and achieve zero steady-state error, yet one may react very slowly or overshoot the desired value severely. We therefore quantify performance by several time-domain indicators.

4.1 Transient Response Measures

• Rise time: the time it takes for \( y(t) \) to move from a small percentage (e.g. 10%) to a large percentage (e.g. 90%) of its final value after a step change in \( r(t) \).
• Overshoot: the amount by which \( y(t) \) exceeds its final steady-state value, usually expressed as a percentage of that value.
• Settling time: the time after which \( y(t) \) remains within a specified band around its steady-state value (e.g. within 2%).

These quantities will be defined precisely in later chapters for standard first- and second-order systems. For now, it is enough to understand that a good controller should provide fast convergence with limited overshoot.

4.2 Control Effort

The control input \( u(t) \) must respect actuator limits and energy constraints. Two common ways to quantify control effort are:

• The peak magnitude \( \max_{t \ge 0} |u(t)| \).
• An energy measure such as \( \int_0^{\infty} u^2(t)\,\mathrm{d}t \).

High controller gains may improve steady-state accuracy and speed, but they also tend to increase control effort and can excite unmodeled dynamics. This leads to fundamental trade-offs illustrated next.

flowchart TD
  STAB["Stability (no divergence)"] --> ACC["Accuracy (small steady-state error)"]
  ACC --> PERF["Performance (fast, low overshoot)"]
  PERF --> U["Control effort and actuator limits"]
  U --> TRADE["Design trade-offs: choose gains to balance all goals"]
        

We now analyze a simple closed-loop system using a proportional controller. This example already exhibits the interaction between stability, accuracy, and performance.

5.1 Closed-Loop Model

Consider again the first-order plant

\[ \dot{x}(t) = -a\,x(t) + b\,u(t), \quad a > 0, \; b > 0, \quad y(t) = x(t). \]

We choose a proportional control law

\[ u(t) = k\bigl(r - y(t)\bigr) = k\bigl(r - x(t)\bigr), \quad k \in \mathbb{R}, \]

for a constant reference \( r \). Substituting into the plant equation, we obtain the closed-loop dynamics

\[ \dot{x}(t) = -a\,x(t) + b\,k\bigl(r - x(t)\bigr) = -(a + b k)\,x(t) + b k\,r. \]

5.2 Stability Condition

The closed-loop homogeneous dynamics (with \( r = 0 \)) are

\[ \dot{x}(t) = -(a + b k)\,x(t). \]

Comparing this with the scalar system in Section 2, we see that the origin is asymptotically stable if and only if

\[ a + b k > 0. \]

Thus, as long as we choose \( k > -a/b \), the closed-loop system is stable. In practice we select \( k \gt 0 \).

5.3 Steady-State Error

The equilibrium \( x_{\mathrm{eq}} \) for constant reference \( r \) satisfies

\[ 0 = -(a + b k)\,x_{\mathrm{eq}} + b k\,r \quad \Rightarrow \quad x_{\mathrm{eq}} = \frac{b k}{a + b k}\,r. \]

Since \( y(t) = x(t) \), the steady-state output is \( y_{\mathrm{eq}} = x_{\mathrm{eq}} \), and the steady-state error is

\[ e_{\mathrm{ss}} = r - y_{\mathrm{eq}} = r - \frac{b k}{a + b k}\,r = \frac{a}{a + b k}\,r. \]

As \( k \to \infty \), the steady-state error \( e_{\mathrm{ss}} \to 0 \). Thus, increasing the proportional gain improves accuracy (for this simple system), but at the cost of larger control effort.

5.4 Time Constant and Speed of Response

The closed-loop system behaves like a first-order stable system with effective coefficient \( a_{\mathrm{cl}} = a + b k \). The associated time constant \( \tau_{\mathrm{cl}} \) is

\[ \tau_{\mathrm{cl}} = \frac{1}{a + b k}. \]

A larger gain \( k \) makes \( \tau_{\mathrm{cl}} \) smaller (faster response), but also increases the magnitude of \( u(t) = k(r - x(t)) \). This is a concrete example of the trade-off among stability margin, accuracy, speed, and control effort that permeates linear control design.

We now simulate the closed-loop system from Section 5 with a simple numerical integration (explicit Euler). For a constant reference \( r \),

\[ \dot{x}(t) = -(a + b k)\,x(t) + b k\,r, \quad y(t) = x(t), \quad u(t) = k(r - x(t)). \]

We track: (i) stability (boundedness), (ii) steady-state error \( e_{\mathrm{ss}} \), and (iii) a simple measure of performance such as approximate settling time and the maximum control effort. Although the examples below are simple, the same ideas apply in robotic and mechatronic systems, where such code would be embedded in low-level controllers (often interfacing with robotics libraries or middleware such as ROS).

6.1 Python (NumPy) Example

import numpy as np

def simulate_first_order(a=1.0, b=1.0, k=5.0, r=1.0,
                         dt=0.001, t_final=5.0):
    """
    Simulate closed-loop system:
        dx/dt = -(a + b k) x + b k r
        y = x,  u = k (r - x)

    In robotics, similar logic would run in a low-level controller node
    (e.g. using ROS topics instead of printing to console).
    """
    n_steps = int(t_final / dt)
    x = 0.0
    t = np.linspace(0.0, t_final, n_steps)
    x_hist = np.zeros(n_steps)
    u_hist = np.zeros(n_steps)

    for i in range(n_steps):
        e = r - x
        u = k * e
        dx = -(a + b * k) * x + b * k * r
        x = x + dt * dx

        x_hist[i] = x
        u_hist[i] = u

    # Steady-state values (approximate)
    x_ss = x_hist[-1]
    e_ss = r - x_ss

    # Approximate 2% settling time
    tol = 0.02 * abs(x_ss) if x_ss != 0.0 else 0.02
    t_settle = t_final
    for i in range(n_steps):
        if np.all(np.abs(x_hist[i:] - x_ss) <= tol):
            t_settle = t[i]
            break

    print("Approx steady-state output y_ss =", x_ss)
    print("Approx steady-state error e_ss =", e_ss)
    print("Approx settling time (2%)     =", t_settle)
    print("Peak control effort max|u|    =", np.max(np.abs(u_hist)))

if __name__ == "__main__":
    simulate_first_order(a=1.0, b=1.0, k=5.0, r=1.0)
      

6.2 C++ Example (Console-Based Simulation)

#include <iostream>
#include <cmath>

// In a robotic system, this logic could be embedded in a real-time loop,
// possibly inside a ROS control node using roscpp.

int main() {
    double a = 1.0;
    double b = 1.0;
    double k = 5.0;
    double r = 1.0;

    double dt = 0.001;
    double t_final = 5.0;
    int n_steps = static_cast<int>(t_final / dt);

    double x = 0.0;
    double x_ss = 0.0;
    double max_u = 0.0;

    for (int i = 0; i < n_steps; ++i) {
        double e = r - x;
        double u = k * e;
        double dx = -(a + b * k) * x + b * k * r;
        x += dt * dx;

        if (std::fabs(u) > max_u) {
            max_u = std::fabs(u);
        }

        x_ss = x; // last value approximates steady-state
    }

    double e_ss = r - x_ss;
    std::cout << "Approx steady-state output y_ss = " << x_ss << std::endl;
    std::cout << "Approx steady-state error e_ss = " << e_ss << std::endl;
    std::cout << "Peak control effort max|u|    = " << max_u << std::endl;

    return 0;
}
      

6.3 Java Example

public class FirstOrderControlSim {

    // In robotics, similar logic could be integrated into a Java-based
    // middleware (e.g. rosjava) to control actuators.

    public static void main(String[] args) {
        double a = 1.0;
        double b = 1.0;
        double k = 5.0;
        double r = 1.0;

        double dt = 0.001;
        double tFinal = 5.0;
        int nSteps = (int) (tFinal / dt);

        double x = 0.0;
        double x_ss = 0.0;
        double maxU = 0.0;

        for (int i = 0; i < nSteps; i++) {
            double e = r - x;
            double u = k * e;
            double dx = -(a + b * k) * x + b * k * r;
            x += dt * dx;

            if (Math.abs(u) > maxU) {
                maxU = Math.abs(u);
            }

            x_ss = x;
        }

        double e_ss = r - x_ss;
        System.out.println("Approx steady-state output y_ss = " + x_ss);
        System.out.println("Approx steady-state error e_ss = " + e_ss);
        System.out.println("Peak control effort max|u|    = " + maxU);
    }
}
      

6.4 MATLAB / Simulink Example

% Parameters
a = 1.0;
b = 1.0;
k = 5.0;
r = 1.0;

dt = 0.001;
t_final = 5.0;
t = 0:dt:t_final;
n_steps = numel(t);

x = zeros(size(t));
u = zeros(size(t));

for i = 1:n_steps-1
    e = r - x(i);
    u(i) = k * e;
    dx = -(a + b * k) * x(i) + b * k * r;
    x(i+1) = x(i) + dt * dx;
end
u(end) = k * (r - x(end));

x_ss = x(end);
e_ss = r - x_ss;

fprintf("Approx steady-state output y_ss = %f\n", x_ss);
fprintf("Approx steady-state error e_ss = %f\n", e_ss);
fprintf("Peak control effort max|u|    = %f\n", max(abs(u)));

% In Simulink, the same closed loop can be built using a Sum block for e(t),
% a Gain block for k, another Sum block for plant dynamics, and an Integrator
% block for the state x(t). MATLAB's Robotics System Toolbox can later be
s% used to connect such controllers to robot models.
      

6.5 Wolfram Mathematica Example

(* Closed-loop parameters *)
a = 1.0;
b = 1.0;
k = 5.0;
r = 1.0;

(* Differential equation: x'(t) == -(a + b k) x(t) + b k r *)
eq = x'[t] == -(a + b k) x[t] + b k r;
ic = x[0] == 0.0;

sol = NDSolve[{eq, ic}, x, {t, 0, 5.0}][[1]];
xFun[t_] := x[t] /. sol;

xssApprox = xFun[5.0];
essApprox = r - xssApprox;

Print["Approx steady-state output y_ss = ", xssApprox];
Print["Approx steady-state error e_ss = ", essApprox];

(* In control and robotics applications, Mathematica's control systems
   functionality can be used to analyze more complex multi-variable systems. *)
      

In this lesson we formalized the three central goals of linear control: stability, steady-state accuracy, and transient performance. Using basic ODE theory, we introduced Lyapunov stability for equilibrium points, and illustrated how, even in a simple first-order system with proportional feedback, the controller gain simultaneously affects stability margins, steady-state error, speed of response, and control effort. These concepts provide the conceptual backbone for all later chapters, where more sophisticated analysis tools (transfer functions, pole locations, frequency response) will be developed to design controllers that achieve these goals in more complex systems.