A first-order LTI system is characterized by a single state of energy storage (e.g., one capacitor, one thermal mass, one fluid capacitance). Its time-domain response to common inputs is governed by exponential transients. The central parameters are:

• \( K \): steady-state (DC) gain
• \( \tau \): time constant that sets the transient speed

By the end of this lesson, you should be able to:

• Convert a first-order ODE to a standard first-order transfer function.
• Derive the step response \( y(t) \) and isolate transient vs. steady-state parts.
• Prove key properties: exponential error decay, monotonicity (under standard sign assumptions), and the 63.2% rule.
• Map \( \tau \) to physical parameters (e.g., \( RC \), \( R_{\text{th}}C_{\text{th}} \)).
• Simulate first-order step responses in multiple programming environments.

flowchart TD
  A["Given: first-order model"] --> B["Standardize: tau*y_dot + y = K*u"]
  B --> C["Choose input: step u(t) = A for t>=0"]
  C --> D["Compute steady-state: y_ss = K*A"]
  D --> E["Solve transient: y(t) = y_ss + (y0 - y_ss)*exp(-t/tau)"]
  E --> F["Extract time constant tau (speed of decay)"]
  F --> G["Interpret tau physically (RC, thermal, tank)"]
  G --> H["Implement simulation (exact update or ODE solver)"]
        

The canonical first-order LTI input-output differential equation is

\[ \tau \,\frac{dy(t)}{dt} + y(t) = K\,u(t), \quad \tau \neq 0. \]

A frequently used equivalent parametrization is

\[ \frac{dy(t)}{dt} + a\,y(t) = b\,u(t), \quad a = \frac{1}{\tau},\;\; b = \frac{K}{\tau}. \]

Taking the Laplace transform under zero initial conditions (as established in earlier chapters), we obtain:

\[ (\tau s + 1)Y(s) = K\,U(s) \;\;\Longrightarrow\;\; G(s) \equiv \frac{Y(s)}{U(s)} = \frac{K}{\tau s + 1}. \]

The transfer function has a single pole at \( s_p \): \( s_p = -\frac{1}{\tau} \). The homogeneous (zero-input) response follows from \( \tau \, \dot{y} + y = 0 \), which yields an exponential mode:

\[ \tau \,\frac{dy}{dt} + y = 0 \;\;\Longrightarrow\;\; \frac{1}{y}\frac{dy}{dt} = -\frac{1}{\tau} \;\;\Longrightarrow\;\; y(t) = y(0)\,e^{-t/\tau}. \]

Hence, \( \tau \) directly scales the exponential decay rate \( 1/\tau \). (Formal stability classifications are deferred to Chapter 11; here we focus on observed time-domain behavior.)

Consider a step input of amplitude \( A \):

\[ u(t) = A\,1(t) = \begin{cases} 0, & t < 0 \\ A, & t \ge 0 \end{cases} \]

For \( t \ge 0 \), the system equation becomes

\[ \tau \,\frac{dy(t)}{dt} + y(t) = K A. \]

Divide by \( \tau \) (nonzero) and use the integrating factor method:

\[ \frac{dy}{dt} + \frac{1}{\tau}y = \frac{K}{\tau}A. \]

Define the integrating factor \( \mu(t) \): \( \mu(t) = e^{\int (1/\tau)\,dt} = e^{t/\tau} \). Multiply both sides:

\[ e^{t/\tau}\frac{dy}{dt} + \frac{1}{\tau}e^{t/\tau}y = \frac{K}{\tau}A\,e^{t/\tau}. \]

The left-hand side is an exact derivative:

\[ \frac{d}{dt}\left(e^{t/\tau}y(t)\right) = \frac{K}{\tau}A\,e^{t/\tau}. \]

Integrate from \( 0 \) to \( t \) using initial condition \( y(0) = y_0 \):

\[ e^{t/\tau}y(t) - y_0 = \frac{K}{\tau}A \int_{0}^{t} e^{\xi/\tau}\,d\xi = \frac{K}{\tau}A \cdot \tau\left(e^{t/\tau}-1\right). \]

Solve for \( y(t) \):

\[ y(t) = KA + \left(y_0 - KA\right)e^{-t/\tau}, \quad t \ge 0. \]

This splits naturally into:

• Steady-state part: \( y_{\text{ss}} = KA \)
• Transient part: \( (y_0 - y_{\text{ss}})e^{-t/\tau} \)

In particular, for a unit-step \( A=1 \) and zero initial condition \( y_0=0 \):

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

For a unit step input, \( U(s) = 1/s \). Using \( G(s) = \frac{K}{\tau s + 1} \),

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

