Throughout Chapter 5 we use the standard first-order transfer function (typically representing a closed-loop or effective dynamics from input to output)

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

where \( K \) is the (static) gain and \( \tau \) is the time constant with units of time. For a unit step input \( u(t) = 1 \) for \( t \ge 0 \), the output \( y(t) \) is (from Lesson 2)

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

It is convenient to work with the normalized response \( y_n(t) \) defined by

\[ y_n(t) := \frac{y(t)}{K} = 1 - e^{-t/\tau}. \]

All time-domain performance metrics for first-order systems can be expressed in closed form using this simple exponential function.

Before defining individual metrics, note the following basic properties:

• Initial value: \( y(0^+) = 0 \).
• Final (steady-state) value: \( y(\infty) = K \) (from the Final Value Theorem).
• Monotonicity: for \( K > 0 \), \( y(t) \) increases monotonically towards \( K \).

The monotonicity can be checked by differentiating:

\[ \frac{dy(t)}{dt} = \frac{K}{\tau} e^{-t/\tau} > 0 \quad \text{for all } t \ge 0, \]

which implies there is no overshoot for a stable first-order system with positive gain.

flowchart TD
  A["First-order model G(s) = K / (tau s + 1)"] --> B["Compute step response y(t) = K(1 - e^(-t/tau))"]
  B --> C["Normalize: y_n(t) = y(t)/K"]
  C --> D["Define performance metrics: delay, rise, settling, steady-state error"]
  D --> E["Relate metrics to tau and design specs"]
        

Time-domain performance metrics are defined in terms of when the output reaches certain percentages of its final value. Because \( y_n(t) = 1 - e^{-t/\tau} \) is monotone, these definitions lead to unique times.

2.1 Delay Time \( t_d \)

A common definition of delay time is the time at which the response reaches 50% of its final value:

\[ y_n(t_d) = 0.5. \]

Substituting \( y_n(t) = 1 - e^{-t/\tau} \),

\[ 1 - e^{-t_d/\tau} = 0.5 \quad \Longrightarrow \quad e^{-t_d/\tau} = 0.5. \]

Taking natural logarithms:

\[ -\frac{t_d}{\tau} = \ln(0.5) \quad \Longrightarrow \quad t_d = -\tau \ln(0.5) \approx 0.693\, \tau. \]

Hence, delay time is directly proportional to the time constant \( \tau \).

2.2 Rise Time \( t_r \)

The rise time is commonly defined as the time required for the response to rise from 10% to 90% of the final value. For a first-order system:

• Let \( t_{10} \) satisfy \( y_n(t_{10}) = 0.1 \).
• Let \( t_{90} \) satisfy \( y_n(t_{90}) = 0.9 \).

For a generic percentage \( p \in (0,1) \),

\[ y_n(t_p) = p \quad \Longrightarrow \quad 1 - e^{-t_p/\tau} = p \quad \Longrightarrow \quad e^{-t_p/\tau} = 1 - p. \]

Therefore

\[ t_p = -\tau \ln(1 - p). \]

Applying this with \( p = 0.1 \) and \( p = 0.9 \),

\[ t_{10} = -\tau \ln(0.9), \qquad t_{90} = -\tau \ln(0.1). \]

Hence the 10–90 rise time is

\[ t_r = t_{90} - t_{10} = \tau \Bigl[\ln\!\bigl(0.9\bigr) - \ln\!\bigl(0.1\bigr)\Bigr] = \tau \ln\!\Bigl(\frac{0.9}{0.1}\Bigr) = \tau \ln(9) \approx 2.197\, \tau. \]

The key observation is that for first-order systems, rise time is proportional to the time constant, with a proportionality constant determined by the chosen percentage values (10–90% in this case).

The settling time is the time after which the output remains within a prescribed error band around its final value, and does not leave that band. For first-order systems the band is usually symmetric, e.g., a 2% or 5% band.

3.1 General Definition

For a given tolerance \( \delta \in (0,1) \), the settling time \( t_s(\delta) \) is

\[ t_s(\delta) := \inf \left\{ t \ge 0 \; \bigg|\; \bigl|y(\lambda) - K\bigr| \le \delta |K| \text{ for all } \lambda \ge t \right\}. \]

Using the normalized response and \( K > 0 \),

\[ \bigl|y(\lambda) - K\bigr| = K e^{-\lambda/\tau}, \quad \text{so we need} \quad K e^{-\lambda/\tau} \le \delta K. \]

