Real physical systems (robot joints, motor drives, thermal plants, electrical networks) often lead to high-order differential equations and transfer functions. However, controllers for such systems are frequently designed using low-order (especially first-order) models because:

• Low-order models are easier to analyze and tune.
• Time response intuition (e.g., “time constant”, “speed of response”) is clearest for first-order systems.
• Fast internal dynamics may have negligible effect on the slowly varying closed-loop behavior.

Given a higher-order stable LTI plant with transfer function \( G(s) \), we seek a first-order approximation \( G_{\text{1st}}(s) \) of the form

\[ G_{\text{1st}}(s) = \frac{K}{1 + \tau_{\text{eq}} s}, \]

where \( K \) is the steady-state gain of the original plant and \( \tau_{\text{eq}} \) is an equivalent time constant chosen to approximate the dominant dynamics.

At a high level, the approximation workflow can be summarized as:

flowchart TD
  A["High-order plant G(s)"] --> B["Factor denominator → poles"]
  B --> C["Compute time constants / pole locations"]
  C --> D{"Is one pole \nclearly dominant?"}
  D -->|yes| E["Form first-order G1(s) \nwith dominant time constant"]
  D -->|no| F["Keep higher-order model or \nuse higher-order approximation"]
  E --> G["Compare step responses numerically"]
  G --> H["Use G1(s) for intuition \nand preliminary design"]
        

The rest of this lesson makes this picture precise using Laplace transforms, partial-fraction expansions, and explicit error bounds.

Consider a strictly proper, stable, SISO LTI system with transfer function

\[ G(s) = K \frac{\prod_{i=1}^{m} (s - z_i)}{\prod_{k=1}^{n} (s - p_k)}, \quad \Re(p_k) < 0. \]

In this lesson we focus on the important special case where all poles are real and negative, and there are no zeros:

\[ G(s) = \frac{K}{\prod_{k=1}^{n} (1 + \tau_k s)}, \quad \tau_k > 0. \]

For a unit-step input \( u(t) = 1 \), the Laplace transform is \( U(s) = 1/s \). The output transform is

\[ Y(s) = G(s) U(s) = \frac{K}{s \prod_{k=1}^{n} (1 + \tau_k s)}. \]

Because the denominator is a product of distinct first-order factors, \( Y(s) \) admits a partial-fraction decomposition

\[ Y(s) = \frac{K}{s} + \sum_{k=1}^{n} \frac{K \alpha_k}{1 + \tau_k s}, \]

where the coefficients \( \alpha_k \) are real constants determined by algebra. Taking the inverse Laplace transform, using \( \mathcal{L}^{-1}\{1/s\} = 1 \) and \( \mathcal{L}^{-1}\{1/(1+\tau_k s)\} = e^{-t/\tau_k}/\tau_k \), we obtain

\[ y(t) = K\left(1 + \sum_{k=1}^{n} \alpha_k e^{-t/\tau_k}\right), \quad t \ge 0. \]

The coefficients satisfy constraints obtained from the final value theorem. Since the system is stable,

\[ y(\infty) = \lim_{t \to \infty} y(t) = \lim_{s \to 0} s Y(s) = \lim_{s \to 0} \frac{K}{\prod_{k=1}^{n} (1 + \tau_k s)} = K. \]

On the other hand, from the time-domain expression, \( y(\infty) = K(1 + \sum_{k=1}^{n} \alpha_k \cdot 0) = K \), so consistency requires

\[ \sum_{k=1}^{n} \alpha_k = -1. \]

Thus a general stable, real-pole, higher-order step response is a weighted sum of decaying exponentials plus the steady-state value \( K \). The shape is fully determined by the time constants \( \tau_k \) and the coefficients \( \alpha_k \).

Suppose the time constants are ordered as \( \tau_1 \ge \tau_2 \ge \dots \ge \tau_n > 0 \). The exponential term \( e^{-t/\tau_1} \) decays the slowest; the others decay faster because their denominators \( \tau_k \) are smaller.

If time-scale separation holds, meaning for example

\[ \tau_1 \gg \tau_2,\dots,\tau_n, \]

