In this course, a first-order LTI system is a single-input single-output (SISO) system whose internal dynamics can be described by a linear differential equation of order one. That is, the highest derivative of the output in the governing equation is the first derivative. For an input \( u(t) \) and output \( y(t) \), a general first-order LTI model can be written as

\[ a_1 \frac{dy(t)}{dt} + a_0 y(t) = b_1 \frac{du(t)}{dt} + b_0 u(t), \]

where \( a_1, a_0, b_1, b_0 \) are real constants and we assume \( a_1 \neq 0 \) so that the equation is truly first-order. Under the modeling assumptions from earlier chapters:

• Linearity (superposition holds),
• Time invariance (coefficients are constant in time),
• Zero initial conditions when defining transfer functions,

this differential equation uniquely determines a transfer function \( G(s) \) that relates the Laplace transforms \( U(s) \) and \( Y(s) \) by \( Y(s) = G(s) U(s) \). First-order systems are ubiquitous in control engineering: thermal systems, RC electrical networks, viscously damped motion in one dominant mode, and many actuator models in robotics (e.g., current dynamics in DC motor drives) are well approximated by this class.

Starting from the general first-order ODE

\[ a_1 \frac{dy(t)}{dt} + a_0 y(t) = b_1 \frac{du(t)}{dt} + b_0 u(t), \]

we assume zero initial conditions (this is standard when defining the transfer function) and take the Laplace transform of both sides. Using properties from Chapter 2 and Chapter 4: \( \mathcal{L}\{ \tfrac{d y}{dt} \} = s Y(s) \) and similarly for \( u(t) \), we obtain

\[ a_1 s Y(s) + a_0 Y(s) = b_1 s U(s) + b_0 U(s). \]

Collecting terms in \( Y(s) \) and \( U(s) \),

\[ \left(a_1 s + a_0\right) Y(s) = \left(b_1 s + b_0\right) U(s), \]

so that the transfer function is

\[ G(s) \equiv \frac{Y(s)}{U(s)} = \frac{b_1 s + b_0}{a_1 s + a_0}. \]

This is the most general real-rational first-order transfer function. Its order (the degree of the denominator polynomial) is one, so the system has exactly one pole in the complex \( s \)-plane. Depending on the numerator coefficients \( b_1, b_0 \), there may be a zero as well.

flowchart TD
  PM["Physical model (mechanical / electrical / thermal)"] --> DE["1st-order ODE in y(t), u(t)"]
  DE --> L["Laplace transform with zero initial conditions"]
  L --> TF["Algebraic ratio G(s) = Y(s)/U(s)"]
  TF --> NF["Normalize to standard form K/(tau s + 1) or related"]
  NF --> INT["Interpret K, tau, pole, zero from parameters"]
        

In the rest of this lesson we systematically rewrite \( G(s) \) into standard forms and relate them to system properties that will be crucial in later lessons.

A large and important subclass of first-order systems has no derivative of the input, i.e., \( b_1 = 0 \). In that case

\[ G(s) = \frac{b_0}{a_1 s + a_0}. \]

Assuming \( a_0 \neq 0 \), divide numerator and denominator by \( a_0 \):

\[ G(s) = \frac{b_0 / a_0}{\left(a_1/a_0\right) s + 1} = \frac{K}{\tau s + 1}, \]

where we define the static gain \( K \) and the time constant \( \tau \) as

\[ K \triangleq \frac{b_0}{a_0}, \qquad \tau \triangleq \frac{a_1}{a_0}. \]

Under typical physical conditions \( a_1 > 0 \) and \( a_0 > 0 \), so that \( \tau > 0 \). The pole of this system is located at

\[ s_p = -\frac{1}{\tau}, \]

which lies on the negative real axis when \( \tau > 0 \), corresponding to a stable first-order mode. In Chapters 6 and 7 we will formalize stability further, but for first-order systems you can already remember: if \( s_p < 0 \) (negative real pole), the zero-input response decays to zero.

A key reason for preferring the normalized form \( \dfrac{K}{\tau s + 1} \) is that many time-response and design formulas become simple in terms of \( K \) and \( \tau \), and these parameters often have a clear physical meaning (e.g., thermal time constant, actuator bandwidth).

Beyond the strictly proper first-order form \( \dfrac{K}{\tau s + 1} \), several other standard elements in control can be viewed as first-order factors:

4.1 Pure gain

A static gain element has transfer function

\[ G_{\text{gain}}(s) = K. \]

