For a single-input single-output (SISO) LTI system with input \( u(t) \) and output \( y(t) \), the Laplace-domain description is

\[ G(s) = \frac{Y(s)}{U(s)}, \quad s \in \mathbb{C}. \]

The time-domain response to a given input follows from the inverse Laplace transform:

\[ y(t) = \mathcal{L}^{-1}\{G(s)U(s)\}(t), \quad t \ge 0. \]

The same system admits a frequency-domain description by restricting \( s \) to the imaginary axis. For a sinusoidal input of frequency \( \omega \),

\[ G(j\omega) = G(s)\big|_{s=j\omega} = |G(j\omega)| e^{j\varphi(\omega)}, \]

where \( |G(j\omega)| \) is the steady-state gain and \( \varphi(\omega) \) the phase lag. The steady-state output to \( u(t)=A\sin(\omega t) \) is \( y_{\text{ss}}(t)=A|G(j\omega)|\sin(\omega t+\varphi(\omega)) \).

In feedback, with unity feedback and loop transfer function \( L(s) = G(s) \), the closed-loop transfer function from reference \( r(t) \) to output \( y(t) \) is

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

Both the step response \( y(t) \) and the sinusoidal steady-state response \( T(j\omega) \) are determined by the same pole–zero structure of \( T(s) \). This is why we can relate time-domain specifications directly to frequency-domain properties.

flowchart TD
  A["Physical system + controller"] --> B["Closed-loop model T(s)"]
  B --> C["Time view: y(t) from step, impulse, etc."]
  B --> D["Frequency view: T(j*omega) gain + phase"]
  C --> E["Specs: tr, ts, Mp, steady-state error"]
  D --> F["Specs: Mr, wr, bandwidth, phase lag"]
  E --> G["Design/update controller"]
  F --> G
        

Many well-designed feedback systems (e.g., robot joint servos, DC motor speed loops) can be accurately approximated by a dominant second-order closed-loop model:

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

The poles are

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

For a unit step input \( r(t)=1(t) \) and \( 0 < \zeta < 1 \), the step response is

\[ y(t) = 1 - \frac{1}{\sqrt{1-\zeta^2}} e^{-\zeta\omega_n t} \sin\!\big(\omega_d t + \phi\big), \quad \phi = \arctan\!\left(\frac{\sqrt{1-\zeta^2}}{\zeta}\right). \]

From this expression, classical time-domain performance indices follow:

• Peak time:

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

• Maximum overshoot \( M_p \):

  \[ M_p = e^{-\frac{\zeta\pi}{\sqrt{1-\zeta^2}}}, \quad \text{often expressed as } M_p(\%) = 100 M_p. \]

• Settling time (2% criterion, widely used in control):

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

• Rise time (10%–90%), approximate empirical fit for moderate damping \( 0.3 \lesssim \zeta \lesssim 0.8 \):

  \[ t_r \approx \frac{1.8 - 0.9\zeta}{\omega_n}. \]

All these quantities are functions only of the damping ratio \( \zeta \) and the natural frequency \( \omega_n \), which will also control the frequency-domain shape of \( T(j\omega) \).

Evaluating the closed-loop transfer function on the imaginary axis gives

\[ T(j\omega) = \frac{\omega_n^2}{-\omega^2 + \omega_n^2 + j 2\zeta\omega_n\omega}. \]

The squared magnitude (normalized with \( u = \omega / \omega_n \)) is

\[ |T(j\omega)|^2 = \frac{1}{\big(1-u^2\big)^2 + \big(2\zeta u\big)^2}, \quad u = \frac{\omega}{\omega_n}. \]

Key frequency-domain indices for the closed-loop are:

• Resonant frequency \( \omega_r \) (if it exists): frequency at which \( |T(j\omega)| \) is maximal. Differentiating \( |T(j\omega)|^2 \) with respect to \( u \) and setting to zero yields, for \( \zeta < \frac{1}{\sqrt{2}} \),

  \[ \omega_r = \omega_n \sqrt{1-2\zeta^2}. \]