Perform partial fractions:

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

Multiply through by \( s(\tau s + 1) \):

\[ K = A(\tau s + 1) + Bs. \]

Match coefficients of \( s \) and constants:

\[ \begin{aligned} s: &\quad 0 = A\tau + B \\ 1: &\quad K = A \end{aligned} \;\;\Longrightarrow\;\; A = K,\;\; B = -K\tau. \]

Hence,

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

Take inverse Laplace using common pairs:

\[ \mathcal{L}^{-1}\left\{\frac{1}{s}\right\}=1(t),\quad \mathcal{L}^{-1}\left\{\frac{1}{\tau s + 1}\right\}=\frac{1}{\tau}e^{-t/\tau}1(t). \]

Therefore,

\[ y(t) = K\left(1 - e^{-t/\tau}\right)1(t), \]

which matches the direct ODE derivation for \( y_0=0 \), \( A=1 \), \( t \ge 0 \).

For a unit-step response with \( y_0=0 \), the output is \( y(t) \): \( y(t)=K(1-e^{-t/\tau}) \). The steady-state value is \( y_{\text{ss}} \): \( y_{\text{ss}}=K \).

Definition (time constant via 63.2% rule).

The time constant \( \tau \) is the time at which the response has completed \( 1-e^{-1} \approx 0.632 \) of the total step change:

\[ y(\tau) = y_{\text{ss}}\left(1-e^{-1}\right). \]

Proof: Substitute \( t=\tau \) into the step response:

\[ y(\tau) = K\left(1-e^{-\tau/\tau}\right) = K\left(1-e^{-1}\right) = y_{\text{ss}}\left(1-e^{-1}\right). \]

A complementary viewpoint uses the error to steady state: \( e(t) \): \( e(t)=y_{\text{ss}}-y(t) \). For \( y_0=0 \), \( y_{\text{ss}}=K \), we get

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

Thus, every \( \tau \) seconds, the error shrinks by a factor \( e^{-1} \).

General time-to-reach fraction. For \( 0 < \alpha < 1 \), define the time \( t_\alpha \) such that \( y(t_\alpha)=\alpha y_{\text{ss}} \) (assuming \( y_0=0 \), step up). Then:

\[ \alpha y_{\text{ss}} = y_{\text{ss}}\left(1-e^{-t_\alpha/\tau}\right) \;\;\Longrightarrow\;\; e^{-t_\alpha/\tau} = 1-\alpha \;\;\Longrightarrow\;\; t_\alpha = -\tau \ln(1-\alpha). \]

Monotonicity under standard sign assumptions.

Suppose \( \tau > 0 \) and the step is upward with \( y_0 \le y_{\text{ss}} \). Differentiate the general solution \( y(t)=y_{\text{ss}}+(y_0-y_{\text{ss}})e^{-t/\tau} \):

\[ \frac{dy}{dt} = (y_0-y_{\text{ss}})\left(-\frac{1}{\tau}\right)e^{-t/\tau} = \frac{(y_{\text{ss}}-y_0)}{\tau}e^{-t/\tau}. \]

If \( y_{\text{ss}} \ge y_0 \) and \( \tau > 0 \), then \( dy/dt \ge 0 \) for all \( t \ge 0 \). Hence the response increases monotonically and cannot overshoot.

Estimating \( \tau \) from data (log-error method).

From \( e(t)=e(0)e^{-t/\tau} \), take the natural logarithm:

\[ \ln e(t) = \ln e(0) - \frac{t}{\tau}. \]

Therefore, plotting \( \ln e(t) \) versus \( t \) yields a straight line of slope \( -1/\tau \), enabling estimation of \( \tau \) from experimental transient data.

Preview used later (performance metrics): Because \( e(t)/e(0)=e^{-t/\tau} \), the time to reach a small relative error \( \varepsilon \) satisfies \( t = -\tau\ln \varepsilon \). This will be reused systematically in Lesson 5.

A recurring theme in system dynamics is that first-order behavior arises from one dominant storage element and one dominant dissipation/throughput mechanism. In many cases:

• Storage sets how much “state” can accumulate (capacitance-like).
• Dissipation/transport sets how quickly the state can change (resistance-like).
• The time constant is often a product: (resistance) × (capacitance).

flowchart TD
  U["Input u(t) (forcing)"] --> D["Dissipation / transport (R_eq)"]
  D --> S["Storage (C_eq)"]
  S --> Y["State / output y(t)"]
  Y --> E1["Dynamics: y_dot = (1/tau)*(K*u - y)"]
  E1 --> E2["Time constant: tau = R_eq * C_eq (common cases)"]
        