There is no internal state; the output equals \( K \) times the input instantaneously. In many control loops (including robotic servo loops), encoders, amplifiers, and some sensors are idealized as pure gains.

4.2 Integrator

The ideal integrator, fundamental in control (especially for eliminating steady-state error), has transfer function

\[ G_{\text{int}}(s) = \frac{K}{s}. \]

Here the denominator degree is one, so this is technically a first-order system with a pole at \( s = 0 \). However, it is not asymptotically stable (the pole lies on the imaginary axis). In later chapters we will see how such marginally stable elements behave in feedback loops.

4.3 First-order lead and lag factors

In frequency-domain design, we frequently use first-order factors of the form

\[ G_{\text{lead/lag}}(s) = K \frac{\tau_z s + 1}{\tau_p s + 1}, \]

where \( \tau_z, \tau_p > 0 \). If \( \tau_z > \tau_p \) we obtain a lag-type factor; if \( \tau_z < \tau_p \) a lead-type factor. The pole and zero are located at \( s = -1/\tau_p \) and \( s = -1/\tau_z \), respectively. While the systematic design of such compensators is postponed to later chapters, we already see that they are constructed from first-order building blocks.

4.4 Strict properness and relative degree

For a rational transfer function \( G(s) = \dfrac{b_1 s + b_0}{a_1 s + a_0} \), define relative degree as (degree of denominator) minus (degree of numerator):

• If \( b_1 = 0 \), relative degree = 1 (strictly proper), e.g. \( \dfrac{K}{\tau s + 1} \).
• If \( b_1 \neq 0 \), relative degree = 0 (proper but not strictly proper).
• \( G(s) = K \) has relative degree 0 with no dynamics.

Many physical plants used in servo-type robotic applications have a strictly proper first order (or higher order) transfer function, while controllers and filters may include non-strictly proper factors.

Consider again the general first-order transfer function

\[ G(s) = \frac{b_1 s + b_0}{a_1 s + a_0}. \]

The pole \( s_p \) solves \( a_1 s + a_0 = 0 \), i.e.

\[ s_p = -\frac{a_0}{a_1}. \]

If \( b_1 \neq 0 \), the zero \( s_z \) solves \( b_1 s + b_0 = 0 \), i.e.

\[ s_z = -\frac{b_0}{b_1}. \]

Using the normalization of Section 3, a common alternative is

\[ G(s) = K \frac{s - s_z}{s - s_p}. \]

For a proper first-order plant with one real pole and possibly one real zero, both pole and zero lie on the real axis. In later chapters, this geometric interpretation in the \( s \)-plane will be directly linked to time response and stability margins. In this chapter our focus remains on obtaining and understanding the standard forms that we will reuse repeatedly.

In modern control and robotics software stacks, first-order transfer functions are often represented explicitly as rational functions or implicitly via state-space models. Here we consider the canonical form \( G(s) = \dfrac{K}{\tau s + 1} \) with some example values, say \( K = 2 \) and \( \tau = 0.5 \,\text{s} \). We show how to construct and simulate this element in several languages frequently used in control and robotics.

6.1 Python (with python-control and robotics context)

The python-control library provides functions for transfer-function and state-space manipulation. In robotics, such models are often combined with libraries like roboticstoolbox-python for kinematics and dynamics.

import numpy as np
import matplotlib.pyplot as plt

# Control systems library (python-control)
import control as ct

# First-order system: G(s) = K / (tau s + 1)
K = 2.0
tau = 0.5
G = ct.tf([K], [tau, 1.0])

print("Transfer function G(s) =")
print(G)

# Example: unit-step response
t = np.linspace(0.0, 5.0, 500)
t_out, y_out = ct.step_response(G, T=t)

plt.figure()
plt.plot(t_out, y_out)
plt.xlabel("t [s]")
plt.ylabel("y(t)")
plt.title("Unit-step response of first-order system")
plt.grid(True)
plt.show()

# In robotics, this G(s) can approximate, e.g., a simple current loop
# of a DC motor used in a robot joint or wheel drive.
      

6.2 C++ (simple discrete simulation; relation to ROS / Eigen)

In C++-based robotics frameworks (e.g., ROS with ros_control and Eigen for linear algebra), first-order models often appear inside low-level controllers and filters. Below is a minimal explicit Euler simulation of \( G(s) = \dfrac{K}{\tau s + 1} \) interpreted in the time domain as \( \tau \dot{y}(t) + y(t) = K u(t) \).

#include <iostream>
#include <vector>