• Resonant peak \( M_r = \max_{\omega\ge 0} |T(j\omega)| \). Substituting \( \omega = \omega_r \) into \( |T(j\omega)| \) gives

  \[ M_r = \frac{1}{2\zeta\sqrt{1-\zeta^2}}, \quad 0 < \zeta < \frac{1}{\sqrt{2}}. \]

  For \( \zeta \ge \frac{1}{\sqrt{2}} \) the magnitude is monotone decreasing and no resonant peak occurs (\( M_r = 1 \)).

• Closed-loop bandwidth \( \omega_B \): frequency at which the magnitude has dropped by 3 dB relative to its low-frequency value (\( |T(j\omega)| = 1/\sqrt{2} \) for unity DC gain). Using \( |T(j\omega)|^2 = 1/2 \) and the normalized form, we solve

  \[ (1-u^2)^2 + (2\zeta u)^2 = 2 \]

  which is a quadratic in \( u^2 \):

  \[ u^4 + (4\zeta^2 - 2)u^2 - 1 = 0. \]

  Solving for \( u^2 \) and taking the physically relevant positive root yields

  \[ u_B^2 = \frac{2-4\zeta^2 + \sqrt{(4\zeta^2-2)^2 + 4}}{2}, \quad \omega_B = u_B \, \omega_n. \]

The same parameters \( \zeta \) and \( \omega_n \) thus control both \( (t_r, t_s, M_p) \) and \( (M_r, \omega_r, \omega_B) \).

In design, specifications are often given in the time domain, such as maximum overshoot and settling time. We now derive explicit formulas for mapping these to \( \zeta \) and \( \omega_n \), and then to frequency metrics.

4.1 From Overshoot to Damping Ratio

Given an overshoot specification \( M_p \) (e.g., 10%), the exact relationship for a standard second-order system is

\[ M_p = e^{-\frac{\zeta\pi}{\sqrt{1-\zeta^2}}}. \]

Let \( \delta = \ln M_p \lt 0 \). Then

\[ \delta^2 = \frac{\zeta^2\pi^2}{1-\zeta^2} \quad → \quad \delta^2(1-\zeta^2) = \zeta^2\pi^2. \]

Solving for \( \zeta \) gives

\[ \zeta = -\frac{\delta}{\sqrt{\pi^2 + \delta^2}} = -\frac{\ln M_p}{\sqrt{\pi^2 + (\ln M_p)^2}}. \]

Hence we can compute \( \zeta \) directly from the permitted overshoot.

4.2 From Settling Time to Natural Frequency

Using the 2% settling time approximation,

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

For a given \( t_s \) and computed \( \zeta \) from overshoot, we obtain \( \omega_n \).

4.3 From \( \zeta, \omega_n \) to Frequency Metrics

Once \( \zeta \) and \( \omega_n \) are known, we substitute into the formulas for resonant peak, resonant frequency, and bandwidth:

\[ \omega_r = \omega_n\sqrt{1-2\zeta^2}, \quad M_r = \frac{1}{2\zeta\sqrt{1-\zeta^2}}, \]

\[ \omega_B = \omega_n \sqrt{ \frac{ 2-4\zeta^2 + \sqrt{(4\zeta^2-2)^2 + 4} }{2} }. \]

This yields an explicit mapping \( (M_p, t_s) \mapsto (\zeta, \omega_n) \mapsto (M_r, \omega_r, \omega_B) \).

Although the formulas above are exact (for the standard second-order model), control design often relies on qualitative rules that generalize to higher-order systems:

• Bandwidth vs speed: larger \( \omega_B \) typically implies smaller rise/settling times, roughly \( t_s \sim \frac{\text{constant}}{\omega_B} \) when the closed loop is dominated by a well-damped pair of poles.
• Damping vs resonance: smaller \( \zeta \) gives smaller exponential decay in the time domain (more overshoot) and a larger resonant peak \( M_r \) in the frequency domain.
• Desired trade-off: values \( \zeta \approx 0.6 \text{--} 0.8 \) often provide a good balance: modest overshoot, relatively flat magnitude around the bandwidth, and acceptable phase lag for tracking.
• Robotics implication: for a robot joint tracking a reference with dominant frequency \( \omega_{\text{cmd}} \), it is common to choose \( \omega_B \) at least 3–5 times larger than \( \omega_{\text{cmd}} \), to avoid excessive phase lag and amplitude attenuation at the command frequency.

Consider a robot joint angle loop that must satisfy:

• Maximum overshoot: \( M_p \le 10\% \).
• Settling time (2%): \( t_s \le 0.5 \,\text{s} \).

We approximate the closed-loop as second order and compute the implied frequency-domain parameters.

6.1 Damping Ratio from Overshoot

Take \( M_p = 0.10 \). Then \( \delta = \ln(0.10) \approx -2.3026 \), and

\[ \zeta = -\frac{\delta}{\sqrt{\pi^2 + \delta^2}} \approx -\frac{-2.3026}{\sqrt{\pi^2 + 2.3026^2}} \approx 0.59. \]

6.2 Natural Frequency from Settling Time

Using \( t_s \approx 4 / (\zeta \omega_n) \) with \( t_s = 0.5 \,\text{s} \) and \( \zeta \approx 0.59 \):

\[ \omega_n \approx \frac{4}{\zeta t_s} \approx \frac{4}{0.59 \cdot 0.5} \approx 13.5 \,\text{rad/s}. \]

6.3 Frequency-Domain Indices

Using the formulas from Section 3:

• Resonant frequency

  \[ \omega_r = \omega_n\sqrt{1-2\zeta^2} \approx 13.5 \sqrt{1-2 \cdot 0.59^2} \approx 7.4 \,\text{rad/s}. \]

• Resonant peak

  \[ M_r = \frac{1}{2\zeta\sqrt{1-\zeta^2}} \approx \frac{1}{2\cdot 0.59 \cdot \sqrt{1-0.59^2}} \approx 1.05, \]

  i.e., about 0.4 dB peak.
• Bandwidth \( \omega_B \) (3 dB) from Section 3, numerically:

  \[ \omega_B \approx 15.7 \,\text{rad/s} \approx 2.5 \,\text{Hz}. \]

Thus, time specifications of \( M_p \le 10\% \) and \( t_s \le 0.5\,\text{s} \) correspond roughly to a closed-loop bandwidth of about 2.5 Hz, which then informs actuator sizing, sampling rates, and inner-loop design in robotic applications.

flowchart TD
  S["Time specs: Mp, ts"] --> Z["Compute zeta from Mp"]
  Z --> WN["Compute wn from ts"]
  WN --> F1["Compute Mr, wr, wB"]
  F1 --> DES["Check actuator limits & sensing"]
  DES --> ITER["Iterate controller gains if needed"]
        

In Python, the python-control library is widely used in robotics and mechatronics for linear control analysis. Below we:

1. Define a second-order closed-loop model with given \( \zeta, \omega_n \).
2. Compute step response and estimate \( t_s, M_p \).
3. Compute the frequency response and estimate \( M_r, \omega_B \).

import numpy as np
import control  # python-control: pip install control

# Example: design values for a robotic joint position loop
zeta = 0.6
wn = 13.5  # rad/s, roughly consistent with Section 6

# Closed-loop second-order transfer function T(s) = wn^2 / (s^2 + 2*zeta*wn*s + wn^2)
num = [wn**2]
den = [1, 2*zeta*wn, wn**2]
T = control.TransferFunction(num, den)