then for time instants of interest (especially near the settling time) we have \( e^{-t/\tau_k} \approx 0 \) for \( k \ge 2 \), while \( e^{-t/\tau_1} \) is still significant. The response behaves approximately as

\[ y(t) \approx K\left(1 + \alpha_1 e^{-t/\tau_1}\right), \]

which is qualitatively similar to a first-order step response. If we choose \( \tau_{\text{eq}} = \tau_1 \) and adjust the static gain to be exactly \( K \), we obtain the canonical first-order model:

\[ G_{\text{1st}}(s) = \frac{K}{1 + \tau_1 s}. \]

In many practical cases, \( \alpha_1 \) is close to \( -1 \), so the response is very close to the unit first-order shape \( K(1 - e^{-t/\tau_1}) \). We now study this more carefully for a second-order example.

Consider the cascade of two stable first-order systems with gain \( K \) and time constants \( \tau_1 > \tau_2 > 0 \):

\[ G(s) = \frac{K}{(1 + \tau_1 s)(1 + \tau_2 s)}. \]

For a unit step input, the Laplace-domain output is

\[ Y(s) = \frac{K}{s(1 + \tau_1 s)(1 + \tau_2 s)}. \]

Using partial fractions, one can show

\[ Y(s) = \frac{K}{s} - \frac{K \tau_1^2}{(\tau_1 - \tau_2)(1 + \tau_1 s)} + \frac{K \tau_2^2}{(\tau_1 - \tau_2)(1 + \tau_2 s)}. \]

Taking inverse Laplace transforms yields the exact step response:

\[ y(t) = K\left[ 1 - \frac{\tau_1 e^{-t/\tau_1} - \tau_2 e^{-t/\tau_2}} {\tau_1 - \tau_2} \right], \quad t \ge 0. \]

A natural first-order approximation uses the dominant time constant \( \tau_1 \):

\[ G_{\text{1st}}(s) = \frac{K}{1 + \tau_1 s}, \quad y_{\text{1st}}(t) = K(1 - e^{-t/\tau_1}). \]

The approximation error is

\[ e(t) = y(t) - y_{\text{1st}}(t) = K \frac{\tau_2}{\tau_1 - \tau_2} \left(e^{-t/\tau_2} - e^{-t/\tau_1}\right). \]

Since for \( t \ge 0 \) we have \( 0 \le e^{-t/\tau_1}, e^{-t/\tau_2} \le 1 \), the maximum magnitude of the bracketed term is bounded by \( 1 \), hence

\[ |e(t)| \le K \frac{\tau_2}{\tau_1 - \tau_2}, \quad t \ge 0. \]

This simple inequality already shows that if \( \tau_1 \gg \tau_2 \), the worst-case error is small. For instance:

• If \( \tau_1 = 5 \tau_2 \) then \( |e(t)| \le K \tau_2/(4 \tau_2) = 0.25K \).
• If \( \tau_1 = 10 \tau_2 \) then \( |e(t)| \le K/9 \approx 0.11K \).

In practice, the error near the dominant time scale \( \tau_1 \) is usually much smaller than this conservative bound. This example justifies the engineering rule of thumb:

If the slowest time constant is at least 5–10 times larger than the others, a first-order approximation based on the slowest pole is often acceptable for time-response analysis.

Zeros modify the step response shape without changing the denominators' decay rates. Consider a system with a real zero:

\[ G(s) = K \frac{1 + z s}{1 + \tau s}, \quad z > 0,\; \tau > 0. \]

For a unit step, \( Y(s) = K(1 + z s)/(s(1 + \tau s)) \). After partial fractions, one can show

\[ y(t) = K\left[1 - \left(1 - \frac{z}{\tau}\right)e^{-t/\tau}\right], \quad t \ge 0. \]

The time constant of the exponential is still \( \tau \), but the shape is modified by the factor \( 1 - z/\tau \). Therefore, even if a system has a single pole, a nearby zero can distort the first-order behavior.

For higher-order systems with zeros, approximating by a simple first-order model is reliable only if:

• The dominant pole is clearly separated from other poles (time-scale separation), and
• Zeros are either far from the origin (high-frequency) or their effect is small in the time window of interest.

