A control system acts on an input (or reference) signal \( r(t) \) through actuators to influence the behavior of a physical plant (e.g., a robot joint, DC motor, or temperature chamber). The plant produces an output \( y(t) \), such as position or temperature. The key question in this lesson is whether the control action uses information about the current output.

Open-loop control: the control input \( u(t) \) is computed from the reference and time, but not from measurements of the plant output:

\[ u_{\text{open}}(t) = f\bigl(r(t), t\bigr). \]

Closed-loop (feedback) control: the control input depends on the difference between the reference and a measured output \( y_m(t) \) (which may be a noisy version of \( y(t) \)):

\[ u_{\text{closed}}(t) = g\bigl(r(t), y_m(t), t\bigr). \]

A very common linear feedback law is proportional control: \( u(t) = K \bigl(r(t) - y_m(t)\bigr) \), where \( K \in \mathbb{R} \) is the proportional gain.

flowchart LR
  subgraph OpenLoop["Open-loop control"]
    R1["Reference r(t)"] --> C1["Command generator (no feedback)"]
    C1 --> U1["Actuator signal u(t)"]
    U1 --> P1["Plant"]
    P1 --> Y1["Output y(t)"]
  end

  subgraph ClosedLoop["Closed-loop control with feedback"]
    R2["Reference r(t)"] --> SUM["Error computation: e(t) = r(t) - y_m(t)"]
    Y2["Output y(t)"] --> SENS["Sensor"]
    SENS --> YM["Measured output y_m(t)"]
    YM --> SUM
    SUM --> C2["Controller (for example u(t) = K * e(t))"]
    C2 --> U2["Actuator signal u(t)"]
    U2 --> P2["Plant"]
    P2 --> Y2
  end
        

Open-loop systems rely entirely on a model of the plant and the environment. Closed-loop systems continuously compare the actual behavior with the desired behavior and correct deviations via feedback. In the rest of the lesson we formalize these ideas for linear plants.

We begin with a simple static linear plant (no dynamics, representing steady-state behavior):

\[ y = k u, \]

where \( u \) is the actuator input, \( y \) is the output, and \( k \in \mathbb{R} \) is the (unknown) plant gain.

Suppose we want the output to track a constant reference \( r \). If the true gain \( k \) were known exactly, the ideal open-loop control law would set

\[ u_{\text{ideal}}(r) = \frac{r}{k}, \qquad y = k u_{\text{ideal}}(r) = r. \]

In reality, the controller uses an estimated gain \( \hat{k} \), obtained from calibration, design calculations, or identification. The implemented open-loop control is

\[ u_{\text{open}}(r) = \frac{r}{\hat{k}}. \]

The actual output of the plant is then

\[ y = k\,u_{\text{open}}(r) = k \frac{r}{\hat{k}} = r \frac{k}{\hat{k}}. \]

The tracking error \( e \) (difference between desired and actual output) is

\[ e = r - y = r - r\frac{k}{\hat{k}} = r\left(1 - \frac{k}{\hat{k}}\right). \]

Denote the gain error by \( \Delta k = \hat{k} - k \). We can write \( \hat{k} = k + \Delta k \) and expand the error for small \( \Delta k \) using a first-order Taylor approximation:

\[ \frac{k}{\hat{k}} = \frac{k}{k + \Delta k} \approx 1 - \frac{\Delta k}{k} \quad \text{for } |\Delta k| \ll |k|. \]

Substituting into the expression for \( e \), we obtain the approximate steady-state error:

\[ e \approx r\left(1 - \left(1 - \frac{\Delta k}{k}\right)\right) = r \frac{\Delta k}{k}. \]

Thus, in open-loop control, even a modest relative error in \( k \) produces a proportional error in the output. No mechanism exists to correct this, because \( y \) is never measured or compared to \( r \).

For the same static plant \( y = k u \), consider a proportional feedback controller that computes the control input using the error \( e = r - y \):

\[ u = K (r - y), \]

where \( K \) is the feedback gain. Substituting \( u \) into the plant equation gives

\[ y = k u = k K (r - y). \]

Solving for \( y \):

\[ y = k K (r - y) \quad \Longrightarrow \quad y + k K y = k K r \quad \Longrightarrow \quad (1 + k K) y = k K r. \]

Therefore the closed-loop output is

\[ y_{\text{cl}} = \frac{k K}{1 + k K} r. \]

The closed-loop steady-state error is

\[ e_{\text{cl}} = r - y_{\text{cl}} = r - \frac{k K}{1 + k K} r = \frac{1}{1 + k K} r. \]

Several observations follow:

• If \( k K > 0 \), the feedback is negative (the controller pushes \( y \) toward \( r \)).
• As \( K \to \infty \), the error \( e_{\text{cl}} \to 0 \) and \( y_{\text{cl}} \to r \).
• Unlike open-loop control, the closed-loop error does not explicitly depend on model mismatch between the controller and plant gains; it depends on the actual product \( kK \), which can be tuned.

This simple algebraic example already shows a core advantage of feedback: the error is divided by the factor \( 1 + k K \), which can be made large, thereby making the closed-loop system less sensitive to plant gain uncertainty.

We now consider a simple continuous-time first-order linear dynamical plant, which already appears in many mechanical and electrical systems:

\[ \dot{y}(t) = -a\,y(t) + b\,u(t), \]

where \( a > 0 \) and \( b > 0 \) are constants. The parameter \( a \) is related to the natural decay rate (or inverse time constant), and \( b \) is the input gain.

4.1 Open-loop with constant input

If the controller chooses a constant input \( u(t) = u_0 \) independent of \( y(t) \), then the solution of the differential equation is

\[ y_{\text{open}}(t) = y(0)\,e^{-a t} + \frac{b u_0}{a}\bigl(1 - e^{-a t}\bigr). \]

As \( t \to \infty \), the term \( e^{-a t} \) vanishes and we obtain the steady-state value

\[ y_{\text{open},\infty} = \frac{b}{a} u_0. \]

To achieve a desired steady-state value \( r \), the controller must choose \( u_0 = \frac{a}{b} r \). This requires accurate knowledge of \( a/b \). Any error in this ratio leads to a steady-state tracking error, exactly as in the static model.

4.2 Closed-loop with proportional feedback

Now consider a constant reference \( r \) and a proportional feedback controller

\[ u(t) = K\bigl(r - y(t)\bigr). \]

Substituting into the plant equation yields

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

This is again a first-order linear ODE. Its general solution is

\[ y_{\text{closed}}(t) = y_{\infty} + \bigl(y(0) - y_{\infty}\bigr) e^{-(a + b K)t}, \]

where the steady-state value \( y_{\infty} \) solves \( 0 = -(a + b K) y_{\infty} + b K r \), giving

\[ y_{\infty} = \frac{b K}{a + b K} r. \]

Hence the closed-loop steady-state error is

\[ e_{\text{closed},\infty} = r - y_{\infty} = r - \frac{b K}{a + b K} r = \frac{a}{a + b K} r. \]

When \( a \) and \( b K \) are positive, the exponential term \( e^{-(a + b K)t} \) decays to zero and \( y(t) \) converges to \( y_{\infty} \). As \( K \) increases, the factor \( \frac{a}{a + b K} \) becomes small and the steady-state error is reduced. Again, feedback suppresses the effect of imperfect knowledge of model parameters, without requiring explicit online estimation of \( a \) or \( b \).

Real plants are subject to disturbances. For example, an external torque on a robot joint, or a heat leak in a thermal system. Consider again the static plant, now with an additive disturbance \( d \):

\[ y = k u + d. \]

5.1 Open-loop with disturbance

The open-loop controller still chooses \( u_{\text{open}} = r / \hat{k} \). The output is

\[ y_{\text{open}} = k \frac{r}{\hat{k}} + d, \]

and the error becomes

\[ e_{\text{open}} = r - y_{\text{open}} = r\left(1 - \frac{k}{\hat{k}}\right) - d. \]

The disturbance \( d \) directly adds to the error; the controller has no way to react because it never measures \( y \).

5.2 Closed-loop with disturbance

For the proportional feedback controller \( u = K(r - y) \), with the same disturbed plant \( y = k u + d \), we have

\[ y = k K (r - y) + d. \]

Solving for \( y \):

\[ (1 + k K) y = k K r + d \quad \Longrightarrow \quad y_{\text{closed}} = \frac{k K}{1 + k K} r + \frac{1}{1 + k K} d. \]

The error is therefore

\[ e_{\text{closed}} = r - y_{\text{closed}} = \frac{1}{1 + k K} (r - d). \]

In particular, if \( r = 0 \) (pure regulation problem) we obtain

\[ e_{\text{closed}} = -\frac{1}{1 + k K} d. \]

Thus the disturbance contribution to the error is scaled by the factor \( \frac{1}{1 + k K} \). As \( k K \) grows, the impact of disturbances on the output is attenuated. This is a fundamental robustness property of feedback, even in these simple linear examples.

