Consider a stable first-order LTI system with input \( u(t) \) and output \( y(t) \). Around a fixed operating point, many physical subsystems (e.g., RC circuits, thermal systems, low-speed robot joint dynamics) can be approximated by

\[ \tau \frac{\mathrm{d}y(t)}{\mathrm{d}t} + y(t) = K\,u(t), \quad \tau > 0,\; K \in \mathbb{R}. \]

The parameter \( K \) is the static gain (ratio of steady-state output to steady-state input), while \( \tau \) is the time constant. Intuitively, \( \tau \) sets the time scale over which the system reacts: smaller \( \tau \) means a faster response; larger \( \tau \) means a sluggish response.

For a unit-step input, the output of a stable first-order system rises monotonically from its initial value toward a new steady-state value. The time constant is defined as the time at which the response has completed about \( 63.2\% \) of the total change. We will prove this property rigorously in Section 3.

flowchart TD
  A["Physical system (motor joint, RC circuit)"]
    --> B["Model: tau dy/dt + y = K u"]
  B --> C["Transfer function G(s) = K/(tau s + 1)"]
  C --> D["Time-domain response y(t) after input change"]
  D --> E["Exponential term exp(-t/tau) identified"]
  E --> F["Time constant tau quantifies speed of response"]
        

Starting from the differential equation

\[ \tau \frac{\mathrm{d}y(t)}{\mathrm{d}t} + y(t) = K\,u(t), \]

take the Laplace transform under zero initial conditions \( y(0^{-}) = 0 \):

\[ \tau \left[ s Y(s) \right] + Y(s) = K U(s) \quad \Rightarrow \quad Y(s)\left(\tau s + 1\right) = K U(s). \]

Hence the transfer function from input to output is

\[ G(s) \triangleq \frac{Y(s)}{U(s)} = \frac{K}{\tau s + 1}. \]

The denominator polynomial \( \tau s + 1 \) has a single pole at \( s = -\dfrac{1}{\tau} \). For \( \tau > 0 \) this pole lies on the negative real axis, guaranteeing asymptotic stability of the homogeneous dynamics. Thus, for a first-order system,

\[ \text{pole location: } s_p = -\frac{1}{\tau} \quad \Longleftrightarrow \quad \text{time constant: } \tau = \frac{1}{|s_p|}. \]

The magnitude of the pole (distance from the origin along the real axis) is the inverse of the time constant: a pole further left (more negative) corresponds to a smaller time constant and therefore a faster response.

Consider the unit-step input \( u(t) = 1 \) for \( t \ge 0 \). The Laplace transform is \( U(s) = \dfrac{1}{s} \), so

\[ Y(s) = G(s) U(s) = \frac{K}{\tau s + 1} \cdot \frac{1}{s} = \frac{K}{s\left(\tau s + 1\right)}. \]

We perform partial fraction expansion

\[ \frac{K}{s\left(\tau s + 1\right)} = \frac{A}{s} + \frac{B}{\tau s + 1}. \]

Multiplying both sides by \( s\left(\tau s + 1\right) \) yields

\[ K = A\left(\tau s + 1\right) + B s. \]

Matching coefficients in powers of \( s \):

\[ \begin{cases} s\text{-terms:} & A \tau + B = 0, \\ \text{constant term:} & A = K. \end{cases} \]

Thus \( A = K \) and \( B = -K\tau \), so

\[ Y(s) = \frac{K}{s} - \frac{K\tau}{\tau s + 1}. \]

Taking the inverse Laplace transform:

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

The steady-state value is \( y(\infty) = K \). The time constant is defined as the time at which the exponential term has decayed to \( \mathrm{e}^{-1} \), i.e. the output has reached a fraction \( 1 - \mathrm{e}^{-1} \approx 0.632 \) of the total change:

\[ y(\tau) = K\left(1 - \mathrm{e}^{-\frac{\tau}{\tau}}\right) = K\left(1 - \mathrm{e}^{-1}\right) \approx 0.632\,K. \]

Therefore, for any stable first-order system excited by a step input, the time constant \( \tau \) is the time required for the output to achieve approximately \( 63.2\% \) of the final value, starting from zero. The remaining error at \( t = \tau \) is

\[ e(\tau) = K - y(\tau) = K\,\mathrm{e}^{-1} \approx 0.368\,K. \]

This exponential decay of the error underlies the quantitative connection between time constant and speed of response.

Define the tracking error for a unit-step input as \( e(t) = K - y(t) \). From the step response derived above,

\[ e(t) = K - K\left(1 - \mathrm{e}^{-\frac{t}{\tau}}\right) = K\,\mathrm{e}^{-\frac{t}{\tau}}. \]

The error magnitude satisfies

\[ |e(t)| = |e(0)|\,\mathrm{e}^{-\frac{t}{\tau}}, \quad e(0) = K. \]