In later chapters (second-order systems and frequency response) we will see that poorly placed zeros can create overshoot or even “inverse responses” that no first-order model can reproduce. In such cases, a higher-order model is unavoidable.

We now illustrate first-order approximation on a numerical example corresponding to the two-pole system of Section 4 with \( K = 1 \), \( \tau_1 = 1 \,\text{s} \), \( \tau_2 = 0.1 \,\text{s} \). The exact plant and its first-order approximation are

\[ G(s) = \frac{1}{(1 + s)(1 + 0.1 s)}, \quad G_{\text{1st}}(s) = \frac{1}{1 + s}. \]

A typical modeling and simulation workflow can be summarized as:

flowchart TD
  A["Specify high-order G(s)"] --> B["Derive dominant pole and G1(s)"]
  B --> C["Implement both models in software"]
  C --> D["Simulate step response for each"]
  D --> E["Plot, compare, and quantify error"]
  E --> F["Decide if first-order model is acceptable"]
        

6.1 Python (control / robotics context)

In Python, the python-control library provides convenient functions for transfer functions and step responses. In robotics, such models often represent joint actuators or wheel drives, and can be used together with higher-level libraries like roboticstoolbox-python or ROS-based stacks.

import numpy as np
import matplotlib.pyplot as plt
import control as ct  # python-control library

# Exact second-order plant: G(s) = 1 / ((1 + s)(1 + 0.1 s))
G_full = ct.tf([1.0], np.polymul([1.0, 1.0], [0.1, 1.0]))

# First-order approximation using dominant pole tau1 = 1 s
G_1st = ct.tf([1.0], [1.0, 1.0])

t = np.linspace(0, 8, 400)
t1, y_full = ct.step_response(G_full, T=t)
t2, y_1st = ct.step_response(G_1st, T=t)

plt.figure()
plt.plot(t1, y_full, label="Full model")
plt.plot(t2, y_1st, linestyle="--", label="1st-order approx")
plt.xlabel("Time [s]")
plt.ylabel("Output")
plt.legend()
plt.grid(True)
plt.show()
      

In a robotics control stack (e.g., ROS), a similar reduced model can be used for gain tuning of low-level joint controllers before switching to a more detailed plant model.

6.2 C++ (ROS / Eigen context)

In C++, high-order models are often handled through state-space formulations, using linear algebra libraries like Eigen, and integrated into ROS controllers (ros_control). Below is a minimal explicit-Euler simulation of the first-order approximation:

#include <iostream>

int main() {
    double tau = 1.0;      // dominant time constant
    double K = 1.0;        // gain
    double dt = 0.001;     // integration step
    double T_end = 8.0;    // simulation horizon
    double x = 0.0;        // state of first-order system
    double u = 1.0;        // unit step input

    // First-order ODE: dx/dt = -(1/tau)*x + (K/tau)*u
    for (double t = 0.0; t <= T_end; t += dt) {
        double dx = -(1.0 / tau) * x + (K / tau) * u;
        x += dt * dx;
        if (static_cast<int>(t * 1000) % 100 == 0) {
            std::cout << t << " " << x << std::endl;
        }
    }
    return 0;
}
      

This simple integrator can be embedded as part of a motor or joint model in a ROS-based simulation to compare full and reduced-order dynamics.

6.3 Java (using numerical utilities, e.g., for robotics frameworks)

Java is sometimes used in educational robotics (e.g., via WPILib in FIRST Robotics). A simple discrete-time simulation of the first-order approximation can be written as:

public class FirstOrderApprox {
    public static void main(String[] args) {
        double tau = 1.0;
        double K = 1.0;
        double dt = 0.001;
        double T_end = 8.0;
        double x = 0.0;
        double u = 1.0;

        for (double t = 0.0; t <= T_end; t += dt) {
            double dx = -(1.0 / tau) * x + (K / tau) * u;
            x += dt * dx;
            if (((int)(t * 1000)) % 100 == 0) {
                System.out.println(t + " " + x);
            }
        }
    }
}
      

More sophisticated Java-based robotics frameworks can use libraries like Apache Commons Math for matrix operations and ODE solvers, while still relying on first-order approximations for simple actuator models.

6.4 MATLAB / Simulink (Control System and Robotics Toolboxes)