flowchart TD
  R["Reference r(t)"] --> SUM["Error e(t) = r(t) - y_m(t)"]
  SUM --> C["Controller u(t)"]
  C --> P["Plant"]
  D["Disturbance d(t)"] --> P
  P --> Y["True output y(t)"]
  Y --> SENS["Sensor"]
  SENS -->|"Measured output y_m(t)"| SUM
        

The diagram emphasizes that feedback uses the measured output to compensate not only for modeling errors, but also for unmeasured disturbances acting on the plant.

In robotics, open-loop and closed-loop control appear in many contexts:

• Open loop: sending a fixed PWM duty cycle to a motor driver and assuming this produces a desired speed, ignoring load variation and supply voltage changes.
• Closed loop: reading an encoder angle \( y(t) \) and computing \( u(t) = K (r(t) - y(t)) \) inside a real-time control loop.

Modern robotics software stacks offer structured support for implementing such loops:

• Python: ROS 1/ROS 2 nodes using rospy/rclpy with numerical backends such as numpy and control-oriented libraries like python-control.
• C++: ROS control frameworks (ros_control, ros2_control) with linear algebra using Eigen to represent states and gains.
• Java: robotics libraries such as WPILib (used in mobile robotics and educational settings) which provide controller classes and sensor interfaces.
• MATLAB/Simulink: Control loops modeled as block diagrams and executed in real time via code-generation toolchains or interfacing with hardware through the Robotics System Toolbox.
• Wolfram Mathematica: symbolic and numeric modeling of plants and feedback laws, with functions for linear systems and simulation.

In the next section we implement a simple first-order plant with both open-loop and closed-loop control in each of these languages using a discrete-time approximation suitable for software implementation.

We discretize the first-order plant \( \dot{y}(t) = -a y(t) + b u(t) \) using the explicit Euler method with sampling period \( h > 0 \):

\[ y_{k+1} = y_k + h\bigl(-a y_k + b u_k\bigr), \]

where \( y_k \approx y(kh) \), \( u_k \approx u(kh) \). We compare:

• Open loop: \( u_k = u_{\text{open}} \) constant.
• Closed loop: \( u_k = K\bigl(r - y_k\bigr) \).

7.1 Python (with NumPy and Matplotlib)

import numpy as np
import matplotlib.pyplot as plt

# Plant parameters
a = 1.0
b = 1.0

# Controller gain
K = 2.0

# Discretization
h = 0.01      # time step [s]
N = 1000      # number of steps
r = 1.0       # constant reference

t = np.linspace(0.0, N * h, N + 1)

y_open = np.zeros(N + 1)
y_closed = np.zeros(N + 1)

# Choose open-loop input to roughly achieve y ≈ 1 at steady state
u_open = a / b * r

for k in range(N):
    # Open-loop update
    y_open[k + 1] = y_open[k] + h * (-a * y_open[k] + b * u_open)

    # Closed-loop update
    e_k = r - y_closed[k]
    u_closed = K * e_k
    y_closed[k + 1] = y_closed[k] + h * (-a * y_closed[k] + b * u_closed)

# Plot for visualization
plt.plot(t, y_open, label="open-loop")
plt.plot(t, y_closed, label="closed-loop")
plt.axhline(r, linestyle="--", label="reference")
plt.xlabel("time [s]")
plt.ylabel("output y(t)")
plt.grid(True)
plt.legend()
plt.show()
      

In a robotics context, the core update loop would run inside a ROS node using rclpy timers, with y_closed obtained from sensors and u_closed sent to actuators.

7.2 C++ (using STL, compatible with ROS control loops)

#include <iostream>
#include <vector>

int main() {
    const double a = 1.0;
    const double b = 1.0;
    const double K = 2.0;
    const double h = 0.01;
    const int    N = 1000;
    const double r = 1.0;

    std::vector<double> y_open(N + 1, 0.0);
    std::vector<double> y_closed(N + 1, 0.0);

    const double u_open = a / b * r;

    for (int k = 0; k < N; ++k) {
        // Open-loop update
        y_open[k + 1] = y_open[k] +
                        h * (-a * y_open[k] + b * u_open);

        // Closed-loop update
        double e_k = r - y_closed[k];
        double u_closed = K * e_k;
        y_closed[k + 1] = y_closed[k] +
                          h * (-a * y_closed[k] + b * u_closed);
    }

    std::cout << "k,time,y_open,y_closed\n";
    for (int k = 0; k <= N; ++k) {
        double t = k * h;
        std::cout << k << ","
                  << t << ","
                  << y_open[k] << ","
                  << y_closed[k] << "\n";
    }

    return 0;
}
      