Suppose we want the error to be reduced to a fraction \( \varepsilon \) of its initial value, where \( 0 < \varepsilon < 1 \). We ask for the time \( T_{\varepsilon} \) such that

\[ |e(T_{\varepsilon})| = \varepsilon |e(0)| \quad \Longleftrightarrow \quad \mathrm{e}^{-\frac{T_{\varepsilon}}{\tau}} = \varepsilon. \]

Taking natural logarithms:

\[ -\frac{T_{\varepsilon}}{\tau} = \ln(\varepsilon) \quad \Longrightarrow \quad T_{\varepsilon} = -\tau \,\ln(\varepsilon). \]

This formula shows that all time scales of interest (e.g. times to reach a given error band) are proportional to the time constant \( \tau \). For example:

• To reduce the error to \( 5\% \) of its initial value, choose \( \varepsilon = 0.05 \):

  \[ T_{0.05} = -\tau \,\ln(0.05) \approx 3\tau. \]

• To reduce the error to \( 2\% \) of its initial value, \( \varepsilon = 0.02 \):

  \[ T_{0.02} = -\tau \,\ln(0.02) \approx 4\tau. \]

Later lessons will name and standardize particular choices of \( \varepsilon \) as performance metrics (e.g. settling time for a prescribed error band). At this stage, the key takeaway is that the entire family of such times is linear in \( \tau \). Designing a faster system corresponds to reducing \( \tau \).

Many first-order transfer functions are initially obtained in the form

\[ G(s) = \frac{K}{s + a}, \quad a > 0. \]

This can be rewritten in the standard time-constant form by factoring out \( a \) in the denominator:

\[ G(s) = \frac{K}{a} \cdot \frac{1}{\frac{1}{a}s + 1} = K^{\ast} \cdot \frac{1}{\tau s + 1}, \quad K^{\ast} = \frac{K}{a},\; \tau = \frac{1}{a}. \]

Thus, for any stable first-order pole at \( s = -a \) with \( a > 0 \), the time constant is simply \( \tau = \dfrac{1}{a} \). Now compare two systems with the same static gain \( K \) but different time constants \( \tau_1 \) and \( \tau_2 \) satisfying \( 0 < \tau_1 < \tau_2 \). Their unit-step responses are

\[ y_1(t) = K\left(1 - \mathrm{e}^{-\frac{t}{\tau_1}}\right),\quad y_2(t) = K\left(1 - \mathrm{e}^{-\frac{t}{\tau_2}}\right). \]

For each fixed \( t > 0 \), since \( \tau_1 < \tau_2 \), we have \( \dfrac{t}{\tau_1} > \dfrac{t}{\tau_2} \) and hence \( \mathrm{e}^{-\frac{t}{\tau_1}} < \mathrm{e}^{-\frac{t}{\tau_2}} \). Because the mapping \( x \mapsto 1 - x \) is monotonically increasing,

\[ 1 - \mathrm{e}^{-\frac{t}{\tau_1}} > 1 - \mathrm{e}^{-\frac{t}{\tau_2}}, \quad t > 0, \]

so \( y_1(t) > y_2(t) \) for all \( t > 0 \). Therefore the system with the smaller time constant reaches any fixed fraction of its final value earlier in time. This formalizes the intuitive statement: smaller time constant implies faster response.

flowchart TD
  P1["Pole s = -1/tau1 (large magnitude)"] --> T1["Small tau1"]
  P2["Pole s = -1/tau2 (small magnitude)"] --> T2["Large tau2"]
  T1 --> R1["Fast exponential decay of error"]
  T2 --> R2["Slow exponential decay of error"]
        

In robot joint control, designers often specify a desired time constant for the closed-loop speed response (e.g., hip joint speed should settle within a few tenths of a second). Controller parameters (such as proportional gains) are then tuned so that the effective closed-loop pole lies at the corresponding location \( s = -1/\tau \).

We now simulate the first-order step response and compute the time constant numerically using several programming environments. The same mathematical model underlies many robotics libraries: a single joint or wheel speed actuator is frequently approximated as a first-order system around an operating point.

6.1 Python (NumPy, Matplotlib, and python-control)

The code below computes and plots the step response \( y(t) = K\left(1 - \mathrm{e}^{-t/\tau}\right) \) and highlights the time constant \( \tau \). The same model can be embedded in robotics simulations using the python-control library or within ROS-based controllers.

import numpy as np
import matplotlib.pyplot as plt

# First-order parameters
K = 1.0          # static gain
tau = 0.4        # time constant (seconds)

# Time grid up to 5 tau
t_end = 5.0 * tau
t = np.linspace(0.0, t_end, 400)

# Analytic step response y(t) = K * (1 - exp(-t/tau))
y = K * (1.0 - np.exp(-t / tau))

plt.figure()
plt.plot(t, y, label="step response")
plt.axhline(K, linestyle="--", label="steady state K")
plt.axvline(tau, linestyle=":", label="time constant tau")
plt.xlabel("t [s]")
plt.ylabel("y(t)")
plt.title("First-order step response")
plt.legend()
plt.grid(True)
plt.show()

