A feedback control system continuously compares the desired output with the measured output and acts to reduce the difference. In a standard single-input, single-output (SISO) configuration, the main elements and signals are:

• \( r(t) \): reference or setpoint (desired output trajectory).
• \( y(t) \): actual output of the physical plant.
• \( y_m(t) \): measured output provided by the sensor.
• \( e(t) \): error signal, difference between reference and measured output.
• \( u_c(t) \): controller output (command to actuator).
• \( u(t) \): actuator output (physical input to the plant).
• \( d(t) \): external disturbance acting on the plant.
• \( n(t) \): measurement noise in the sensor.

These signals form the backbone of any feedback loop. For linear systems, we model the plant, actuator, controller, and sensor as linear operators that map input signals to output signals. This operator viewpoint allows us to derive closed-loop equations without yet relying on Laplace transforms.

flowchart TD
  R["Reference r(t)"] --> E["Error e(t) = r(t) - y_m(t)"]
  E --> C["Controller"]
  C --> A["Actuator"]
  A --> P["Plant"]
  P --> Y["Output y(t)"]
  Y --> S["Sensor"]
  S --> YM["Measured output y_m(t)"]
  YM --> E
  D["Disturbance d(t)"] --> P
  N["Measurement noise n(t)"] --> S
        

In robotic systems, for example, \( y(t) \) might be the position of a robot joint, \( r(t) \) a desired trajectory, the actuator is a motor drive, and the sensor is an encoder. The same conceptual structure applies to many physical domains (mechanical, electrical, thermal, etc.).

We begin with the basic algebraic relations between signals, independent of any particular differential equation model. For a standard negative feedback loop:

\[ e(t) = r(t) - y_m(t) \]

\[ y_m(t) = S\bigl[y(t)\bigr] + n(t) \]

Here, \( S \) denotes the sensor mapping from the true output \( y(t) \) to a measured quantity. For a linear sensor with gain \( k_s \):

\[ y_m(t) = k_s\,y(t) + n(t). \]

The controller maps the error signal into a command:

\[ u_c(t) = C\bigl[e(t)\bigr], \]

and the actuator converts this command into a physical actuation:

\[ u(t) = A\bigl[u_c(t)\bigr]. \]

Finally, the physical plant acts on the actuator input and disturbances:

\[ y(t) = P\bigl[u(t), d(t)\bigr], \]

where \( P \) is a (possibly multi-input) operator representing the plant dynamics.

Under the assumption of linearity and time invariance (to be formalized in later chapters), we can regard \( C, A, P, S \) as linear operators on spaces of signals such as \( \mathcal{C}^1([0,\infty),\mathbb{R}) \). For example, if \( C \) is a proportional controller with gain \( K \), then

\[ C\bigl[e(t)\bigr] = K\,e(t). \]

Collecting these relations for the disturbance-free case \( d(t)=0, n(t)=0 \), we obtain

\[ y(t) = P\!\left(A\!\left(C\bigl[r(t) - S[y(t)]\bigr]\right)\right). \]

This nonlinear-looking expression is actually linear in the operators \( P, A, C, S \) when they are linear maps. Later, this will correspond to the familiar algebra of transfer functions and block diagrams.

A linear time-invariant (LTI) plant can be represented by an ordinary differential equation (ODE) of the form

\[ a_n\,y^{(n)}(t) + a_{n-1}\,y^{(n-1)}(t) + \cdots + a_1\,\dot{y}(t) + a_0\,y(t) = \\ b_m\,u^{(m)}(t) + b_{m-1}\,u^{(m-1)}(t) + \cdots + b_0\,u(t) + d(t), \]

where \( a_i, b_j \in \mathbb{R} \) and the coefficients are constant. This expresses the plant as a linear combination of derivatives of \( y(t) \) equal to a linear combination of derivatives of \( u(t) \) plus disturbances.

A sensor may also have dynamics. For instance, a first-order sensor with gain \( k_s \) and time constant \( T_s > 0 \) can be modeled as

\[ T_s\,\dot{y}_m(t) + y_m(t) = k_s\,y(t) + n(t). \]

An actuator, such as a DC motor drive, might have its own first-order dynamics:

\[ T_a\,\dot{u}(t) + u(t) = k_a\,u_c(t), \]

with actuator time constant \( T_a > 0 \) and gain \( k_a \).

Putting these together, the overall closed-loop system is described by a coupled set of ODEs for \( y(t), y_m(t), u(t) \). Even for a simple robot joint, the combined model involves mechanical dynamics (plant), drive dynamics (actuator), sensor dynamics, and the control law, all interacting through feedback.

Consider a simple unity-feedback system without actuator or sensor dynamics:

• Plant: first-order stable dynamics

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

• Sensor: ideal, \( y_m(t) = y(t) \) and \( n(t) = 0 \).
• Controller: proportional, \( u(t) = K\bigl(r(t) - y(t)\bigr) \).

Substituting the control law into the plant equation (and setting \( d(t)=0 \)) gives