# --- Time-domain analysis: step response ---
t = np.linspace(0, 2.0, 1000)  # 2 seconds horizon
t, y = control.step_response(T, T=t)

# Estimate overshoot Mp and 2% settling time ts
y_final = y[-1]
peak = np.max(y)
Mp = (peak - y_final) / y_final
# Settling time: last time y is outside 2% band
idx_outside = np.where(np.abs(y - y_final) > 0.02 * np.abs(y_final))[0]
ts = t[idx_outside[-1]] if idx_outside.size > 0 else 0.0

print(f"Estimated Mp: {Mp*100:.1f}%")
print(f"Estimated ts: {ts:.3f} s")

# --- Frequency-domain analysis ---
# Frequency range around the expected bandwidth
w = np.logspace(-1, 2, 500)  # 0.1 to 100 rad/s
mag, phase, omega = control.freqresp(T, w)

# mag has shape (1,1,len(w)) for SISO, take absolute and flatten
mag = np.abs(mag.flatten())

# Resonant peak and frequency
idx_Mr = np.argmax(mag)
Mr = mag[idx_Mr]
wr = omega[idx_Mr]

# Bandwidth: frequency where |T(jw)| drops to 1/sqrt(2) of DC (assume DC gain ~1)
target = 1 / np.sqrt(2)
# Find first index where magnitude falls below target
bw_indices = np.where(mag <= target)[0]
wB = omega[bw_indices[0]] if bw_indices.size > 0 else np.nan

print(f"Mr: {Mr:.3f}, wr: {wr:.3f} rad/s, wB: {wB:.3f} rad/s")
      

In a full robotic framework (e.g., with roboticstoolbox or ROS-based controllers), the same closed-loop transfer functions arise from linearizing joint dynamics and actuator models, and time/frequency metrics can be computed with python-control for tuning.

In C++, linear control analysis for robotic systems often relies on Eigen for linear algebra and std::complex for frequency response computations. Below is a simple self-contained example:

#include <iostream>
#include <vector>
#include <complex>
#include <cmath>

int main() {
    double zeta = 0.6;
    double wn   = 13.5; // rad/s

    // Time discretization for step response simulation (Euler integration)
    double dt = 0.0005;
    double T_end = 2.0;
    int N = static_cast<int>(T_end / dt);

    std::vector<double> t(N), y(N);
    double y_val = 0.0;     // output
    double y_dot = 0.0;     // first derivative
    double u = 1.0;         // unit step

    for (int k = 0; k < N; ++k) {
        t[k] = k * dt;
        // Second-order ODE: y'' + 2*zeta*wn*y' + wn^2*y = wn^2*u
        double y_ddot = wn*wn * (u - y_val) - 2.0 * zeta * wn * y_dot;
        y_dot += dt * y_ddot;
        y_val += dt * y_dot;
        y[k] = y_val;
    }

    // Estimate overshoot and settling time (2% band)
    double y_final = y.back();
    double peak = y[0];
    for (double v : y) {
        if (v > peak) peak = v;
    }
    double Mp = (peak - y_final) / y_final;

    int last_outside = 0;
    for (int k = 0; k < N; ++k) {
        if (std::fabs(y[k] - y_final) > 0.02 * std::fabs(y_final)) {
            last_outside = k;
        }
    }
    double ts = t[last_outside];

    std::cout << "Mp = " << Mp * 100.0 << "%\n";
    std::cout << "ts = " << ts << " s\n";

    // Frequency response |T(jw)| for a range of omega
    std::vector<double> omega;
    for (double w = 0.1; w <= 100.0; w *= 1.05) {
        omega.push_back(w);
    }

    double Mr = 0.0;
    double wr = 0.0;
    double target = 1.0 / std::sqrt(2.0);
    double wB = NAN;
    bool found_bw = false;

    for (double w : omega) {
        std::complex<double> s(0.0, w);
        std::complex<double> num(wn*wn, 0.0);
        std::complex<double> den = s*s + 2.0*zeta*wn*s + wn*wn;
        std::complex<double> Tjw = num / den;
        double mag = std::abs(Tjw);

        if (mag > Mr) {
            Mr = mag;
            wr = w;
        }
        if (!found_bw && mag <= target) {
            wB = w;
            found_bw = true;
        }
    }

    std::cout << "Mr = " << Mr << ", wr = " << wr << " rad/s\n";
    std::cout << "wB (approx) = " << wB << " rad/s\n";

    return 0;
}
      