MATLAB's Control System Toolbox provides direct support for transfer functions, while the Robotics System Toolbox connects these models to robot kinematics and dynamics.

% Exact and approximate transfer functions
s = tf('s');
G_full = 1 / ((1 + s) * (1 + 0.1*s));
G_1st  = 1 / (1 + s);

figure;
step(G_full, G_1st);
legend('Full model', '1st-order approx');
grid on;

% In Simulink:
% - Place two Transfer Fcn blocks (G_full and G_1st)
% - Drive them with the same Step block
% - Compare outputs on a Scope block
      

In a robotics setting, the same first-order approximation might represent the current control loop of a DC motor driving a joint, while higher-order dynamics (flexibilities, sensor filters) are modeled separately.

6.5 Wolfram Mathematica

Mathematica has built-in support for transfer functions and step responses. It is often used to symbolically derive reduced-order models before exporting them to robotics simulators or embedded code.

(* Exact and first-order models *)
s = LaplaceTransformVariable[];
Gfull = TransferFunctionModel[1/((1 + s) (1 + 0.1 s)), s];
G1st  = TransferFunctionModel[1/(1 + s), s];

(* Step responses *)
StepResponsePlot[{Gfull, G1st}, {t, 0, 8},
  PlotLegends -> {"Full model", "1st-order approx"},
  Frame -> True, FrameLabel -> {"t (s)", "y(t)"}
]
      

Symbolic tools also allow you to compute partial fractions and error bounds analytically, as in Section 4, for more complex higher-order systems.

Problem 1 (Dominant Pole Approximation for a Two-Pole System)
Consider the plant

\[ G(s) = \frac{2}{(1 + 1.5 s)(1 + 0.2 s)}. \]

(a) Compute the steady-state gain for a unit-step input.
(b) Propose a first-order approximation based on the dominant pole.
(c) Using the formula from Section 4, give an upper bound on the approximation error \( |e(t)| \).

Solution:

(a) The DC gain is \( G(0) = 2/[(1)(1)] = 2 \), so the steady-state output under a unit step is \( y(\infty) = 2 \).

(b) The time constants are \( \tau_1 = 1.5 \) and \( \tau_2 = 0.2 \). The dominant (slow) time constant is \( \tau_1 \), so we choose

\[ G_{\text{1st}}(s) = \frac{2}{1 + 1.5 s}. \]

(c) The bound from Section 4, with gain \( K = 2 \), is

\[ |e(t)| \le K \frac{\tau_2}{\tau_1 - \tau_2} = 2 \frac{0.2}{1.5 - 0.2} = 2 \cdot \frac{0.2}{1.3} \approx 0.308. \]

Thus the worst-case error is approximately \( 0.31 \) in absolute value. In practice, for times around the settling time of the slow mode, the actual error is smaller.

Problem 2 (General n-th Order Real-Pole System)
Let

\[ G(s) = \frac{K}{\prod_{k=1}^{n} (1 + \tau_k s)}, \quad \tau_1 \ge \dots \ge \tau_n > 0, \]

and let \( y(t) \) be the unit-step response. Suppose we approximate \( G(s) \) by the first-order model \( G_{\text{1st}}(s) = K/(1 + \tau_1 s) \) with response \( y_{\text{1st}}(t) \). Show that the approximation error can be bounded in the form \( |y(t) - y_{\text{1st}}(t)| \le C e^{-t/\tau_2} \) for some constant \( C \) depending on the coefficients \( \alpha_k \).

Solution:

From Section 2, the exact step response is

\[ y(t) = K\left(1 + \sum_{k=1}^{n} \alpha_k e^{-t/\tau_k}\right). \]

The first-order model has response

\[ y_{\text{1st}}(t) = K(1 - e^{-t/\tau_1}). \]

Their difference is

\[ y(t) - y_{\text{1st}}(t) = K\left( \sum_{k=1}^{n} \alpha_k e^{-t/\tau_k} + e^{-t/\tau_1} \right) = K\left( (\alpha_1 + 1)e^{-t/\tau_1} + \sum_{k=2}^{n} \alpha_k e^{-t/\tau_k} \right). \]