\[ \dot{y}(t) = -a\,y(t) + b\,K\bigl(r(t) - y(t)\bigr) = -(a + bK)\,y(t) + bK\,r(t). \]

This is a first-order linear ODE with input \( r(t) \). For a constant reference \( r(t) = r_0 \), the solution is

\[ y(t) = y(0)\,e^{-(a + bK)t} + \frac{bK}{a + bK}\,r_0\bigl(1 - e^{-(a + bK)t}\bigr). \]

The exponential term shows that the closed-loop response decays with time constant \( 1/(a + bK) \). Increasing \( K \) makes the response faster (smaller time constant), but also changes the steady-state value \( \frac{bK}{a + bK}r_0 \). Systematic analysis of such trade-offs appears in later chapters on performance and steady-state error.

From this example, we see how even a simple controller alters the effective dynamics of the plant. This is the essence of feedback: the controller reshapes the differential equation governing \( y(t) \).

When feedback control is implemented in software (e.g., on a robot microcontroller), the continuous-time feedback loop is approximated in discrete time. At each sampling instant, the following steps occur:

1. Read sensor measurements \( y_m[k] \).
2. Compute error \( e[k] = r[k] - y_m[k] \).
3. Compute controller output \( u_c[k] \) from \( e[k] \).
4. Send actuation command to the actuator.
5. Observe the plant evolution until the next sampling instant.

flowchart TD
  K0["Start sample k"] --> SAMP["Read y_m[k] from sensor"]
  SAMP --> ERR["Compute e[k] = r[k] - y_m[k]"]
  ERR --> CTRL["Compute u_c[k] from e[k]"]
  CTRL --> ACT["Send u_c[k] to actuator"]
  ACT --> WAIT["Wait until next sample"]
  WAIT --> K1["Proceed to sample k+1"]
        

This algorithmic interpretation is central to digital control and robotic applications. The underlying mathematics of Section 4 still applies, but is approximated through numerical integration and discrete-time updates.

We simulate the first-order plant with proportional feedback introduced in Section 4 for a constant reference \( r(t) = r_0 \). We discretize the dynamics by a simple Euler method. In robotics, similar code can be embedded in low-level controllers; more advanced libraries such as python-control and roboticstoolbox-python build on these principles.

import numpy as np
import matplotlib.pyplot as plt

# Plant parameters (e.g., robot joint position dynamics)
a = 1.0   # intrinsic damping coefficient
b = 1.0   # control effectiveness
K = 4.0   # proportional gain
r0 = 1.0  # desired position (setpoint)

# Simulation settings
dt = 0.001   # time step [s]
T  = 3.0     # total simulation time [s]
N  = int(T / dt)

t = np.linspace(0.0, T, N + 1)
y = np.zeros(N + 1)  # plant output (position)
r = r0 * np.ones(N + 1)  # constant reference

for k in range(N):
    # Measured output (ideal sensor)
    y_m = y[k]
    # Error
    e = r[k] - y_m
    # Proportional controller
    u = K * e
    # Plant dynamics: y_dot = -a y + b u
    y_dot = -a * y[k] + b * u
    # Euler integration
    y[k + 1] = y[k] + dt * y_dot

plt.figure()
plt.plot(t, r, linestyle="--", label="reference r(t)")
plt.plot(t, y, label="output y(t)")
plt.xlabel("time [s]")
plt.ylabel("signal")
plt.legend()
plt.title("First-order plant with proportional feedback")
plt.show()

# Note:
# In robotics applications, you might replace this simple model
# with a more detailed joint model and use robotics libraries like:
#   - python-control (for LTI analysis)
#   - roboticstoolbox-python (for multi-joint kinematics/dynamics)
      

This script demonstrates how the mathematical model \( \dot{y}(t) = -(a + bK)y(t) + bK r_0 \) is realized numerically. Changing \( K \) directly affects the speed of convergence of \( y(t) \) to \( r_0 \).

In embedded robotics, C++ is widely used (for example in ROS controllers). The following minimal example simulates the same first-order feedback loop. In a realistic setting, the plant model would represent a robot joint or wheel, and the loop would run in a real-time thread.

#include <iostream>
#include <vector>

struct FirstOrderPlant {
    double a; // damping
    double b; // control effectiveness
    double y; // state (output)

    FirstOrderPlant(double a_, double b_, double y0)
        : a(a_), b(b_), y(y0) {}

    void step(double u, double dt) {
        // y_dot = -a y + b u
        double y_dot = -a * y + b * u;
        y += dt * y_dot;
    }
};