In a robotics setting (e.g., using ROS control), the same logic is used inside low-level controllers: closed-loop poles are shaped to achieve desired \( M_p, t_s \), and then the resulting bandwidth is checked against sensing and actuation limitations.

Java is used in some robotics platforms (e.g., educational robots and FIRST Robotics). We can implement the same second-order model and analyze its time/frequency behavior. Here we show a simple skeleton without external dependencies; in practice, libraries like EJML or Apache Commons Math simplify matrix and complex arithmetic.

public class SecondOrderAnalysis {

    static class Complex {
        double re, im;
        Complex(double r, double i) { re = r; im = i; }

        Complex add(Complex o) { return new Complex(re + o.re, im + o.im); }
        Complex mul(Complex o) {
            return new Complex(re*o.re - im*o.im, re*o.im + im*o.re);
        }
        Complex mul(double k) { return new Complex(k*re, k*im); }
        Complex div(Complex o) {
            double den = o.re*o.re + o.im*o.im;
            return new Complex((re*o.re + im*o.im)/den,
                               (im*o.re - re*o.im)/den);
        }
        double abs() { return Math.hypot(re, im); }
    }

    public static void main(String[] args) {
        double zeta = 0.6;
        double wn   = 13.5;

        // Time simulation parameters
        double dt = 0.001;
        double T_end = 2.0;
        int N = (int)(T_end / dt);
        double[] t = new double[N];
        double[] y = new double[N];

        double yVal = 0.0, yDot = 0.0;
        double u = 1.0;

        for (int k = 0; k < N; ++k) {
            t[k] = k * dt;
            double yDDot = wn*wn * (u - yVal) - 2.0*zeta*wn*yDot;
            yDot += dt * yDDot;
            yVal += dt * yDot;
            y[k] = yVal;
        }

        // Overshoot and settling time (2% band)
        double yFinal = y[N-1];
        double peak = y[0];
        for (double v : y) {
            if (v > peak) peak = v;
        }
        double Mp = (peak - yFinal) / yFinal;

        int lastOutside = 0;
        for (int k = 0; k < N; ++k) {
            if (Math.abs(y[k] - yFinal) > 0.02 * Math.abs(yFinal)) {
                lastOutside = k;
            }
        }
        double ts = t[lastOutside];

        System.out.printf("Mp = %.2f%%%n", Mp * 100.0);
        System.out.printf("ts = %.3f s%n", ts);

        // Frequency response: scan omega
        double Mr = 0.0;
        double wr = 0.0;
        double target = 1.0 / Math.sqrt(2.0);
        Double wB = null;

        for (double w = 0.1; w <= 100.0; w *= 1.05) {
            Complex s = new Complex(0.0, w);
            Complex num = new Complex(wn*wn, 0.0);
            Complex den = s.mul(s).add(
                           new Complex(2.0*zeta*wn, 0.0).mul(s))
                         .add(new Complex(wn*wn, 0.0));
            Complex Tjw = num.div(den);
            double mag = Tjw.abs();

            if (mag > Mr) {
                Mr = mag;
                wr = w;
            }
            if (wB == null && mag <= target) {
                wB = w;
            }
        }
        System.out.printf("Mr = %.3f, wr = %.3f rad/s%n", Mr, wr);
        System.out.printf("wB (approx) = %.3f rad/s%n", wB);
    }
}
      