Cancel \( K \) and solve the inequality

\[ e^{-\lambda/\tau} \le \delta. \]

Taking natural logarithms, and using the fact that \( \ln(\delta) < 0 \) for \( 0 < \delta < 1 \),

\[ -\frac{\lambda}{\tau} \le \ln(\delta) \quad \Longrightarrow \quad \lambda \ge -\tau \ln(\delta). \]

Therefore,

\[ t_s(\delta) = -\tau \ln(\delta). \]

3.2 Common Numerical Values

Two standard tolerances are:

• \( \delta = 0.05 \) (5% band),
• \( \delta = 0.02 \) (2% band).

For \( \delta = 0.05 \):

\[ t_s(0.05) = -\tau \ln(0.05) \approx 2.996\, \tau \approx 3 \tau. \]

For \( \delta = 0.02 \):

\[ t_s(0.02) = -\tau \ln(0.02) \approx 3.912\, \tau \approx 4 \tau. \]

Hence the widely used design rule:

• For a 2% settling time, one can approximate \( t_s \approx 4 \tau \).
• For a 5% settling time, one can approximate \( t_s \approx 3 \tau \).

For robotics and servo systems, these approximations allow quick back-of-the-envelope design: if a joint position must settle within 2% in \( 0.2 \,\text{s} \), then \( \tau \approx 0.05 \,\text{s} \).

In closed-loop control, we are often interested in how accurately the output tracks a reference input. For now, consider a unity-feedback configuration with first-order plant and proportional gain \( K_c > 0 \):

\[ G_p(s) = \frac{K}{\tau s + 1}, \quad C(s) = K_c, \]

and the standard loop: controller \( C(s) \), plant \( G_p(s) \), unity feedback.

The closed-loop transfer function from reference \( R(s) \) to output \( Y(s) \) is

\[ T(s) = \frac{C(s)G_p(s)}{1 + C(s)G_p(s)} = \frac{K_c K}{\tau s + 1 + K_c K}. \]

For a unit step reference \( R(s) = 1/s \), the closed-loop output is

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

4.1 Steady-State Output and Error

Using the Final Value Theorem (assuming stability),

\[ y(\infty) = \lim_{t \rightarrow \infty} y(t) = \lim_{s \rightarrow 0} s Y(s) = \lim_{s \rightarrow 0} \frac{K_c K}{\tau s + 1 + K_c K} = \frac{K_c K}{1 + K_c K}. \]

The steady-state error for a unit step reference is defined as

\[ e_{ss} := \lim_{t \rightarrow \infty} \bigl(1 - y(t)\bigr) = 1 - y(\infty) = 1 - \frac{K_c K}{1 + K_c K} = \frac{1}{1 + K_c K}. \]

Thus:

• Increasing the loop gain \( K_c K \) reduces the steady-state error.
• As \( K_c K \rightarrow \infty \), \( e_{ss} \rightarrow 0 \).

Note that the time-domain speed of the response is primarily governed by the effective time constant

\[ \tau_{\mathrm{cl}} = \frac{\tau}{1 + K_c K}, \]

as can be seen by rewriting \( T(s) = K_{\mathrm{cl}} / (\tau_{\mathrm{cl}} s + 1) \) with \( K_{\mathrm{cl}} = K_c K / (1 + K_c K) \).

Therefore, increasing gain simultaneously:

• reduces steady-state error, and
• reduces the closed-loop time constant, making the response faster.

In later chapters (second-order systems and stability margins), we will see that excessively large gain can cause oscillatory behaviour and loss of robustness. For a pure first-order model, however, increasing gain only accelerates the monotone exponential response.

The analytical relationships derived above allow direct translation of time-domain requirements into bounds on the time constant \( \tau \) and gain products \( K_c K \). For a desired 2% settling time \( t_s^{\star} \), we have

\[ t_s^{\star} \approx 4 \tau_{\mathrm{cl}} = 4 \frac{\tau}{1 + K_c K}, \]

hence

\[ 1 + K_c K \approx \frac{4 \tau}{t_s^{\star}}. \]

At the same time, a bound on the step steady-state error yields

\[ e_{ss} = \frac{1}{1 + K_c K} \le e_{\max} \quad \Longrightarrow \quad K_c K \ge \frac{1}{e_{\max}} - 1. \]

Combining these constraints produces a feasible range for \( K_c K \). This is fundamental in early-stage controller tuning for robotics actuators modeled as first-order systems.