Since \( \tau_1 \ge \tau_k \), we have \( e^{-t/\tau_k} \le e^{-t/\tau_2} \) for all \( k \ge 2 \). Also \( e^{-t/\tau_1} \le e^{-t/\tau_2} \). Hence

\[ |y(t) - y_{\text{1st}}(t)| \le K\left(|\alpha_1 + 1| + \sum_{k=2}^{n} |\alpha_k|\right) e^{-t/\tau_2} = C e^{-t/\tau_2} \]

with \( C = K\left(|\alpha_1 + 1| + \sum_{k=2}^{n} |\alpha_k|\right) \). Thus the error decays at least as fast as the second-slowest mode.

Problem 3 (Zero and Effective Gain)
Consider

\[ G(s) = \frac{K(1 + 0.1 s)}{(1 + s)(1 + 0.1 s)}. \]

(a) Simplify \( G(s) \).
(b) What is the corresponding first-order model and its time constant?
(c) Explain, using this example, how “high-frequency” zeros can sometimes be neglected in first-order approximations.

Solution:

(a) The zero and one pole cancel algebraically:

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

(b) The model is exactly first-order with time constant \( \tau = 1 \). There is no approximation here; the cancellation is exact.

(c) In more realistic plants, the cancellation is only approximate, but if the zero is located at a much higher frequency than the dominant pole, its influence on the time response for typical time scales is small. In such cases, an approximate cancellation leads to an effective first-order behavior similar to this ideal example.

Problem 4 (Robotics Interpretation)
A DC motor driving a lightweight robot joint can be modeled (after linearization and electrical-mechanical reduction) as a third-order system. Numerical identification yields three time constants:

\[ \tau_1 = 0.5 \,\text{s},\quad \tau_2 = 0.08 \,\text{s},\quad \tau_3 = 0.02 \,\text{s}. \]

(a) Argue whether a first-order approximation is reasonable for closed-loop position control.
(b) Which time constant should you use in the first-order model?

Solution:

(a) The fastest time constants are much smaller than the dominant one: \( \tau_1/\tau_2 \approx 6.25 \) and \( \tau_1/\tau_3 = 25 \). Thus, the faster modes decay much earlier than the 0.5 s mode. For time scales relevant to joint position control (e.g., rise times on the order of 0.5–1 s), the response will be largely governed by the \( \tau_1 \) mode, so a first-order approximation is reasonable for preliminary controller tuning.

(b) We choose \( \tau_{\text{eq}} = \tau_1 = 0.5 \,\text{s} \) in the first-order model \( G_{\text{1st}}(s) = K/(1 + 0.5 s) \), with \( K \) equal to the steady-state gain identified from experiments.

Problem 5 (Time Constant from Experimental Step Response)
A high-order stable system is known to be well approximated by a first-order model. An experiment shows that the unit-step response reaches 63% of its final value at \( t = 0.8 \,\text{s} \). Estimate the equivalent time constant \( \tau_{\text{eq}} \) and write the approximate transfer function.

Solution:

For a first-order system with unit-step response \( y(t) = K(1 - e^{-t/\tau}) \), the time at which the response reaches \( 0.63K \) is exactly \( t = \tau \). Thus, if the measured 63% time is 0.8 s, we take \( \tau_{\text{eq}} = 0.8 \,\text{s} \). The approximate transfer function is then

\[ G_{\text{1st}}(s) = \frac{K}{1 + 0.8 s}, \]

where \( K \) is determined from the steady-state value of the experiment.

In this lesson, we showed how higher-order LTI systems with real, stable poles produce step responses expressed as sums of decaying exponentials. When one pole is much closer to the origin than the others (equivalently, when one time constant is much larger), the slowest mode dominates the response for time scales of interest.

By formally analyzing the two-pole case, we obtained explicit error bounds that justify the dominant-pole first-order approximation. We also discussed the effect of zeros and emphasized that poorly placed zeros or closely spaced poles can invalidate a first-order model, necessitating higher-order descriptions. Finally, we demonstrated how to simulate and compare full and reduced-order models in several programming environments commonly used in control and robotics.

These ideas are the bridge between the simple first-order responses of this chapter and the richer dynamics of genuine second-order systems, which will be the focus of the next chapter.