6.1 Electrical RC circuit (capacitor voltage as output).

For a series resistor \( R \) feeding a capacitor \( C \) to ground, with input voltage \( v_{\text{in}}(t) \) and output capacitor voltage \( v_c(t) \), KCL gives: \( i_R = i_C \), where \( i_R = (v_{\text{in}}-v_c)/R \) and \( i_C = C\,dv_c/dt \).

\[ C\frac{dv_c}{dt} = \frac{v_{\text{in}}(t)-v_c(t)}{R} \;\;\Longrightarrow\;\; RC\frac{dv_c}{dt} + v_c(t) = v_{\text{in}}(t). \]

Comparing with \( \tau \dot{y} + y = K u \), we identify:

\[ y \equiv v_c,\quad u \equiv v_{\text{in}},\quad K=1,\quad \tau = RC. \]

6.2 Lumped thermal system (temperature as output).

A body with thermal capacitance \( C_{\text{th}} \) exchanging heat through thermal resistance \( R_{\text{th}} \) with an environment temperature \( T_{\text{env}}(t) \) satisfies an energy balance:

\[ C_{\text{th}}\frac{dT}{dt} = \frac{T_{\text{env}}(t)-T(t)}{R_{\text{th}}} \;\;\Longrightarrow\;\; R_{\text{th}}C_{\text{th}}\frac{dT}{dt} + T(t) = T_{\text{env}}(t). \]

Hence \( K=1 \) and \( \tau = R_{\text{th}}C_{\text{th}} \). Large thermal mass (large \( C_{\text{th}} \)) or strong insulation (large \( R_{\text{th}} \)) yields slow temperature transients.

6.3 Simple fluid tank level model (linear outflow approximation).

For a tank with cross-sectional area \( A \), inflow \( q_{\text{in}}(t) \), and outflow approximated as \( q_{\text{out}}(t)=\frac{1}{R_h}h(t) \) (linear hydraulic resistance near an operating point), mass balance gives:

\[ A\frac{dh}{dt} = q_{\text{in}}(t) - \frac{1}{R_h}h(t) \;\;\Longrightarrow\;\; (AR_h)\frac{dh}{dt} + h(t) = R_h\,q_{\text{in}}(t). \]

Here, \( y \equiv h \), \( u \equiv q_{\text{in}} \), \( K = R_h \), and \( \tau = AR_h \).

For simulation and digital implementation, it is useful to express the first-order model in state form:

\[ \frac{dy}{dt} = -\frac{1}{\tau}y + \frac{K}{\tau}u. \]

Exact discrete-time update (zero-order hold on \( u \)). Assume \( u(t)=u_k \) for \( t \in [kT_s,(k+1)T_s) \). Solving the ODE over one sample interval yields:

\[ y_{k+1} = e^{-T_s/\tau}\,y_k + K\left(1-e^{-T_s/\tau}\right)u_k. \]

This formula is numerically robust and avoids integration error for first-order systems.

7.1 Python (SciPy + optional python-control)

import numpy as np
import matplotlib.pyplot as plt

# First-order parameters
K = 2.0
tau = 0.8      # time constant
A = 1.0        # step amplitude
y0 = 0.0

# Analytic step response for t >= 0: y(t) = K*A + (y0 - K*A)*exp(-t/tau)
t = np.linspace(0.0, 5.0 * tau, 600)
y = K * A + (y0 - K * A) * np.exp(-t / tau)

plt.figure()
plt.plot(t, y)
plt.xlabel("t (s)")
plt.ylabel("y(t)")
plt.title("First-order step response (analytic)")
plt.grid(True)
plt.show()

# Exact discrete-time update under ZOH: y[k+1] = a*y[k] + b*u[k]
Ts = 0.05
a = np.exp(-Ts / tau)
b = K * (1.0 - a)

N = int(np.ceil((5.0 * tau) / Ts))
yk = np.zeros(N + 1)
uk = A * np.ones(N)  # step input

yk[0] = y0
for k in range(N):
    yk[k + 1] = a * yk[k] + b * uk[k]

tk = np.arange(N + 1) * Ts
plt.figure()
plt.plot(tk, yk, label="Exact discrete update")
plt.plot(t, y, "--", label="Analytic (continuous)")
plt.xlabel("t (s)")
plt.ylabel("y")
plt.title("First-order response: discrete vs analytic")
plt.grid(True)
plt.legend()
plt.show()

# Optional: SciPy step response (requires scipy)
# from scipy import signal
# sys = signal.TransferFunction([K], [tau, 1.0])
# t2, y2 = signal.step(sys)
      