flowchart TD
  R["Start with time spec: t_s*, t_r*, e_ss*"] --> CLT["Compute desired closed-loop tau_cl from t_s*"]
  CLT --> GAINR["Infer required gain product Kc*K from tau_cl"]
  R --> ERR["Compute gain lower bound from e_ss*"]
  GAINR --> FEAS["Check overlap of gain constraints"]
  ERR --> FEAS
  FEAS --> DEC["If feasible: implement controller and test step response"]
        

In this lab section we implement the first-order performance metrics in several programming environments, oriented toward control and robotics applications. We consider the normalized first-order system

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

and compute analytic metrics as well as sampled step responses.

6.1 Python – Using python-control and numpy

import numpy as np
import matplotlib.pyplot as plt
from control import tf, step_response  # python-control library

def first_order_metrics(K, tau, tol=0.02):
    # delay time (50%), rise time (10-90%), settling time (tol)
    t_d = -tau * np.log(0.5)
    t_r = tau * np.log(9.0)  # 10-90%
    t_s = -tau * np.log(tol)
    return t_d, t_r, t_s

# Example: simple velocity loop of a robotic joint
K = 2.0
tau = 0.1  # seconds

# Define transfer function G(s) = K / (tau s + 1)
G = tf([K], [tau, 1.0])

# Step response
t = np.linspace(0, 1.0, 1000)
t_out, y_out = step_response(G, T=t)

t_d, t_r, t_s = first_order_metrics(K=K, tau=tau, tol=0.02)
print("Delay time t_d =", t_d)
print("Rise time t_r (10-90%) =", t_r)
print("Settling time t_s (2%) =", t_s)

plt.figure()
plt.plot(t_out, y_out, label="step response")
plt.axhline(K, linestyle="--", label="final value")
plt.axvline(t_d, linestyle=":", label="t_d")
plt.axvline(t_r, linestyle=":", label="t_r")
plt.axvline(t_s, linestyle=":", label="t_s (2%)")
plt.xlabel("t [s]")
plt.ylabel("y(t)")
plt.legend()
plt.grid(True)
plt.show()
      

In a robotics context, python-control can be combined with ROS (Robot Operating System) nodes to design and verify linear models for low-level joint control before deployment.

6.2 C++ – Using Eigen and Simple Simulation Loop

For a first-order system, an explicit simulation using Euler or higher-order integration is straightforward. Below, we use an analytical formula together with discrete time samples.

#include <iostream>
#include <cmath>

// First-order metrics for step response
struct Metrics {
    double t_delay;
    double t_rise;
    double t_settle;
};

Metrics firstOrderMetrics(double tau, double tol) {
    Metrics m;
    m.t_delay = -tau * std::log(0.5);       // 50%
    m.t_rise = tau * std::log(9.0);         // 10-90%
    m.t_settle = -tau * std::log(tol);      // tol band
    return m;
}

int main() {
    double K = 2.0;
    double tau = 0.1;
    double dt = 0.001;
    double T_final = 1.0;

    Metrics m = firstOrderMetrics(tau, 0.02);
    std::cout << "Delay time t_d = " << m.t_delay << std::endl;
    std::cout << "Rise time t_r = " << m.t_rise << std::endl;
    std::cout << "Settling time t_s = " << m.t_settle << std::endl;

    // Sample analytical response y(t) = K(1 - exp(-t/tau))
    for (double t = 0.0; t <= T_final; t += dt) {
        double y = K * (1.0 - std::exp(-t / tau));
        // This loop could be integrated into robot joint control simulation
        // using libraries like ROS control_toolbox in a larger framework.
    }
    return 0;
}
      

In practice, typed linear algebra libraries like Eigen are combined with ROS and control_toolbox for more complex higher-order models, but first-order metrics remain the base intuition.

6.3 Java – Using Apache Commons Math

public class FirstOrderMetrics {

    public static class Metrics {
        public double tDelay;
        public double tRise;
        public double tSettle;
    }

    public static Metrics computeMetrics(double tau, double tol) {
        Metrics m = new Metrics();
        m.tDelay = -tau * Math.log(0.5);
        m.tRise = tau * Math.log(9.0);
        m.tSettle = -tau * Math.log(tol);
        return m;
    }

    public static double stepResponse(double K, double tau, double t) {
        return K * (1.0 - Math.exp(-t / tau));
    }