int main() {
    double a = 1.0;
    double b = 1.0;
    double K = 4.0;
    double r0 = 1.0;

    double dt = 0.001;
    double T  = 3.0;
    int N = static_cast<int>(T / dt);

    FirstOrderPlant plant(a, b, 0.0);

    std::vector<double> t;
    std::vector<double> y;
    t.reserve(N + 1);
    y.reserve(N + 1);

    double time = 0.0;
    for (int k = 0; k <= N; ++k) {
        t.push_back(time);
        y.push_back(plant.y);

        // Feedback control
        double y_m = plant.y;      // ideal measurement
        double e   = r0 - y_m;     // error
        double u   = K * e;        // proportional control

        plant.step(u, dt);
        time += dt;
    }

    // Print a few samples
    for (int k = 0; k <= N; k += N / 10) {
        std::cout << "t = " << t[k]
                  << ", y = " << y[k] << std::endl;
    }

    // In a ROS-based robot controller, this simulation loop
    // would be replaced by a real-time loop reading from
    // hardware interfaces and publishing actuator commands.
    return 0;
}
      

Robotics-related C++ frameworks (e.g., ROS/ROS 2 with ros_control or ros2_control) encapsulate the basic pattern of reading sensors, computing control actions, and writing commands to actuators, all based on the feedback elements introduced in this lesson.

Java is used in some robotics and automation environments (for example, educational robots and certain industrial controllers). The pattern is again a periodic loop implementing measurement, error computation, and actuation.

public class FirstOrderFeedback {

    public static void main(String[] args) {
        double a = 1.0;
        double b = 1.0;
        double K = 4.0;
        double r0 = 1.0;

        double dt = 0.001;
        double T  = 3.0;
        int N = (int) (T / dt);

        double y = 0.0; // plant output

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

            // Ideal measurement
            double y_m = y;
            // Error
            double e = r0 - y_m;
            // Proportional controller
            double u = K * e;

            // Plant dynamics: y_dot = -a y + b u
            double y_dot = -a * y + b * u;
            y += dt * y_dot;

            if (k % (N / 10) == 0) {
                System.out.println("t = " + t + ", y = " + y);
            }
        }

        // In robotics libraries such as WPILib for FRC robots,
        // a similar loop is wrapped around a PID controller class.
    }
}
      

Frameworks such as WPILib (for mobile robots) offer built-in PID controllers that encapsulate the feedback structure from this lesson while providing additional features (integral and derivative action, saturation handling, etc.).

MATLAB and Simulink are standard tools in control and robotics. Here we use an ODE model for the same feedback loop and solve it with ode45. In a robotics context, Robotics System Toolbox can be used to obtain plant models from robot dynamics, which can then be placed inside feedback loops.

% Parameters
a  = 1.0;
b  = 1.0;
K  = 4.0;
r0 = 1.0;

% Closed-loop ODE:
% y_dot = -(a + b*K)*y + b*K*r0
odefun = @(t, y) -(a + b*K) * y + b * K * r0;

tspan = [0 3];
y0    = 0;

[t, y] = ode45(odefun, tspan, y0);

r = r0 * ones(size(t));

figure;
plot(t, r, '--', 'DisplayName', 'reference r(t)');
hold on;
plot(t, y, 'DisplayName', 'output y(t)');
xlabel('time [s]');
ylabel('signal');
legend;
title('First-order plant with proportional feedback');

% In Simulink, you would connect:
%  - A Sum block to compute e = r - y
%  - A Gain block (value K) for the controller
%  - A first-order plant block or an integrator implementing the ODE
% and feed back y to the Sum block.
      

Once transfer functions and state-space models are introduced in later chapters, Simulink diagrams can be generated directly from these models and integrated with robotic plant models from the Robotics System Toolbox.

Wolfram Mathematica allows a compact symbolic description of the closed-loop dynamics and easy numerical simulation. This is useful when exploring the impact of parameters such as the gain \( K \) on the closed-loop response.

a  = 1.0;
b  = 1.0;
K  = 4.0;
r0 = 1.0;

(* Closed-loop ODE: y'(t) = -(a + b K) y(t) + b K r0 *)
eq  = y'[t] == -(a + b*K) y[t] + b*K*r0;
ic  = y[0] == 0.0;

sol = DSolve[{eq, ic}, y, t][[1]];

(* Simplified symbolic solution *)
ySym[t_] = y[t] /. sol // Simplify

(* Numeric plot *)
Plot[{r0, ySym[t]}, {t, 0, 3},
    PlotLegends -> {"reference r(t)", "output y(t)"},
    AxesLabel -> {"t", "signal"},
    PlotLabel -> "First-order plant with proportional feedback"
]

(* Numeric simulation with NDSolve (for more complex models) *)
ndSol = NDSolve[{eq, ic}, y, {t, 0, 3}];
      

In more advanced studies, Mathematica can also be used to derive linearized models of robotic dynamics symbolically and then embed them in feedback structures like the one studied here.

In this lesson we decomposed a feedback control system into its fundamental elements: reference, error, controller, actuator, plant, sensor, and feedback path. We expressed their relationships as signal equations and as linear differential equations, and we derived closed-loop dynamics for a simple first-order plant with a proportional controller. We also connected these abstract concepts to algorithmic implementations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, emphasizing their relevance to robotic control. These foundations prepare us to study stability, performance, and systematic design methods in subsequent lessons.