Libraries to know (Python): scipy.signal (transfer functions and step), numpy (arrays), matplotlib (plots), and optionally control (python-control) for classical control workflows.

7.2 C++ (exact update; suitable for embedded-style simulation)

#include <iostream>
#include <fstream>
#include <cmath>

int main() {
    // Parameters
    const double K = 2.0;
    const double tau = 0.8;
    const double A = 1.0;       // step amplitude
    const double Ts = 0.05;     // sample time
    const double t_end = 5.0 * tau;

    // Exact ZOH discrete update coefficients
    const double a = std::exp(-Ts / tau);
    const double b = K * (1.0 - a);

    double y = 0.0;  // y0
    std::ofstream file("first_order_step.csv");
    file << "t,y\n";

    int N = static_cast<int>(std::ceil(t_end / Ts));
    for (int k = 0; k <= N; ++k) {
        double t = k * Ts;
        file << t << "," << y << "\n";

        if (k < N) {
            double u = A;               // step
            y = a * y + b * u;          // exact update
        }
    }

    file.close();
    std::cout << "Wrote first_order_step.csv\n";
    return 0;
}
      

Libraries to know (C++): for general ODE integration, Boost.Odeint is common. For larger linear systems later in the course, Eigen becomes standard for matrix computations.

7.3 Java (exact update; lightweight and deterministic)

import java.io.FileWriter;
import java.io.IOException;

public class FirstOrderStep {
    public static void main(String[] args) throws IOException {
        // Parameters
        double K = 2.0;
        double tau = 0.8;
        double A = 1.0;       // step amplitude
        double Ts = 0.05;
        double tEnd = 5.0 * tau;

        double a = Math.exp(-Ts / tau);
        double b = K * (1.0 - a);

        double y = 0.0; // y0

        try (FileWriter fw = new FileWriter("first_order_step_java.csv")) {
            fw.write("t,y\n");
            int N = (int) Math.ceil(tEnd / Ts);

            for (int k = 0; k <= N; k++) {
                double t = k * Ts;
                fw.write(t + "," + y + "\n");

                if (k < N) {
                    double u = A;          // step
                    y = a * y + b * u;     // exact update
                }
            }
        }

        System.out.println("Wrote first_order_step_java.csv");
    }
}
      

Libraries to know (Java): Apache Commons Math provides ODE solvers and linear algebra utilities. For matrix-heavy workflows later, EJML is also widely used.

7.4 MATLAB (Control System Toolbox) and Simulink

% MATLAB: First-order step response using tf and step
K = 2.0;
tau = 0.8;

sys = tf(K, [tau 1]);     % G(s) = K / (tau*s + 1)
figure; step(sys);
grid on;
title('First-order step response: G(s)=K/(tau s + 1)');

% Compare analytic expression
t = linspace(0, 5*tau, 600);
y = K*(1 - exp(-t/tau));
figure; plot(t, y);
grid on; xlabel('t'); ylabel('y(t)');
title('First-order step response (analytic)');
      

Simulink block-level procedure (conceptual):

• Drag blocks: Step → Transfer Fcn → Scope.
• Set Transfer Fcn numerator to [K] and denominator to [tau 1].
• Set Step time to 0, Initial value to 0, Final value to 1 (or \( A \)).
• Run and verify the 63.2% point occurs at \( t=\tau \).

7.5 Wolfram Mathematica (symbolic + numeric)