In a ROS controller written in C++, the body of the loop corresponds to the update() function of a ros_control controller, using Eigen vectors for higher-dimensional states.

7.3 Java (e.g., for educational robotics frameworks)

public class FirstOrderFeedbackExample {
    public static void main(String[] args) {
        double a = 1.0;
        double b = 1.0;
        double K = 2.0;
        double h = 0.01;
        int    N = 1000;
        double r = 1.0;

        double[] yOpen = new double[N + 1];
        double[] yClosed = new double[N + 1];

        double uOpen = a / b * r;

        for (int k = 0; k < N; ++k) {
            // Open-loop update
            yOpen[k + 1] = yOpen[k] +
                    h * (-a * yOpen[k] + b * uOpen);

            // Closed-loop update
            double eK = r - yClosed[k];
            double uClosed = K * eK;
            yClosed[k + 1] = yClosed[k] +
                    h * (-a * yClosed[k] + b * uClosed);
        }

        System.out.println("k,time,yOpen,yClosed");
        for (int k = 0; k <= N; ++k) {
            double t = k * h;
            System.out.println(
                k + "," + t + "," + yOpen[k] + "," + yClosed[k]
            );
        }
    }
}
      

In Java-based robotics frameworks (such as WPILib), the update logic would run in a periodic loop, with r determined by a higher level motion planner and yClosed provided by sensors.

7.4 MATLAB and Simulink

% Parameters
a = 1.0;
b = 1.0;
K = 2.0;
h = 0.01;
N = 1000;
r = 1.0;

y_open   = zeros(1, N + 1);
y_closed = zeros(1, N + 1);

u_open = a / b * r;

for k = 1:N
    % Open-loop update
    y_open(k + 1) = y_open(k) + h * (-a * y_open(k) + b * u_open);

    % Closed-loop update
    e_k = r - y_closed(k);
    u_closed = K * e_k;
    y_closed(k + 1) = y_closed(k) + ...
        h * (-a * y_closed(k) + b * u_closed);
end

t = (0:N) * h;
plot(t, y_open, 'LineWidth', 1.5); hold on;
plot(t, y_closed, 'LineWidth', 1.5);
yline(r, '--', 'LineWidth', 1.0);
grid on;
xlabel('time [s]');
ylabel('output y(t)');
legend('open-loop', 'closed-loop', 'reference');
title('First-order plant: open vs closed loop');
      

In Simulink, the same system can be constructed using blocks:

1. A constant block for the reference r.
2. A sum block computing e = r - y.
3. A gain block with gain K producing u.
4. A first-order plant using an integrator block implementing dy/dt = -a*y + b*u.
5. Scopes to visualize open-loop and closed-loop responses.

7.5 Wolfram Mathematica

a = 1.0;
b = 1.0;
K = 2.0;
h = 0.01;
N = 1000;
r = 1.0;

(* Euler update function for one step *)
stepOpen[y_] := y + h*(-a*y + b*(a/b*r));
stepClosed[y_] := Module[{e, u},
  e = r - y;
  u = K*e;
  y + h*(-a*y + b*u)
];

yOpenList = NestList[stepOpen, 0.0, N];
yClosedList = NestList[stepClosed, 0.0, N];
tList = Range[0, N]*h;

ListLinePlot[
  {
    Transpose[{tList, yOpenList}],
    Transpose[{tList, yClosedList}],
    Transpose[{tList, ConstantArray[r, Length[tList]]}]
  },
  PlotLegends -> {"open-loop", "closed-loop", "reference"},
  AxesLabel -> {"t", "y(t)"}
]
      

Mathematica can also handle symbolic solutions of the continuous-time ODEs, making it convenient for deriving analytical expressions for \( y_{\text{open}}(t) \) and \( y_{\text{closed}}(t) \), as in Section 4.

In this lesson we formalized the distinction between open-loop and closed-loop control for linear systems. For both static and first-order dynamical plants, we showed algebraically that:

• Open-loop control depends critically on accurate knowledge of plant parameters and cannot compensate for disturbances.
• Closed-loop control with negative feedback reduces steady-state error and sensitivity to plant gain errors by the factor \( 1/(1 + k K) \) (or its dynamical analogue).
• Disturbances entering the plant are attenuated in the closed-loop error by the same factor, explaining the robustness of feedback.
• Simple discrete-time implementations using Euler integration can be realized in Python, C++, Java, MATLAB/Simulink, and Mathematica, and embedded into robotics frameworks such as ROS and WPILib.

These ideas lay the conceptual and mathematical foundation for later chapters, where we will introduce more systematic models and design tools (transfer functions, block diagrams, and time- and frequency-domain performance measures).