    public static void main(String[] args) {
        double K = 2.0;
        double tau = 0.1;
        Metrics m = computeMetrics(tau, 0.02);
        System.out.println("Delay time t_d = " + m.tDelay);
        System.out.println("Rise time t_r = " + m.tRise);
        System.out.println("Settling time t_s = " + m.tSettle);

        double dt = 0.001;
        double Tfinal = 1.0;
        for (double t = 0.0; t <= Tfinal; t += dt) {
            double y = stepResponse(K, tau, t);
            // In a Java-based robotics framework (e.g., some FRC or custom),
            // y could represent the predicted output for a joint or wheel.
        }
    }
}
      

6.4 MATLAB / Simulink

K = 2.0;
tau = 0.1;

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

% Step response
t = 0:0.001:1.0;
[y, t_out] = step(G, t);

% Performance metrics
t_delay = -tau * log(0.5);
t_rise  = tau * log(9.0);    % 10-90%
t_settle_2 = -tau * log(0.02);

fprintf('t_d   = %f s\n', t_delay);
fprintf('t_r   = %f s\n', t_rise);
fprintf('t_s2%% = %f s\n', t_settle_2);

figure;
plot(t_out, y); hold on;
yline(K, '--', 'Final value');
xline(t_delay, ':', 't_d');
xline(t_rise, ':', 't_r');
xline(t_settle_2, ':', 't_s 2%%');
grid on;
xlabel('t [s]');
ylabel('y(t)');

% Simulink implementation:
% - Use a "Step" block with amplitude 1.
% - Use a "Transfer Fcn" block with numerator [K] and denominator [tau 1].
% - Use "Scope" or "To Workspace" blocks to visualize y(t).
      

6.5 Wolfram Mathematica

K = 2.0;
tau = 0.1;

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

tDelay = -tau Log[0.5];
tRise = tau Log[9.0];
tSettle2 = -tau Log[0.02];

Print["t_d   = ", tDelay];
Print["t_r   = ", tRise];
Print["t_s2% = ", tSettle2];

Plot[y[t], {t, 0, 1},
  AxesLabel -> {"t", "y(t)"},
  Epilog -> {
    Dashed, Line[{ {0, K}, {1, K} }],
    Red, Dashed, Line[{ {tDelay, 0}, {tDelay, K} }],
    Blue, Dashed, Line[{ {tRise, 0}, {tRise, K} }],
    Green, Dashed, Line[{ {tSettle2, 0}, {tSettle2, K} }]
  }
]
      

Mathematica is particularly convenient for symbolic manipulations (e.g., deriving metrics for more complicated transfer functions) as we will need in later chapters.

Problem 1 (Delay, Rise, and Settling Times): Consider a first-order system \( G(s) = \dfrac{K}{\tau s + 1} \) with \( K = 3 \) and \( \tau = 0.2 \,\text{s} \). Compute: (a) the delay time \( t_d \), (b) the 10–90 rise time \( t_r \), (c) the 2% settling time \( t_s \).

Solution:

Using the derived formulas:

\[ t_d = -\tau \ln(0.5), \quad t_r = \tau \ln(9), \quad t_s = -\tau \ln(0.02). \]

Substitute \( \tau = 0.2 \):

\[ t_d = -0.2 \ln(0.5) \approx 0.2 \times 0.693 = 0.1386 \,\text{s}, \] \[ t_r = 0.2 \ln(9) \approx 0.2 \times 2.197 = 0.4394 \,\text{s}, \] \[ t_s = -0.2 \ln(0.02) \approx 0.2 \times 3.912 = 0.7824 \,\text{s}. \]

Note that all three metrics are directly proportional to the time constant.

Problem 2 (Monotonicity and Overshoot): Show that the first-order step response \( y(t) = K(1 - e^{-t/\tau}) \) has zero percent overshoot for \( K > 0 \) and \( \tau > 0 \).

Solution:

First, note that the final value is \( y(\infty) = K \). The percent overshoot is defined as

\[ M_p = \frac{\max_{t \ge 0} y(t) - y(\infty)}{y(\infty)} \times 100\%. \]

We compute the derivative:

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

For \( K > 0 \) and \( \tau > 0 \), we have \( \frac{K}{\tau} > 0 \) and \( e^{-t/\tau} > 0 \) for all \( t \ge 0 \). Hence \( dy(t)/dt > 0 \), so \( y(t) \) is strictly increasing and achieves its maximum only in the limit \( t \rightarrow \infty \), where \( y(\infty) = K \). Thus