(* Mathematica: symbolic step response of tau y'(t) + y(t) = K A, y(0)=y0 *)
ClearAll[t, y, K, A, tau, y0];
K = 2; A = 1; tau = 0.8; y0 = 0;

sol = DSolveValue[{tau y'[t] + y[t] == K A, y[0] == y0}, y, t]
(* Expected: K A + (y0 - K A) Exp[-t/tau] *)

Plot[Evaluate[sol], {t, 0, 5 tau},
 PlotRange -> All,
 GridLines -> Automatic,
 AxesLabel -> {"t", "y(t)"},
 PlotLabel -> "First-order step response (symbolic)"]

(* Exact discrete-time update demonstration *)
Ts = 0.05;
a = Exp[-Ts/tau];
b = K (1 - a);
N = Ceiling[(5 tau)/Ts];
yList = NestList[a # + b A &, y0, N];
tList = Range[0, N] Ts;

ListLinePlot[Transpose[{tList, yList}],
 GridLines -> Automatic,
 AxesLabel -> {"t", "y[k]"},
 PlotLabel -> "First-order step response (exact discrete update)"]
      

The following exercises align with standard first-order transient analysis in classical system dynamics texts. Provide complete derivations, not only final formulas.

Problem 1 (General step with nonzero initial condition):
Solve \( \tau \dot{y}(t) + y(t) = K A \) for \( t \ge 0 \) with initial condition \( y(0)=y_0 \).

Solution: This is exactly the derivation in Section 3. The closed-form solution is

\[ y(t) = KA + (y_0 - KA)e^{-t/\tau},\quad t \ge 0. \]

The transient term \( (y_0-y_{\text{ss}})e^{-t/\tau} \) decays exponentially for \( \tau > 0 \).

Problem 2 (Time to reach a specified fraction):
For the unit-step response with \( y_0=0 \), find the time \( t_\alpha \) such that \( y(t_\alpha) = \alpha y_{\text{ss}} \), where \( 0 < \alpha < 1 \).

Solution: With \( y(t)=y_{\text{ss}}(1-e^{-t/\tau}) \), set \( \alpha y_{\text{ss}}=y_{\text{ss}}(1-e^{-t_\alpha/\tau}) \):

\[ \alpha = 1-e^{-t_\alpha/\tau} \;\;\Longrightarrow\;\; t_\alpha = -\tau\ln(1-\alpha). \]

Problem 3 (RC numerical evaluation and 90% time):
An RC circuit has \( R=2\,\text{k}\Omega \), \( C=50\,\mu\text{F} \), input step \( v_{\text{in}}(t)=5\,\text{V}\cdot 1(t) \), and \( v_c(0)=0 \). (i) Find \( v_c(t) \). (ii) Find the time to reach 90% of final value.

Solution: From Section 6.1, \( \tau = RC \) and \( K=1 \). Compute:

\[ \tau = RC = (2000)(50\times 10^{-6}) = 0.1\;\text{s}. \]

Final value is \( v_{\text{ss}}=5\,\text{V} \). Thus,

\[ v_c(t) = 5\left(1-e^{-t/0.1}\right),\quad t \ge 0. \]

For 90%: \( v_c(t_{0.9})=0.9\cdot 5 \Rightarrow 0.9=1-e^{-t_{0.9}/0.1} \Rightarrow e^{-t_{0.9}/0.1}=0.1 \).

\[ t_{0.9} = -0.1\ln(0.1) \approx 0.1(2.3026)=0.23026\;\text{s}. \]

Problem 4 (Estimating \( \tau \) from a single measurement):
A first-order system with zero initial condition responds to a unit step and reaches 55% of its final value at \( t=0.8 \) s. Estimate \( \tau \).

Solution: For \( y(t)=y_{\text{ss}}(1-e^{-t/\tau}) \), the fraction is \( \alpha=0.55 \). Using \( t_\alpha=-\tau\ln(1-\alpha) \):

\[ 0.8 = -\tau\ln(1-0.55) = -\tau\ln(0.45) \;\;\Longrightarrow\;\; \tau = \frac{0.8}{-\ln(0.45)}. \]

Numerically, \( -\ln(0.45)\approx 0.7985 \), so \( \tau \approx 0.8/0.7985 \approx 1.0019 \) s.

Problem 5 (Monotonicity and absence of overshoot):
Assume \( \tau > 0 \) and a constant input \( u(t)=A \) for \( t \ge 0 \). Prove that if \( y_0 \le KA \), then \( y(t) \) is monotone nondecreasing for all \( t \ge 0 \).

Solution: Using the general solution \( y(t)=KA+(y_0-KA)e^{-t/\tau} \), differentiate:

\[ \frac{dy}{dt} = \frac{(KA-y_0)}{\tau}e^{-t/\tau}. \]

Since \( e^{-t/\tau} > 0 \) for all \( t \ge 0 \) and \( \tau > 0 \), the sign of \( dy/dt \) is the sign of \( KA-y_0 \). If \( y_0 \le KA \), then \( KA-y_0 \ge 0 \) and therefore \( dy/dt \ge 0 \) for all \( t \ge 0 \). Hence \( y(t) \) is monotone nondecreasing and cannot overshoot its limit \( KA \).

We established the canonical first-order model \( \tau \dot{y}+y=Ku \), derived the step response in closed form, and proved core properties that define first-order transient behavior: exponential decay of the steady-state error, the 63.2% interpretation of \( \tau \), monotonicity under standard parameter conditions, and the general time-to-reach formula \( t_\alpha=-\tau\ln(1-\alpha) \). We then connected \( \tau \) to physical parameters in electrical, thermal, and fluid systems, and implemented both continuous-time and exact discrete-time simulations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.