int main() {
    double K = 2.0;
    double tau = 0.5;
    double dt = 0.001;           // time step [s]
    double T_final = 2.0;
    int N = static_cast<int>(T_final / dt);

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

    // Initial conditions
    t[0] = 0.0;
    y[0] = 0.0;

    // Unit-step input u(t) = 1
    for (int k = 0; k < N; ++k) {
        t[k + 1] = (k + 1) * dt;
        double u = 1.0;
        double dy_dt = (K * u - y[k]) / tau;   // from tau dy/dt + y = K u
        y[k + 1] = y[k] + dt * dy_dt;
    }

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

    return 0;
}
      

In a ROS-based robot controller, such a numerical integration loop might be embedded into a real-time control node, with Eigen used to handle vector-valued states and multi-axis joints. The underlying continuous-time model, however, still often reduces to a set of first-order or second-order factors.

6.3 Java (basic simulation skeleton; robotics libraries)

Java is used in some robotics contexts (for example, in educational platforms). Below is a simple Java class that simulates the same first-order system using explicit Euler integration:

public class FirstOrderSystem {
    private final double K;
    private final double tau;
    private double y;

    public FirstOrderSystem(double K, double tau) {
        this.K = K;
        this.tau = tau;
        this.y = 0.0;
    }

    // Simulate one step with explicit Euler
    public double step(double u, double dt) {
        double dy_dt = (K * u - y) / tau; // tau dy/dt + y = K u
        y = y + dt * dy_dt;
        return y;
    }

    public static void main(String[] args) {
        FirstOrderSystem sys = new FirstOrderSystem(2.0, 0.5);
        double dt = 0.001;
        double Tfinal = 2.0;
        int N = (int) (Tfinal / dt);

        double t = 0.0;
        for (int k = 0; k <= N; ++k) {
            double u = 1.0; // unit step
            double y = sys.step(u, dt);
            if (k % (N / 10) == 0) {
                System.out.println("t = " + t + " s, y = " + y);
            }
            t += dt;
        }
    }
}
      

Java-based robotics frameworks may wrap such continuous-time models into higher-level control libraries. The first-order structure remains visible in the underlying equations used for tuning and analysis.

6.4 MATLAB / Simulink (control and robotics toolboxes)

MATLAB's Control System Toolbox uses the same \( (K, \tau) \) parameters directly:

% First-order transfer function G(s) = K / (tau s + 1)
K   = 2;
tau = 0.5;

s = tf('s');
G = K / (tau * s + 1);

disp('Transfer function G(s) = ');
G

% Unit-step response
figure;
step(G);
grid on;
title('Unit-step response of first-order system');

% In robotics, such a block can represent a simplified actuator model
% inside a joint servo loop (e.g., in Robotics System Toolbox-based simulations).

% In Simulink:
%  - Place a Transfer Fcn block with Numerator [K] and Denominator [tau 1].
%  - Connect a Step block to its input and a Scope to its output.
      

6.5 Wolfram Mathematica

Mathematica provides symbolic and numeric tools for working with transfer functions via TransferFunctionModel:

(* Parameters *)
K   = 2.0;
tau = 0.5;

(* First-order transfer function G(s) = K / (tau s + 1) *)
G = TransferFunctionModel[K/(tau*s + 1), s];

(* Display transfer function *)
G // Simplify

(* Unit-step response over [0, 5] seconds *)
StepResponsePlot[G, {t, 0, 5},
  Frame -> True,
  FrameLabel -> {"t [s]", "y(t)"},
  PlotLegends -> {"Step response"}
]
      

In more advanced robotics modeling with Mathematica, such transfer-function models can be combined with rigid-body dynamics to produce inner-loop actuator dynamics or sensor filtering models, again using first-order blocks as fundamental building units.

In this lesson we formalized first-order LTI systems as those whose transfer functions have a first-degree denominator, typically of the form \( G(s) = \dfrac{b_1 s + b_0}{a_1 s + a_0} \). By imposing physically motivated assumptions (such as absence of input derivatives), we obtained the widely used canonical form \( G(s) = \dfrac{K}{\tau s + 1} \) with an easily interpretable static gain \( K \) and time constant \( \tau \). We also discussed pure gains, integrators, lead/lag factors, and the classification into strictly proper and proper-but-not-strictly-proper systems. Finally, we illustrated how these first-order models are represented and simulated in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, with remarks on how they appear in robotics software stacks. In the next lessons of this chapter we will exploit these standard forms to derive explicit time responses (step, ramp, impulse) and connect \( \tau \) to the speed of response.