Such Java-based analysis can be integrated into simulation tools for Java-driven robots, ensuring that the commanded trajectories are compatible with the closed-loop bandwidth.

MATLAB with the Control System Toolbox is a standard tool in control engineering and robotics. The following script reproduces the analysis of Section 6:

zeta = 0.6;
wn   = 13.5;  % rad/s

num = [wn^2];
den = [1 2*zeta*wn wn^2];
T = tf(num, den);

% Time-domain: step response
t = 0:0.001:2;
[y, t] = step(T, t);
y_final = y(end);
peak = max(y);
Mp = (peak - y_final)/y_final;

idx_out = find(abs(y - y_final) > 0.02*abs(y_final));
ts = t(idx_out(end));

fprintf('Mp = %.2f%%\n', Mp*100);
fprintf('ts = %.3f s\n', ts);

% Frequency-domain: frequency response
w = logspace(-1, 2, 500);  % rad/s
[mag, phase] = bode(T, w);
mag = squeeze(mag);

[Mr, idxMr] = max(mag);
wr = w(idxMr);

target = 1/sqrt(2);
idxBw = find(mag <= target, 1, 'first');
wB = w(idxBw);

fprintf('Mr = %.3f, wr = %.3f rad/s, wB = %.3f rad/s\n', Mr, wr, wB);

% For visualization:
% figure; step(T);
% figure; bode(T); grid on;  % Bode plots (dB and deg vs log w)
      

In Simulink, the same transfer function can be implemented using a Transfer Fcn block, with step input and the Frequency Response Estimator for experimental determination of \( \omega_B \), which can be compared to the theoretical formulas derived here.

Wolfram Mathematica is well-suited to exploring symbolic relationships between time- and frequency-domain metrics for second-order systems:

(* Parameters *)
zeta = 0.6;
wn   = 13.5;

(* Closed-loop transfer function *)
s =.; (* Clear any symbolic value *)
T[s_] := wn^2 / (s^2 + 2 zeta wn s + wn^2);

(* Step response *)
step = InverseLaplaceTransform[T[s]/s, s, t];
stepPlot = Plot[step, {t, 0, 2},
  PlotRange -> All,
  AxesLabel -> {"t", "y(t)"},
  PlotLabel -> "Second-order step response"
];

(* Overshoot and settling time (numeric) *)
stepFun = Function[{tt}, Evaluate[step]];
yFinal = Limit[step, t -> Infinity];
tPeak = Pi/(wn Sqrt[1 - zeta^2]);
yPeak = stepFun[tPeak];
Mp = (yPeak - yFinal)/yFinal;

(* Solve for ts where |y(t) - yFinal| = 0.02 |yFinal| *)
ts = Last@Select[
   Table[{tt, Abs[stepFun[tt] - yFinal]}, {tt, 0, 5, 0.001}],
   #[[2]] > 0.02 Abs[yFinal] &
   ][[1]];

Print["Mp = ", N[Mp*100], " %"];
Print["ts ~ ", N[ts], " s"];

(* Frequency response magnitude and phase *)
omegaVals = LogSpace[-1, 2, 300]; (* custom helper or define manually *)
Tjw[omega_] := T[I*omega];
magVals = Abs[Tjw /@ omegaVals];
phaseVals = Arg[Tjw /@ omegaVals];