\[ \max_{t \ge 0} y(t) = y(\infty) = K \quad \Longrightarrow \quad M_p = 0\%. \]

Problem 3 (Design for Settling Time in Robotics): A robotic joint position loop can be approximated by the first-order transfer function \( G(s) = \dfrac{K}{\tau s + 1} \) with fixed \( \tau = 0.05 \,\text{s} \). You require a 2% settling time \( t_s^{\star} = 0.1 \,\text{s} \) for the closed-loop. Assuming a unity-feedback loop with proportional controller \( C(s) = K_c \), find the necessary gain product \( K_c K \) under the approximation \( t_s \approx 4 \tau_{\mathrm{cl}} \).

Solution:

The closed-loop time constant is \( \tau_{\mathrm{cl}} = \tau/(1 + K_c K) \). The 2% settling time is approximated as \( t_s \approx 4 \tau_{\mathrm{cl}} \), so

\[ t_s^{\star} \approx 4 \frac{\tau}{1 + K_c K} \quad \Longrightarrow \quad 1 + K_c K \approx \frac{4 \tau}{t_s^{\star}}. \]

Substitute \( \tau = 0.05 \,\text{s} \) and \( t_s^{\star} = 0.1 \,\text{s} \):

\[ 1 + K_c K \approx \frac{4 \times 0.05}{0.1} = 2, \quad \Rightarrow \quad K_c K \approx 1. \]

Thus the controller gain magnitude should be tuned so that the product \( K_c K \) is approximately 1. Additional constraints (e.g., maximum torque) would further limit feasible gains.

Problem 4 (Steady-State Error Constraint): For the same robotic joint as Problem 3, suppose instead that the required steady-state error to a unit step reference is \( e_{ss} \le 0.01 \). What bound does this impose on \( K_c K \)? Is it compatible with the gain found in Problem 3?

Solution:

For a unity-feedback first-order system with proportional control:

\[ e_{ss} = \frac{1}{1 + K_c K}. \]

The constraint \( e_{ss} \le 0.01 \) implies

\[ \frac{1}{1 + K_c K} \le 0.01 \quad \Longrightarrow \quad 1 + K_c K \ge 100 \quad \Longrightarrow \quad K_c K \ge 99. \]

This requirement clashes with the gain \( K_c K \approx 1 \) computed from the settling-time constraint in Problem 3. Hence, the performance requirements \( t_s^{\star} = 0.1 \,\text{s} \) and \( e_{ss} \le 0.01 \) cannot both be satisfied by a simple first-order proportional controller with \( \tau = 0.05 \,\text{s} \). More advanced control strategies (e.g., integral action) will be needed in later chapters.

Problem 5 (General \( p\% \)-Band Settling Time): For a first-order system \( G(s) = \dfrac{K}{\tau s + 1} \), derive the formula for the settling time corresponding to a generic \( p\% \) band, i.e., the time after which \( |y(t) - K| \le \frac{p}{100} |K| \).

Solution:

The normalized error is \( |y(t) - K| = K e^{-t/\tau} \). The \( p\% \)-band requirement is

\[ K e^{-t/\tau} \le \frac{p}{100} K \quad \Longrightarrow \quad e^{-t/\tau} \le \frac{p}{100}. \]

Taking logarithms:

\[ -\frac{t}{\tau} \le \ln\!\Bigl(\frac{p}{100}\Bigr) \quad \Longrightarrow \quad t \ge -\tau \ln\!\Bigl(\frac{p}{100}\Bigr). \]

Therefore, the \( p\% \)-band settling time is

\[ t_s(p\%) = -\tau \ln\!\Bigl(\frac{p}{100}\Bigr). \]

Setting \( p = 5 \) and \( p = 2 \) recovers the standard values discussed earlier.

In this lesson we exploited the simple exponential form of the first-order step response to derive precise expressions for key time-domain performance metrics: delay time, rise time, and settling time. We showed that all of these are proportional to the time constant and that the first-order response is strictly monotone with zero overshoot. We also derived the steady-state error of a unity-feedback proportional loop, linking gain selection simultaneously to speed (via the closed-loop time constant) and accuracy (via the steady-state error). Finally, we implemented these metrics computationally in Python, C++, Java, MATLAB/Simulink, and Mathematica, preparing the ground for more complex second-order and higher-order analyses in the next chapter.