For a causal, stable, single-input single-output (SISO) LTI system excited by a standard test input (typically a unit step), the transient response is the portion of the output that evolves from the initial condition until the output is acceptably close to its steady-state value.

In this lesson we consider the unit step response \( c(t) \) of a standard second-order system and define:

• Rise time \( t_r \): time for the response to rise from a low percentage of its final value to a high percentage (e.g. from \(10\% \) to \(90\%\), or from \(0\%\) to \(100\%\) depending on the convention).
• Peak time \( t_p \): time at which the response first reaches its maximum value.
• Maximum overshoot \( M_p \): relative amount by which the response exceeds its final value at the first peak.
• Settling time \( t_s \): time after which the response remains within a specified band (e.g., \(2\%\) or \(5\%\)) around its final value.

These metrics convert abstract closed-loop dynamics into directly interpretable engineering numbers: speed (how fast the system responds) and shape (overshoot/oscillation). They are ubiquitous in servo design for robotics, mechatronics, and process control.

flowchart TD
  A["Closed-loop transfer function"] --> B["Unit step input"]
  B --> C["Time response c(t)"]
  C --> D["Extract metrics:
  tr, tp, Mp, ts"]
  D --> E["Compare with specs"]
  E --> F["Adjust controller parameters"]
  F --> A
        

From Lessons 1 and 2 of this chapter, the standard second-order closed-loop transfer function is

\[ G(s) = \frac{\omega_n^2}{s^2 + 2\zeta \omega_n s + \omega_n^2}, \quad \omega_n > 0,\; 0 < \zeta < 1, \]

where \( \omega_n \) is the (undamped) natural frequency and \( \zeta \) is the damping ratio. For a unit step input with Laplace transform \( R(s) = 1/s \), the output transform is

\[ C(s) = \frac{\omega_n^2}{s\left(s^2 + 2\zeta \omega_n s + \omega_n^2\right)}. \]

Performing a partial fraction expansion and inverse Laplace transform (using tools from Chapter 2), the time-domain step response for the underdamped case \(0 < \zeta < 1\) is

\[ c(t) = 1 - \frac{e^{-\zeta \omega_n t}}{\sqrt{1-\zeta^2}} \sin\!\Big(\omega_d t + \phi\Big), \quad t \ge 0, \]

where

\[ \omega_d = \omega_n \sqrt{1-\zeta^2}, \qquad \phi = \arctan\!\Big(\frac{\sqrt{1-\zeta^2}}{\zeta}\Big). \]

The exponential term \( e^{-\zeta \omega_n t} \) defines the decay envelope; the sinusoidal term with frequency \( \omega_d \) describes oscillations. All transient metrics we care about are ultimately determined by \( \zeta \) and \( \omega_n \).

3.1 Definitions

Let the final value of the unit step response be \( c(\infty) = 1 \), which holds for a unity-gain second-order system that is type 0 and stable. Then:

• Peak time \( t_p \): first time at which \( c(t) \) attains its maximum.
• Maximum overshoot \( M_p \): the relative height above the final value:

  \[ M_p = \frac{c(t_p) - 1}{1}. \]

3.2 Derivation of Peak Time \( t_p \)

Since the response is smooth, the peak occurs when the time derivative of \( c(t) \) vanishes: \( \frac{dc}{dt}(t_p) = 0 \) and \( \frac{d^2 c}{dt^2}(t_p) < 0 \).

Differentiating the step response,

\[ \frac{dc}{dt}(t) = \frac{e^{-\zeta \omega_n t}}{\sqrt{1-\zeta^2}} \Big( -\omega_d \cos(\omega_d t + \phi) + \zeta \omega_n \sin(\omega_d t + \phi) \Big). \]

Setting \( \frac{dc}{dt}(t_p) = 0 \) and canceling the nonzero exponential and denominator gives

\[ -\omega_d \cos(\omega_d t_p + \phi) + \zeta \omega_n \sin(\omega_d t_p + \phi) = 0. \]

Rearranging,

\[ \tan(\omega_d t_p + \phi) = \frac{\omega_d}{\zeta \omega_n} = \frac{\sqrt{1-\zeta^2}}{\zeta} = \tan(\phi). \]

Thus \( \omega_d t_p + \phi = \pi + \phi \) (the first time beyond \(t=0\) where the tangents coincide with a negative slope), which implies

\[ t_p = \frac{\pi}{\omega_d} = \frac{\pi}{\omega_n \sqrt{1-\zeta^2}}. \]

3.3 Derivation of Maximum Overshoot \( M_p \)

Evaluating \( c(t) \) at \( t = t_p \), and using \( \omega_d t_p + \phi = \pi + \phi \),

\[ \begin{aligned} c(t_p) &= 1 - \frac{e^{-\zeta \omega_n t_p}}{\sqrt{1-\zeta^2}} \sin(\omega_d t_p + \phi) \\ &= 1 - \frac{e^{-\zeta \omega_n t_p}}{\sqrt{1-\zeta^2}} \sin(\pi + \phi) \\ &= 1 + \frac{e^{-\zeta \omega_n t_p}}{\sqrt{1-\zeta^2}} \sin(\phi), \end{aligned} \]

because \( \sin(\pi + \phi) = -\sin(\phi) \). From the definition of \( \phi \),

\[ \sin(\phi) = \frac{\sqrt{1-\zeta^2}}{\sqrt{\zeta^2 + (1-\zeta^2)}} = \sqrt{1-\zeta^2}, \qquad \cos(\phi) = \zeta. \]

Hence,

\[ c(t_p) = 1 + e^{-\zeta \omega_n t_p}, \quad M_p = c(t_p) - 1 = e^{-\zeta \omega_n t_p}. \]

Substituting \( t_p = \pi / \omega_d \) and \( \omega_d = \omega_n \sqrt{1-\zeta^2} \),

\[ M_p = \exp\!\Big( -\zeta \omega_n \frac{\pi}{\omega_n \sqrt{1-\zeta^2}} \Big) = \exp\!\Big( -\frac{\zeta \pi}{\sqrt{1-\zeta^2}} \Big). \]

In percentage form,

\[ M_p(\%) = 100 \times \exp\!\Big( -\frac{\zeta \pi}{\sqrt{1-\zeta^2}} \Big). \]

This formula is central in design: specifying an admissible overshoot directly constrains the damping ratio \( \zeta \).

The settling time \( t_s \) is defined with respect to an error band around the final value. For a unit step response with steady-state value \(1\), a common definition is:

\[ |c(t) - 1| \le \delta \quad \text{for all } t \ge t_s, \]

where \( \delta = 0.02 \) for the 2% criterion and \( \delta = 0.05 \) for the 5% criterion.

For underdamped second-order systems, the oscillatory term is bounded by \(1\) in magnitude, so the envelope of the error is approximately

\[ |c(t) - 1| \lesssim \frac{e^{-\zeta \omega_n t}}{\sqrt{1-\zeta^2}}. \]

A conservative bound sets

\[ \frac{e^{-\zeta \omega_n t_s}}{\sqrt{1-\zeta^2}} = \delta. \]

Solving for \( t_s \),

\[ t_s = -\frac{1}{\zeta \omega_n} \Big( \ln(\delta) + \tfrac{1}{2}\ln(1-\zeta^2) \Big). \]

In engineering practice, one often neglects the weak dependence on \( \zeta \) inside the logarithm and uses the widely known approximations:

• 2% criterion:

  \[ t_s \approx \frac{4}{\zeta \omega_n}. \]

• 5% criterion:

  \[ t_s \approx \frac{3}{\zeta \omega_n}. \]

These formulas are especially accurate for \( 0.4 \lesssim \zeta \lesssim 0.8 \), which is a typical design range for many servo systems (including robot joint controllers).

Rise time \( t_r \) is less standardized than \( t_p \) and \( t_s \). Two common definitions are:

• 0–100% rise time: time for \( c(t) \) to go from \(0\) to the first time it reaches the final value \(1\).
• 10–90% rise time: time interval between the first instant when \( c(t) = 0.1 \) and the first instant when \( c(t) = 0.9 \).

For the 0–100% definition and an underdamped second-order system, the first time that \( c(t) = 1 \) (excluding \( t = 0 \)) occurs approximately when the sine term crosses zero:

\[ c(t) = 1 \quad \Longrightarrow \quad \sin(\omega_d t + \phi) \approx 0 \quad \Longrightarrow \quad \omega_d t_r + \phi \approx \pi. \]

Thus

\[ t_r^{(0\text{–}100\%)} \approx \frac{\pi - \phi}{\omega_d} = \frac{\pi - \arctan\!\Big(\frac{\sqrt{1-\zeta^2}}{\zeta}\Big)}{\omega_n \sqrt{1-\zeta^2}}. \]

A simpler empirical approximation widely used for \( 0.4 \lesssim \zeta \lesssim 0.8 \) is

\[ t_r^{(10\text{–}90\%)} \approx \frac{1.8}{\omega_n}. \]

In controller tuning (including many robotics libraries), such approximations allow engineers to translate a desired rise time directly into a range of acceptable natural frequencies \( \omega_n \).

The closed-loop poles of the standard second-order system are

\[ p_{1,2} = -\zeta \omega_n \pm j \omega_d = -\zeta \omega_n \pm j \omega_n \sqrt{1-\zeta^2}. \]

From these expressions we see:

• The real part \(-\zeta \omega_n\) determines the exponential decay rate; more negative values give faster decay and shorter settling time \( t_s \).
• The imaginary part \( \omega_d \) sets the oscillation frequency and thus the peak time \( t_p = \pi/\omega_d \).
• The angle of the pole relative to the negative real axis encodes the damping ratio \( \zeta \), which in turn determines the overshoot \( M_p \).

For higher-order systems dominated by a complex-conjugate pair of poles near the imaginary axis, the same formulas give good approximations to time-domain metrics, provided the remaining poles are significantly faster (more negative real parts).

In practice (and in robotics experiments), we often have sampled data \( \{(t_k, c_k)\}_{k=0}^{N} \) from a step test rather than an analytic formula. The following algorithm extracts \( t_r, t_p, M_p, t_s \) from such data.

flowchart TD
  A["Sampled response tk, ck"] --> B["Estimate final value c_inf = average of last samples"]
  B --> C["Scan for first crossing of 0.1*c_inf and 0.9*c_inf to get tr"]
  C --> D["Find maximum ck and its time tp"]
  D --> E["Compute Mp = (c_max - c_inf)/c_inf"]
  E --> F["Scan from t=0 to find smallest ts where |ck - c_inf| <= band for all later k"]
  F --> G["Return tr, tp, Mp, ts"]
        

This algorithm will be implemented in several programming languages in the next sections and can be integrated into control and robotics toolchains to automatically evaluate transient performance from simulation or experimental logs.

In Python we can either use the python-control library to generate the step response of a second-order system or implement the analytic formula directly. The following code does both and demonstrates metric extraction. Such routines can be used in robotics libraries like roboticstoolbox-python to analyze joint step responses.

import numpy as np

def second_order_step_response(t, zeta, wn):
    """
    Underdamped (0 < zeta < 1) standard second-order unit step response.
    """
    wd = wn * np.sqrt(1.0 - zeta**2)
    phi = np.arctan2(np.sqrt(1.0 - zeta**2), zeta)
    return 1.0 - (np.exp(-zeta * wn * t) / np.sqrt(1.0 - zeta**2)) * np.sin(wd * t + phi)

def transient_metrics_from_samples(t, y, band=0.02):
    """
    Compute tr (10-90%), tp, Mp, ts from sampled step response.
    t, y: 1D numpy arrays.
    band: settling band (e.g. 0.02 for 2%).
    """
    t = np.asarray(t).flatten()
    y = np.asarray(y).flatten()
    assert t.shape == y.shape

    # Estimate final value as mean of last 10% of samples
    n = len(t)
    n_tail = max(1, n // 10)
    c_inf = np.mean(y[-n_tail:])

    # Rise time: first crossing of 0.1*c_inf and 0.9*c_inf
    low = 0.1 * c_inf
    high = 0.9 * c_inf
    t10 = None
    t90 = None
    for tk, ck in zip(t, y):
        if t10 is None and ck >= low:
            t10 = tk
        if t90 is None and ck >= high:
            t90 = tk
            break
    tr = None
    if t10 is not None and t90 is not None:
        tr = t90 - t10

    # Peak time and maximum overshoot
    idx_max = np.argmax(y)
    tp = t[idx_max]
    Mp = (y[idx_max] - c_inf) / c_inf

    # Settling time using band around c_inf
    ts = t[-1]
    tol = band * abs(c_inf)
    # Scan from the beginning to find the smallest time after which all samples stay in band
    for k in range(n):
        if np.all(np.abs(y[k:] - c_inf) <= tol):
            ts = t[k]
            break

    return dict(tr=tr, tp=tp, Mp=Mp, ts=ts, c_inf=c_inf)

if __name__ == "__main__":
    # Example: zeta = 0.4, wn = 10 rad/s
    zeta = 0.4
    wn = 10.0
    t = np.linspace(0.0, 3.0, 3000)
    y = second_order_step_response(t, zeta, wn)
    metrics = transient_metrics_from_samples(t, y, band=0.02)
    print("Transient metrics:")
    for k, v in metrics.items():
        print(f"{k} = {v:.4f}")

    # Optional: verify using python-control library if installed
    try:
        import control
        sys = control.TransferFunction([wn**2], [1.0, 2.0*zeta*wn, wn**2])
        t2, y2 = control.step_response(sys, T=t)
        metrics2 = transient_metrics_from_samples(t2, y2, band=0.02)
        print("Metrics (python-control step):", metrics2)
    except ImportError:
        print("python-control not installed; skipping library-based check.")
      

In a robotics setting, the same metric function can be applied to measured joint responses (e.g. from ROS bag files) to quantify tuning quality of low-level position or velocity controllers.

The following C++ code computes the step response and transient metrics for a second-order system. Such code can be integrated into robotics frameworks (e.g. ros_control) to analyze actuator dynamics. For more complex models, linear algebra libraries like Eigen can be used, but here we work directly with scalar formulas.

#include <vector>
#include <cmath>
#include <cstddef>
#include <iostream>

struct Metrics {
    double tr;     // 10-90% rise time
    double tp;     // peak time
    double Mp;     // maximum overshoot (relative)
    double ts;     // settling time (2% band)
    double c_inf;  // final value
};

std::vector<double> secondOrderStepResponse(
    const std::vector<double>& t,
    double zeta,
    double wn)
{
    std::vector<double> y;
    y.reserve(t.size());
    double sqrt_term = std::sqrt(1.0 - zeta * zeta);
    double wd = wn * sqrt_term;
    double phi = std::atan2(sqrt_term, zeta);
    for (double tk : t) {
        double envelope = std::exp(-zeta * wn * tk);
        double s = std::sin(wd * tk + phi);
        double ck = 1.0 - (envelope / sqrt_term) * s;
        y.push_back(ck);
    }
    return y;
}

Metrics transientMetricsFromSamples(
    const std::vector<double>& t,
    const std::vector<double>& y,
    double band = 0.02)
{
    std::size_t n = t.size();
    std::size_t n_tail = std::max<std::size_t>(1, n / 10);

    // Final value as mean of last 10% samples
    double c_inf = 0.0;
    for (std::size_t i = n - n_tail; i < n; ++i) {
        c_inf += y[i];
    }
    c_inf /= static_cast<double>(n_tail);

    // Rise time (10-90%)
    double low = 0.1 * c_inf;
    double high = 0.9 * c_inf;
    double t10 = -1.0;
    double t90 = -1.0;
    for (std::size_t i = 0; i < n; ++i) {
        if (t10 < 0.0 && y[i] >= low) {
            t10 = t[i];
        }
        if (t90 < 0.0 && y[i] >= high) {
            t90 = t[i];
            break;
        }
    }
    double tr = (t10 >= 0.0 && t90 >= 0.0) ? (t90 - t10) : -1.0;

    // Peak time and Mp
    std::size_t idx_max = 0;
    for (std::size_t i = 1; i < n; ++i) {
        if (y[i] > y[idx_max]) {
            idx_max = i;
        }
    }
    double tp = t[idx_max];
    double Mp = (y[idx_max] - c_inf) / c_inf;

    // Settling time (2% band by default)
    double tol = band * std::fabs(c_inf);
    double ts = t.back();
    for (std::size_t k = 0; k < n; ++k) {
        bool inside = true;
        for (std::size_t j = k; j < n; ++j) {
            if (std::fabs(y[j] - c_inf) > tol) {
                inside = false;
                break;
            }
        }
        if (inside) {
            ts = t[k];
            break;
        }
    }

    Metrics m;
    m.tr = tr;
    m.tp = tp;
    m.Mp = Mp;
    m.ts = ts;
    m.c_inf = c_inf;
    return m;
}

int main() {
    // Example usage: zeta = 0.5, wn = 8 rad/s
    double zeta = 0.5;
    double wn = 8.0;

    std::vector<double> t;
    double t_end = 3.0;
    double dt = 0.001;
    for (double tk = 0.0; tk <= t_end + 1e-12; tk += dt) {
        t.push_back(tk);
    }

    std::vector<double> y = secondOrderStepResponse(t, zeta, wn);
    Metrics m = transientMetricsFromSamples(t, y, 0.02);

    std::cout << "tr = " << m.tr
              << ", tp = " << m.tp
              << ", Mp = " << m.Mp
              << ", ts = " << m.ts
              << std::endl;

    return 0;
}
      

In a ROS-based robot controller, such code can be invoked offline to analyze logged joint responses, or online in diagnostics nodes, to verify that the closed-loop dynamics remain within specification as loads and operating conditions change.

Java is popular in educational and industrial robotics (e.g., FRC robots using WPILib). The following class computes transient metrics for a second-order step response. Numerical linear algebra could be delegated to libraries such as Apache Commons Math; here we remain in scalar computations.

import java.util.ArrayList;
import java.util.List;

public class SecondOrderMetrics {

    public static double[] stepResponse(double[] t, double zeta, double wn) {
        double sqrtTerm = Math.sqrt(1.0 - zeta * zeta);
        double wd = wn * sqrtTerm;
        double phi = Math.atan2(sqrtTerm, zeta);
        double[] y = new double[t.length];
        for (int i = 0; i < t.length; ++i) {
            double tk = t[i];
            double envelope = Math.exp(-zeta * wn * tk);
            double s = Math.sin(wd * tk + phi);
            y[i] = 1.0 - (envelope / sqrtTerm) * s;
        }
        return y;
    }

    public static class Metrics {
        public double tr;
        public double tp;
        public double Mp;
        public double ts;
        public double cInf;
    }

    public static Metrics metricsFromSamples(double[] t, double[] y, double band) {
        int n = t.length;
        int nTail = Math.max(1, n / 10);

        // Final value
        double cInf = 0.0;
        for (int i = n - nTail; i < n; ++i) {
            cInf += y[i];
        }
        cInf /= (double) nTail;

        double low = 0.1 * cInf;
        double high = 0.9 * cInf;

        Double t10 = null;
        Double t90 = null;
        for (int i = 0; i < n; ++i) {
            if (t10 == null && y[i] >= low) {
                t10 = t[i];
            }
            if (t90 == null && y[i] >= high) {
                t90 = t[i];
                break;
            }
        }
        double tr = (t10 != null && t90 != null) ? (t90 - t10) : -1.0;

        // Peak
        int idxMax = 0;
        for (int i = 1; i < n; ++i) {
            if (y[i] > y[idxMax]) {
                idxMax = i;
            }
        }
        double tp = t[idxMax];
        double Mp = (y[idxMax] - cInf) / cInf;

        // Settling time
        double tol = band * Math.abs(cInf);
        double ts = t[n - 1];
        outer:
        for (int k = 0; k < n; ++k) {
            for (int j = k; j < n; ++j) {
                if (Math.abs(y[j] - cInf) > tol) {
                    continue outer;
                }
            }
            ts = t[k];
            break;
        }

        Metrics m = new Metrics();
        m.tr = tr;
        m.tp = tp;
        m.Mp = Mp;
        m.ts = ts;
        m.cInf = cInf;
        return m;
    }

    public static void main(String[] args) {
        double zeta = 0.6;
        double wn = 12.0;
        double dt = 0.001;
        double tEnd = 3.0;
        List<Double> tList = new ArrayList<>();
        for (double tk = 0.0; tk <= tEnd + 1e-12; tk += dt) {
            tList.add(tk);
        }
        double[] t = new double[tList.size()];
        for (int i = 0; i < t.length; ++i) {
            t[i] = tList.get(i);
        }
        double[] y = stepResponse(t, zeta, wn);
        Metrics m = metricsFromSamples(t, y, 0.02);

        System.out.println("tr = " + m.tr + ", tp = " + m.tp
                + ", Mp = " + m.Mp + ", ts = " + m.ts);
    }
}
      

Java-based robotics frameworks (such as WPILib for FRC) often expose linear plant models or empirically measured responses; transient metrics like these are used in auto-tuning utilities and characterization tools.

MATLAB and Simulink provide direct functions to compute time-domain metrics, notably step and stepinfo (Control System Toolbox). Below is an example script for a second-order system; in robotics, such scripts are common when tuning actuators using Robotics System Toolbox models.

% Parameters
zeta = 0.5;
wn   = 10;  % rad/s

% Second-order transfer function G(s) = wn^2 / (s^2 + 2*zeta*wn*s + wn^2)
num = [wn^2];
den = [1, 2*zeta*wn, wn^2];
G = tf(num, den);

% Time-domain simulation
t = 0:0.001:3;
[y, t_out] = step(G, t);

% Built-in transient metrics (2% default)
info = stepinfo(G);

fprintf('Rise time (10-90%%)    : %.4f s\n', info.RiseTime);
fprintf('Peak time             : %.4f s\n', info.PeakTime);
fprintf('Overshoot             : %.2f %%\n', info.Overshoot);
fprintf('Settling time (2%%)   : %.4f s\n', info.SettlingTime);

% Manual metrics using sampled data (similar to earlier algorithms)
band = 0.02;
c_inf = mean(y(round(0.9*length(y)):end));
low = 0.1*c_inf;
high = 0.9*c_inf;

t10 = NaN; t90 = NaN;
for k = 1:length(t_out)
    if isnan(t10) && y(k) >= low
        t10 = t_out(k);
    end
    if isnan(t90) && y(k) >= high
        t90 = t_out(k);
        break;
    end
end
tr = t90 - t10;

[~, idx_max] = max(y);
tp = t_out(idx_max);
Mp = (y(idx_max) - c_inf) / c_inf;

tol = band * abs(c_inf);
ts = t_out(end);
for k = 1:length(t_out)
    if all(abs(y(k:end) - c_inf) <= tol)
        ts = t_out(k);
        break;
    end
end

fprintf('\nManual computation:\n');
fprintf('tr = %.4f, tp = %.4f, Mp = %.4f, ts = %.4f\n', tr, tp, Mp, ts);

% In Simulink, a second-order plant block and a Step block can be used,
% and "Scope" or "To Workspace" block can provide y(t) for the same metrics.
      

In Simulink, a typical workflow is to connect a second-order plant (or a more detailed robot joint model) to a controller and use a Step block as an input. The output is logged to the workspace and then passed through a metric-computation script similar to the above.

Mathematica provides symbolic and numeric capabilities for LTI systems via functions like TransferFunctionModel and OutputResponse. The following code computes and analyzes the second-order step response.

(* Parameters *)
zeta = 0.4;
wn   = 15.0;

G = TransferFunctionModel[
  wn^2 / (s^2 + 2 zeta wn s + wn^2),
  s
];

tEnd = 2.0;
tSamples = Table[t, {t, 0, tEnd, 0.0005}];
ySamples = OutputResponse[G, UnitStep[t], tSamples];

(* Estimate final value *)
n = Length[tSamples];
nTail = Max[1, Floor[n/10]];
cInf = Mean[ Take[ySamples, -nTail] ];

(* Rise time 10-90% *)
low = 0.1 cInf;
high = 0.9 cInf;
t10 = First@Select[tSamples, (ySamples[[Position[tSamples, #][[1,1]]]] >= low) &];
t90 = First@Select[tSamples, (ySamples[[Position[tSamples, #][[1,1]]]] >= high) &];
tr = t90 - t10;

(* Peak time and overshoot *)
idxMax = First@Ordering[ySamples, -1];
tp = tSamples[[idxMax]];
Mp = (ySamples[[idxMax]] - cInf)/cInf;

(* Settling time (2% band) *)
band = 0.02;
tol = band Abs[cInf];
ts = Last[tSamples];
Do[
  If[Max[Abs[Drop[ySamples, k - 1] - cInf]] <= tol,
    ts = tSamples[[k]];
    Break[];
  ],
  {k, 1, n}
];

{ "tr" -> tr, "tp" -> tp, "Mp" -> Mp, "ts" -> ts, "cInf" -> cInf }
      

Symbolic manipulation can also be used to re-derive formulas like \( M_p = \exp\!\big(-\zeta \pi / \sqrt{1-\zeta^2}\big) \) by working directly with the analytic step response.

Problem 1 (Overshoot from Damping Ratio): A second-order system has damping ratio \( \zeta = 0.5 \). Compute its expected maximum percent overshoot \( M_p(\%) \) to a unit step.

Solution:

The percent overshoot is

\[ M_p(\%) = 100 \exp\!\Big( -\frac{\zeta \pi}{\sqrt{1-\zeta^2}} \Big). \]

For \( \zeta = 0.5 \),

\[ \sqrt{1-\zeta^2} = \sqrt{1 - 0.25} = \sqrt{0.75}, \quad \frac{\zeta \pi}{\sqrt{1-\zeta^2}} = \frac{0.5 \pi}{\sqrt{0.75}}. \]

Numerically, \( \sqrt{0.75} \approx 0.8660 \), so

\[ \frac{0.5 \pi}{0.8660} \approx \frac{1.5708}{0.8660} \approx 1.814. \]

Then

\[ M_p(\%) \approx 100 e^{-1.814} \approx 100 \times 0.163 \approx 16.3\%. \]

Problem 2 (Settling Time Approximation): A feedback loop for a robot joint has closed-loop dynamics approximated by a second-order system with \( \zeta = 0.7 \) and \( \omega_n = 12 \,\text{rad/s} \). Estimate the 2\% settling time \( t_s \) using the standard engineering formula.

Solution:

The 2\% settling time approximation is

\[ t_s \approx \frac{4}{\zeta \omega_n}. \]

Substituting \( \zeta = 0.7 \) and \( \omega_n = 12 \),

\[ t_s \approx \frac{4}{0.7 \times 12} = \frac{4}{8.4} \approx 0.476 \,\text{s}. \]

Thus the joint should reach and stay within 2\% of its commanded position in roughly \(0.48\,\text{s}\).

Problem 3 (Finding \( \zeta \) from Overshoot Specification): You require a step response with maximum overshoot no more than \( M_p(\%) = 5\% \). Find the minimum damping ratio \( \zeta \) that satisfies this constraint.

Solution:

Starting from

\[ M_p(\%) = 100 \exp\!\Big( -\frac{\zeta \pi}{\sqrt{1-\zeta^2}} \Big) \le 5, \]

we obtain

\[ \exp\!\Big( -\frac{\zeta \pi}{\sqrt{1-\zeta^2}} \Big) \le 0.05, \quad -\frac{\zeta \pi}{\sqrt{1-\zeta^2}} \le \ln(0.05). \]

Since the left-hand side is negative, we can multiply by \(-1\) and reverse inequality:

\[ \frac{\zeta \pi}{\sqrt{1-\zeta^2}} \ge -\ln(0.05). \]

Numerically, \( -\ln(0.05) \approx 2.996 \). Thus,

\[ \frac{\zeta}{\sqrt{1-\zeta^2}} \ge \frac{2.996}{\pi} \approx 0.953. \]

Let \( x = \frac{\zeta}{\sqrt{1-\zeta^2}} \). Then \( \zeta = \frac{x}{\sqrt{1 + x^2}} \). Substituting \( x \approx 0.953 \):

\[ \zeta \approx \frac{0.953}{\sqrt{1 + 0.953^2}} = \frac{0.953}{\sqrt{1 + 0.908}} = \frac{0.953}{\sqrt{1.908}} \approx \frac{0.953}{1.381} \approx 0.69. \]

Thus a damping ratio of approximately \( \zeta \ge 0.69 \) is required to guarantee \( M_p(\%) \le 5\% \).

Problem 4 (Designing \( \omega_n \) for Rise Time): A positioning system must have a 10–90\% rise time \( t_r^{(10\text{–}90\%)} \le 0.15\,\text{s} \). Assume the damping ratio is fixed at \( \zeta = 0.6 \). Using the approximation \( t_r^{(10\text{–}90\%)} \approx 1.8 / \omega_n \), find the minimum \( \omega_n \).

Solution:

Using \( t_r^{(10\text{–}90\%)} \approx 1.8 / \omega_n \), the requirement \( 1.8 / \omega_n \le 0.15 \) implies

\[ \omega_n \ge \frac{1.8}{0.15} = 12 \,\text{rad/s}. \]

Therefore the system should be designed with \( \omega_n \ge 12\,\text{rad/s} \). For the fixed damping ratio \( \zeta = 0.6 \), this also sets the approximate 2\% settling time to \( t_s \approx 4 / (\zeta \omega_n) \approx 0.56\,\text{s} \).

Problem 5 (From Pole Location to Metrics): A closed-loop system has complex conjugate poles at \( p_{1,2} = -6 \pm j\,8 \). Approximate its damping ratio \( \zeta \), natural frequency \( \omega_n \), peak time \( t_p \), and 2\% settling time \( t_s \).

Solution:

For a second-order pair \( p_{1,2} = -\zeta \omega_n \pm j \omega_d \), we have

\[ \zeta \omega_n = 6, \quad \omega_d = 8, \quad \omega_n = \sqrt{(\zeta \omega_n)^2 + \omega_d^2} = \sqrt{6^2 + 8^2} = 10. \]

Hence \( \omega_n = 10 \) and

\[ \zeta = \frac{\zeta \omega_n}{\omega_n} = \frac{6}{10} = 0.6. \]

The peak time is

\[ t_p = \frac{\pi}{\omega_d} = \frac{\pi}{8} \approx 0.393\,\text{s}. \]

The 2\% settling time is

\[ t_s \approx \frac{4}{\zeta \omega_n} = \frac{4}{0.6 \times 10} = \frac{4}{6} \approx 0.667\,\text{s}. \]

These values fully characterize the main transient features of the step response for this dominant pole pair.

In this lesson we:

• Defined key transient metrics (rise time, peak time, maximum overshoot, settling time) for second-order step responses.
• Derived closed-form relations between these metrics and the damping ratio \( \zeta \) and natural frequency \( \omega_n \), including \( M_p = \exp\!\big(-\zeta \pi / \sqrt{1-\zeta^2}\big) \), \( t_p = \pi / (\omega_n \sqrt{1-\zeta^2}) \), and \( t_s \approx 4 / (\zeta \omega_n) \).
• Linked transient metrics to closed-loop pole locations \( p_{1,2} = -\zeta \omega_n \pm j \omega_d \).
• Presented language-agnostic algorithms and implementations (Python, C++, Java, MATLAB/Simulink, Mathematica) to compute these metrics from sampled step responses, with emphasis on robotics and servo applications.

These tools allow control engineers to translate qualitative performance requirements into precise constraints on closed-loop pole locations and controller parameters. Subsequent lessons will examine how additional poles and zeros alter these metrics and how dominant pole approximations are used in higher-order systems.