(* Compute Mr, wr, and wB numerically *)
Mr = Max[magVals];
wr = omegaVals[[First@Ordering[magVals, -1]]];
target = 1/Sqrt[2];
wB = omegaVals[[First@FirstPosition[magVals, _?(# <= target & )]]];

Print["Mr = ", Mr, ", wr = ", wr, ", wB = ", wB];
      

Symbolic manipulations can reproduce the derivations of \( M_p(\zeta) \), \( M_r(\zeta) \), and \( \omega_B(\zeta, \omega_n) \), reinforcing the analytical relationships shown earlier.

Problem 1 (Resonant Peak Derivation):

For the standard second-order closed-loop transfer function \( T(s) = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2} \), derive the expressions for the resonant frequency \( \omega_r \) and resonant peak \( M_r \) in terms of \( \zeta \) and \( \omega_n \).

Solution:

With \( u = \omega / \omega_n \), the squared magnitude is

\[ |T(j\omega)|^2 = \frac{1}{(1-u^2)^2 + (2\zeta u)^2} = f(u). \]

Maximizing \( |T(j\omega)|^2 \) is equivalent to minimizing the denominator, or solving \( f'(u) = 0 \). Differentiate:

\[ f(u) = \big[(1-u^2)^2 + 4\zeta^2 u^2\big]^{-1}. \]

\[ \frac{df}{du} = -\big[(1-u^2)^2 + 4\zeta^2 u^2\big]^{-2} \cdot \frac{d}{du}\big[(1-u^2)^2 + 4\zeta^2 u^2\big]. \]

The critical points satisfy

\[ \frac{d}{du}\big[(1-u^2)^2 + 4\zeta^2 u^2\big] = 0. \]

Compute the derivative:

\[ \frac{d}{du}(1-u^2)^2 = 2(1-u^2)(-2u) = -4u(1-u^2), \]

\[ \frac{d}{du}(4\zeta^2 u^2) = 8\zeta^2 u. \]

Thus

\[ -4u(1-u^2) + 8\zeta^2 u = 0 \quad → \quad u\big[-4(1-u^2) + 8\zeta^2\big] = 0. \]

Excluding the trivial solution \( u=0 \), we obtain

\[ -4(1-u^2) + 8\zeta^2 = 0 \quad → \quad u^2 = 1 - 2\zeta^2. \]

Therefore, under \( \zeta < 1/\sqrt{2} \),

\[ \omega_r = \omega_n \sqrt{1-2\zeta^2}. \]

Substituting into \( |T(j\omega)|^2 \) gives

\[ M_r^2 = \frac{1}{\big(1-(1-2\zeta^2)\big)^2 + 4\zeta^2(1-2\zeta^2)} = \frac{1}{(2\zeta^2)^2 + 4\zeta^2(1-2\zeta^2)} = \frac{1}{4\zeta^2(1-\zeta^2)}, \]

\[ \Rightarrow \quad M_r = \frac{1}{2\zeta\sqrt{1-\zeta^2}}. \]

Problem 2 (From Time Specs to Bandwidth):

A closed-loop robotic joint must satisfy \( M_p \le 20\% \) and \( t_s \le 1 \,\text{s} \). Assume a second-order model. Compute:

1. The damping ratio \( \zeta \).
2. The natural frequency \( \omega_n \).
3. Approximate resonant peak \( M_r \) and bandwidth \( \omega_B \).

Solution:

First, \( M_p = 0.2 \), so \( \delta = \ln(0.2) \approx -1.6094 \), giving

\[ \zeta = -\frac{\delta}{\sqrt{\pi^2 + \delta^2}} \approx -\frac{-1.6094}{\sqrt{\pi^2 + 1.6094^2}} \approx 0.456. \]

The settling time condition \( t_s \approx 4 / (\zeta \omega_n) \le 1 \) implies

\[ \omega_n \gtrsim \frac{4}{\zeta t_s} = \frac{4}{0.456 \cdot 1} \approx 8.77 \,\text{rad/s}. \]

Taking \( \omega_n \approx 9 \,\text{rad/s} \) for simplicity, we compute

\[ M_r = \frac{1}{2\zeta\sqrt{1-\zeta^2}} \approx \frac{1}{2\cdot 0.456 \cdot \sqrt{1-0.456^2}} \approx 1.20 \]

(about 1.6 dB). For bandwidth, \( u_B^2 \) is

\[ u_B^2 = \frac{2-4\zeta^2 + \sqrt{(4\zeta^2-2)^2 + 4}}{2}. \]

Substituting \( \zeta \approx 0.456 \) yields \( u_B \approx 1.4 \), hence

\[ \omega_B \approx 1.4 \cdot 9 \approx 12.6 \,\text{rad/s}. \]

Thus, the time-domain specifications imply a closed-loop bandwidth of about 12–13 rad/s, which must be consistent with actuator and sensor limitations.

Problem 3 (Monotonicity of Resonant Peak):

Show that for \( 0 < \zeta < 1/\sqrt{2} \), the resonant peak \( M_r = 1/(2\zeta\sqrt{1-\zeta^2}) \) is decreasing as \( \zeta \) increases.

Solution:

Consider the squared peak \( M_r^2 = 1/(4\zeta^2(1-\zeta^2)) \). Its derivative is easier to analyze. Let

\[ g(\zeta) = 4\zeta^2(1-\zeta^2) = 4(\zeta^2 - \zeta^4), \quad M_r^2 = \frac{1}{g(\zeta)}. \]

Then

\[ g'(\zeta) = 4(2\zeta - 4\zeta^3) = 8\zeta(1-2\zeta^2). \]

For \( 0 < \zeta < 1/\sqrt{2} \), we have \( \zeta > 0 \) and \( 1-2\zeta^2 > 0 \), hence \( g'(\zeta) > 0 \) and \( g(\zeta) \) is increasing. Therefore, \( M_r^2 = 1/g(\zeta) \) is decreasing, and so is \( M_r \). Higher damping reduces the resonant peak.

Problem 4 (Bandwidth and Settling Time Approximation):

Assume a second-order system with \( \zeta \approx 0.7 \), for which \( u_B \approx 1 \). Show that the settling time can be approximated as \( t_s \approx 4 / \omega_B \).

Solution:

For \( \zeta \approx 0.7 \), we have \( \omega_B \approx \omega_n \) (the 3 dB point occurs close to \( \omega = \omega_n \) when the magnitude curve is sufficiently flat). The exact settling time approximation is

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

Replacing \( \omega_n \) by \( \omega_B \) and \( \zeta \approx 0.7 \) gives

\[ t_s \approx \frac{4}{0.7 \omega_B} \approx \frac{5.7}{\omega_B}. \]

Engineering practice often simplifies this to \( t_s \approx 4/\omega_B \), which slightly underestimates \( t_s \) but remains a useful rule-of-thumb that links time-domain speed directly to closed-loop bandwidth.

Problem 5 (Design Flowchart):

Draw a conceptual flowchart that a control engineer might follow to translate time-domain specs \( (M_p, t_s) \) into frequency-domain specs \( (M_r, \omega_B) \) for a second-order dominated system.

Solution (flowchart):

flowchart TD
  TSP["Start from time specs (Mp, ts)"] --> ZETA["Compute zeta from Mp"]
  ZETA --> WN["Compute wn from ts"]
  WN --> FREQ["Compute Mr, wr, wB from zeta, wn"]
  FREQ --> CHECK["Check against actuator/sensor limits"]
  CHECK --> ADJ["Adjust controller gains or structure if needed"]
        

In this lesson we established rigorous connections between time-domain performance indices (overshoot, settling time, rise time) and frequency-domain characteristics (resonant peak, resonant frequency, bandwidth) for second-order closed-loop systems. By expressing both sets of quantities in terms of \( \zeta \) and \( \omega_n \), we obtained an explicit mapping from design requirements in one domain to constraints in the other. These relationships are central in practical control and robotics, where engineers often specify time-domain behavior but must simultaneously respect frequency-domain limitations such as actuator bandwidth and sensor noise. In subsequent chapters (Bode, Nyquist, loop-shaping) these links provide the bridge that connects formal frequency-domain design tools to intuitive time-domain performance requirements.