# Using python-control for the same system:
import control
G = control.tf([K], [tau, 1.0])
t2, y2 = control.step_response(G, T=t)
      

In robotics, G can represent an identified motor speed plant; the same structure appears in ros_control-based joint controllers, where the closed-loop dynamics are often tuned to approximate a desired time constant.

6.2 C++ (Discrete Simulation; ROS-Oriented View)

A minimal C++ program to sample the step response at a fixed time step. Such code can be embedded in a low-level loop on a microcontroller or inside a ros_control real-time controller for a single joint actuator.

#include <iostream>
#include <cmath>

int main() {
    const double K = 1.0;
    const double tau = 0.4;
    const double t_end = 5.0 * tau;
    const int N = 200;
    const double dt = t_end / static_cast<double>(N - 1);

    for (int k = 0; k != N; ++k) {
        double t = k * dt;
        double y = K * (1.0 - std::exp(-t / tau));
        std::cout << t << "," << y << std::endl;
    }
    return 0;
}
      

Here we numerically reconstruct the same analytic expression. In a ROS-based system, the value tau typically comes from system identification of the actuator or from desired closed-loop pole placement.

6.3 Java (Console Simulation; Robotics Libraries)

Java is used in several educational robotics platforms (e.g. WPILib for mobile robots). The following code prints samples of the first-order step response; the same expression can be used to design simple motion filters or to approximate actuator dynamics.

import java.util.Locale;

public class FirstOrderStep {
    public static void main(String[] args) {
        double K = 1.0;
        double tau = 0.4;
        double tEnd = 5.0 * tau;
        int N = 200;
        double dt = tEnd / (N - 1);

        Locale.setDefault(Locale.US);
        for (int k = 0; k != N; ++k) {
            double t = k * dt;
            double y = K * (1.0 - Math.exp(-t / tau));
            System.out.printf("%.4f,%.4f%n", t, y);
        }
    }
}
      

In Java-based robotics frameworks (such as WPILib), similar first-order filters are used to smooth commands or model simple actuator dynamics inside higher-level controllers.

6.4 MATLAB/Simulink (Control System Toolbox and Robotics System Toolbox)

MATLAB provides direct functions for creating transfer functions and plotting their responses:

K = 1.0;
tau = 0.4;

% Define first-order transfer function G(s) = K / (tau s + 1)
s = tf('s');
G = K / (tau * s + 1);

% Step response and highlighting tau
t = 0:0.01:5*tau;
[y, t_out] = step(G, t);
figure;
plot(t_out, y, 'LineWidth', 1.5); hold on;
yline(K, '--');
xline(tau, ':');
xlabel('t [s]');
ylabel('y(t)');
title('First-order step response');
grid on;

% In Simulink:
% - Place a Transfer Fcn block with numerator [K] and denominator [tau 1].
% - Drive it by a Step block.
% - Use a Scope to visualize y(t).
      

Within the Robotics System Toolbox, one may combine such first-order models with more complex rigid-body tree models; for example, modeling motor-plus-gearbox dynamics feeding a joint in a manipulator and specifying closed-loop time constants for motion control.

6.5 Wolfram Mathematica (Analytic and Numeric View)

Mathematica naturally expresses both analytic and numeric aspects of the step response:

k = 1.0;
tau = 0.4;
tEnd = 5.0*tau;

y[t_] := k*(1 - Exp[-t/tau]);

Plot[y[t], {t, 0, tEnd},
  AxesLabel -> {"t", "y(t)"},
  PlotRange -> All,
  PlotLegends -> {"step response"}]

(* Solve for T_eps such that y(T_eps) = k*(1 - eps) *)
eps = 0.05;
T_eps = -tau*Log[eps]
      

This last line symbolically computes \( T_{\varepsilon} = -\tau\ln(\varepsilon) \), directly connecting the algebraic expression derived earlier with a numeric evaluation.

In this lesson we:

• Introduced the standard first-order model \( \tau \dfrac{\mathrm{d}y}{\mathrm{d}t} + y = K u \) and its transfer function \( G(s) = \dfrac{K}{\tau s + 1} \).
• Derived the unit-step response \( y(t) = K\left(1 - \mathrm{e}^{-t/\tau}\right) \) and proved the \( 63.2\% \) interpretation of the time constant.
• Obtained the general formula \( T_{\varepsilon} = -\tau \ln(\varepsilon) \) linking the time to reach a given error fraction with the time constant.
• Related the time constant to the real pole location via \( s_p = -1/\tau \), establishing that smaller \( \tau \) implies faster response.
• Illustrated first-order dynamics numerically in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, with emphasis on the role of time constant in robotics actuator models.

These results provide the foundation for the next lesson, where we formalize time-domain performance metrics for first-order systems (rise time, settling time, etc.) using the exponential structure captured by the time constant.