In classical control, two complementary views are used to characterize and design feedback systems:

• Time domain: step and impulse responses, characterized by \( t_p \) (peak time), \( M_p \) (maximum overshoot), \( t_s \) (settling time), and steady-state error \( e_{\text{ss}} \).
• Frequency domain: magnitude and phase of \( G(j\omega) \), loop transfer \( L(j\omega) \), bandwidth, gain crossover frequency \( \omega_c \), gain margin (GM) and phase margin (PM), resonant peak \( M_r \), and resonant frequency \( \omega_r \).

For well-designed unity-feedback systems whose closed-loop behavior is dominated by a pair of complex conjugate poles, there exist approximately monotone relationships between:

• Damping ratio \( \zeta \) and overshoot \( M_p \) (time domain) versus resonant peak \( M_r \) and phase margin (frequency domain).
• Natural frequency \( \omega_n \) and settling time \( t_s \) versus bandwidth \( \omega_B \) and gain crossover frequency \( \omega_c \).

The design workflow can therefore proceed in either direction: specify time-domain constraints, translate them into frequency-domain inequalities, design using Bode/Nyquist/Nichols techniques, and finally verify the time response.

flowchart TD
  TD["Time specs: tr, tp, Mp, ts, ess"] --> P["Identify dominant 2nd order model (zeta, wn)"]
  P --> FD["Compute freq specs: Mr, wr, omega_c, omega_B, margins"]
  FD --> CD["Design controller in freq domain"]
  CD --> V["Simulate and verify time response"]
        

We assume the closed-loop transfer function from reference \( R(s) \) to output \( Y(s) \) can be approximated by a standard second-order form:

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

This model arises when the closed-loop characteristic polynomial has a dominant pair of complex conjugate poles and other poles are sufficiently fast (more negative real part).

For a unit-step input, the time response of this second-order system is known (for \( 0 < \zeta < 1 \)) to be:

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

From this expression, classical formulas for key time-domain metrics are obtained (for a unit step):

• Peak time \( t_p \):

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

• Maximum overshoot \( M_p \) (relative to final value):

  \[ M_p \;=\; e^{-\frac{\pi \zeta}{\sqrt{1-\zeta^2}}},\quad 0 < \zeta < 1. \]

• Settling time (2% criterion):

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

  obtained from the envelope \( e^{-\zeta \omega_n t} \).

These formulas will now be related to frequency-domain characteristics of \( T(j\omega) \).

The frequency response of the standard second-order system is obtained by substituting \( s = j\omega \):

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

The squared magnitude of \( T(j\omega) \) is

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

Introduce the normalized frequency \( x = \omega / \omega_n \). Then,

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

The resonant frequency \( \omega_r \) is defined (when it exists) as the frequency at which \( \big|T(j\omega)\big| \) attains its maximum (for \( 0 < \zeta < 1/\sqrt{2} \)). By differentiating the denominator with respect to \( x \) and setting the derivative to zero, one finds

\[ x_r^2 \;=\; 1 - 2\zeta^2 \quad\Rightarrow\quad \omega_r \;=\; \omega_n \sqrt{1 - 2\zeta^2}, \quad 0 < \zeta < \frac{1}{\sqrt{2}}. \]

The resonant peak \( M_r \) is then \( M_r = \big|T(j\omega_r)\big| \), which evaluates to

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

Both \( M_p \) and \( M_r \) are monotonically decreasing functions of the damping ratio \( \zeta \). Thus, prescribing a maximum allowable overshoot in the time domain (e.g. \( M_p \leq 0.1 \) or 10%) corresponds to bounding the resonant peak in the frequency domain:

\[ M_p \leq M_p^{\max} \quad \Longleftrightarrow \quad \zeta \geq \zeta_{\min} \quad \Longrightarrow \quad M_r \leq M_r(\zeta_{\min}). \]

In practice, many design guidelines impose an upper bound on \( M_r \) (e.g. \( M_r \leq 1.4 \), corresponding roughly to \( \zeta \approx 0.3 \)) in order to limit overshoot and resonant amplification of narrowband disturbances.

The closed-loop bandwidth \( \omega_B \) is conventionally defined as the frequency at which the magnitude of the closed-loop transfer function has decreased by 3 dB, i.e.,

\[ \big|T(j\omega_B)\big|^2 = \frac{1}{2}. \]

Using the normalized expression for \( \big|T(j\omega)\big|^2 \) we obtain

\[ (1 - x_B^2)^2 + (2\zeta x_B)^2 = 2, \quad x_B = \frac{\omega_B}{\omega_n}. \]

Expanding and collecting terms gives

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

Defining \( y = x_B^2 \), we obtain a quadratic equation

\[ y^2 + (-2 + 4\zeta^2) y - 1 = 0, \]

whose physically relevant positive root is

\[ y = 1 - 2\zeta^2 + \sqrt{2 - 4\zeta^2 + 4\zeta^4}, \quad x_B = \sqrt{y} = \sqrt{ 1 - 2\zeta^2 + \sqrt{2 - 4\zeta^2 + 4\zeta^4} }. \]

Thus,

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

For the practically important range \( 0.4 \lesssim \zeta \lesssim 0.8 \), we have \( \omega_B \approx \omega_n \), so the approximate relations

\[ t_s \approx \frac{4}{\zeta\, \omega_B}, \qquad t_p \approx \frac{\pi}{\omega_B \sqrt{1-\zeta^2}} \]

connect time-domain speed to bandwidth. A larger closed-loop bandwidth (higher \( \omega_B \)) implies shorter settling time and peak time, provided damping is not too small.

A frequently cited rule-of-thumb for well-damped systems (\( \zeta \approx 0.6\text{--}0.8 \)) is

\[ \omega_B t_s \approx 4 \text{ to } 6. \]

Such relations allow an engineer to translate a requirement like \( t_s \leq 1 \,\text{s} \) into a rough lower bound on closed-loop bandwidth (e.g., \( \omega_B \gtrsim 5 \,\text{rad/s} \)).

For many unity-feedback systems with a single dominant complex pole pair, the open-loop transfer function may be approximated near the gain crossover by a second-order type-1 model, for example

\[ L(s) = \frac{K \,\omega_n^2}{s\,(s^2 + 2\zeta \omega_n s + \omega_n^2)}. \]

When the closed-loop response is well approximated by the second-order model in Section 2, there is a useful approximate mapping between damping ratio \( \zeta \) and phase margin \( \text{PM} \) (in radians or degrees). One widely used approximation is

\[ \text{PM} \approx \arctan\!\Bigg( \frac{2\zeta}{\sqrt{\sqrt{1 + 4\zeta^4} - 2\zeta^2}} \Bigg), \]

valid for \( 0.1 \lesssim \zeta \lesssim 1 \). In degrees,

\[ \text{PM}_{\deg} \approx \text{PM} \cdot \frac{180}{\pi}. \]

Numerically, the correspondence is approximately:

• \( \zeta \approx 0.2 \Rightarrow \text{PM} \approx 30^\circ \)
• \( \zeta \approx 0.4 \Rightarrow \text{PM} \approx 45^\circ \)
• \( \zeta \approx 0.7 \Rightarrow \text{PM} \approx 60^\circ\text{--}70^\circ \)

Since overshoot \( M_p \) is a function of \( \zeta \), we obtain an approximate mapping \( M_p \leftrightarrow \text{PM} \). For example, requesting a maximum overshoot of 10% leads to \( \zeta \approx 0.6 \), hence an approximate requirement \( \text{PM} \gtrsim 55^\circ \).

Consider a unity-feedback system in which we assume the closed-loop is dominated by a second-order model. Suppose the design requirements are:

• Maximum overshoot: \( M_p \leq 0.1 \) (10%).
• Settling time (2%): \( t_s \leq 2 \,\text{s} \).
• Zero steady-state error to a step (type-1 loop).

Step 1: Overshoot → damping ratio. From \( M_p = e^{-\frac{\pi \zeta}{\sqrt{1-\zeta^2}}} \), we solve for \( \zeta \) given \( M_p^{\max} = 0.1 \), obtaining approximately \( \zeta_{\min} \approx 0.6 \).

Step 2: Settling time → natural frequency. Using \( t_s \approx 4 / (\zeta \omega_n) \), we require

\[ \frac{4}{\zeta \omega_n} \leq 2 \quad\Rightarrow\quad \omega_n \geq \frac{4}{2\zeta} = \frac{2}{\zeta}. \]

With \( \zeta = 0.6 \), this gives \( \omega_n \gtrsim 3.33 \,\text{rad/s} \).

Step 3: Natural frequency → bandwidth and crossover. With \( \zeta \approx 0.6 \), we have \( \omega_B \approx \omega_n \), hence \( \omega_B \gtrsim 3.3 \,\text{rad/s} \). For many unity-feedback designs, the gain crossover \( \omega_c \) is within a factor of order 1 of the bandwidth, so we obtain a rough requirement

\[ \omega_c \gtrsim 3 \,\text{rad/s}. \]

Step 4: Damping → phase margin. With \( \zeta \approx 0.6 \), the approximate mapping of Section 5 yields \( \text{PM} \approx 55^\circ\text{--}60^\circ \). Thus, the frequency-domain design specification could be stated as:

• Phase margin \( \text{PM} \geq 55^\circ \).
• Gain crossover \( \omega_c \gtrsim 3 \,\text{rad/s} \).
• Resonant peak \( M_r \lesssim 1.2\text{--}1.3 \).

Designing a controller to satisfy these frequency-domain inequalities will typically yield a closed-loop step response meeting the original time-domain overshoot and settling-time requirements.

flowchart TD
  A["Time specs: Mp_max, ts_max"] --> B["Solve for zeta_min, wn_min"]
  B --> C["Compute freq specs: omega_B_min, omega_c_min, Mr_max, PM_min"]
  C --> D["Tune controller to meet freq specs"]
  D --> E["Verify time response; iterate if needed"]
        

In Python, the python-control library (widely used in robotics education) and scipy.signal allow us to build transfer functions, compute Bode plots, and evaluate step responses. The following script illustrates the mapping from a desired phase margin and crossover frequency to approximate damping and time-domain metrics for a servo axis.

import numpy as np
import control as ctrl   # python-control library
from math import sqrt, pi

# Helper functions: zeta <-> overshoot, bandwidth, etc.
def zeta_from_Mp(Mp):
    """
    Invert Mp = exp(-pi*zeta / sqrt(1-zeta^2))
    using a simple numerical solve (Newton).
    Mp is specified as a fraction (e.g. 0.1 for 10%).
    """
    if Mp <= 0.0 or Mp >= 1.0:
        raise ValueError("Mp must be in (0,1)")
    z = 0.5  # initial guess
    for _ in range(20):
        f = np.exp(-pi*z / np.sqrt(1 - z**2)) - Mp
        df = np.exp(-pi*z / np.sqrt(1 - z**2)) * (
            (-pi / np.sqrt(1 - z**2)) +
            (-pi*z*(+z) / (1 - z**2)**(3/2))
        )
        z = z - f / df
        z = min(max(z, 1e-3), 0.999)
    return z

def Mr_from_zeta(zeta):
    if zeta >= 1/np.sqrt(2):
        return 1.0
    return 1.0 / (2*zeta*np.sqrt(1 - zeta**2))

def omega_n_from_ts(ts, zeta):
    return 4.0 / (zeta*ts)

def bandwidth_from_2nd_order(wn, zeta):
    # exact closed-form for 3 dB bandwidth
    term = np.sqrt(2 - 4*zeta**2 + 4*zeta**4)
    y = 1 - 2*zeta**2 + term
    return wn*np.sqrt(y)

# Desired time-domain specs for a robot joint servo
Mp_max = 0.1    # 10%
ts_max = 0.8    # seconds

zeta = zeta_from_Mp(Mp_max)
wn   = omega_n_from_ts(ts_max, zeta)
wB   = bandwidth_from_2nd_order(wn, zeta)
Mr   = Mr_from_zeta(zeta)

print("zeta ~", zeta)
print("wn   ~", wn)
print("omega_B ~", wB)
print("Mr   ~", Mr)

# Build an approximate closed-loop model (for verification)
T = ctrl.TransferFunction([wn**2], [1, 2*zeta*wn, wn**2])

t, y = ctrl.step_response(T)
info = ctrl.step_info(T)
print("Step info:", info)

# Bode magnitude at crossover near the bandwidth
mag, phase, omega = ctrl.bode(T, omega_limits=(0.1, 10*wB), Plot=False)
# Extract approximate -3 dB frequency
mag_db = 20*np.log10(mag)
idx = np.argmin(np.abs(mag_db + 3.0))
print("Approx -3 dB bandwidth from numeric Bode:", omega[idx])
      

In a robotics context, such a second-order approximation may correspond to a single joint of a robot arm under position control; the bandwidth and damping ratio directly influence the joint's responsiveness and overshoot when tracking angle commands.

In C++ for embedded and robotic systems, one often avoids heavy control libraries and instead implements key formulas directly, using linear algebra libraries such as Eigen for vector/matrix operations. The snippet below computes overshoot, settling time, and bandwidth for a second-order model that approximates a joint servo.

#include <iostream>
#include <cmath>

// Simple utility functions for second-order system metrics
struct SecondOrderSpecs {
    double zeta;
    double wn;
    double Mp;
    double ts;
    double Mr;
    double wB;
};

double Mr_from_zeta(double zeta) {
    if (zeta >= 1.0 / std::sqrt(2.0)) {
        return 1.0;
    }
    return 1.0 / (2.0 * zeta * std::sqrt(1.0 - zeta*zeta));
}

double bandwidth_from_2nd_order(double wn, double zeta) {
    double term = std::sqrt(2.0 - 4.0*zeta*zeta + 4.0*std::pow(zeta, 4));
    double y = 1.0 - 2.0*zeta*zeta + term;
    return wn * std::sqrt(y);
}

SecondOrderSpecs design_from_time_specs(double Mp_max, double ts_max) {
    SecondOrderSpecs s{};
    // Very coarse mapping Mp -> zeta using standard approximate formula
    // (for design code one could implement a numerical solver as in Python).
    // Here we use a simple lookup-inspired approximation:
    if (Mp_max <= 0.05)      s.zeta = 0.7;
    else if (Mp_max <= 0.10) s.zeta = 0.6;
    else if (Mp_max <= 0.20) s.zeta = 0.5;
    else                     s.zeta = 0.4;

    s.Mp = Mp_max;
    s.wn = 4.0 / (s.zeta * ts_max);
    s.ts = ts_max;
    s.Mr = Mr_from_zeta(s.zeta);
    s.wB = bandwidth_from_2nd_order(s.wn, s.zeta);
    return s;
}

int main() {
    double Mp_max = 0.1;  // 10% overshoot
    double ts_max = 0.8;  // 0.8 s

    SecondOrderSpecs s = design_from_time_specs(Mp_max, ts_max);

    std::cout << "zeta ~ " << s.zeta << "\n";
    std::cout << "wn   ~ " << s.wn   << " rad/s\n";
    std::cout << "omega_B ~ " << s.wB << " rad/s\n";
    std::cout << "Mr   ~ " << s.Mr  << "\n";

    // In a full robot control stack, these specs would guide the design
    // of a joint PID controller or state-feedback controller implemented
    // in the low-level servo loop.
    return 0;
}
      

In a robotics framework such as ros_control, these computed parameters can be used to choose PID gains or to verify that the loop bandwidth for each actuator meets the system-level performance requirements (e.g., end-effector tracking bandwidth).

Java is frequently used in educational robotics (e.g., FIRST robotics). The following class provides a minimal set of static methods for mapping overshoot and settling time to approximate bandwidth and resonant peak. Numerical methods from Apache Commons Math could be used for more accurate inversion of the transcendental relations.

public final class SecondOrderDesign {

    private SecondOrderDesign() {}

    public static double zetaFromMpApprox(double Mp) {
        // crude approximation based on typical textbook values
        if (Mp <= 0.05)      return 0.7;
        else if (Mp <= 0.1) return 0.6;
        else if (Mp <= 0.2) return 0.5;
        else                 return 0.4;
    }

    public static double mrFromZeta(double zeta) {
        if (zeta >= 1.0 / Math.sqrt(2.0)) {
            return 1.0;
        }
        return 1.0 / (2.0 * zeta * Math.sqrt(1.0 - zeta*zeta));
    }

    public static double wnFromTs(double ts, double zeta) {
        return 4.0 / (zeta * ts);
    }

    public static double bandwidthFromSecondOrder(double wn, double zeta) {
        double term = Math.sqrt(2.0 - 4.0*zeta*zeta + 4.0*Math.pow(zeta, 4));
        double y = 1.0 - 2.0*zeta*zeta + term;
        return wn * Math.sqrt(y);
    }

    public static void main(String[] args) {
        double MpMax = 0.1; // 10% overshoot
        double tsMax = 1.0; // 1 s

        double zeta = zetaFromMpApprox(MpMax);
        double wn   = wnFromTs(tsMax, zeta);
        double wB   = bandwidthFromSecondOrder(wn, zeta);
        double Mr   = mrFromZeta(zeta);

        System.out.println("zeta ~ " + zeta);
        System.out.println("wn   ~ " + wn);
        System.out.println("omega_B ~ " + wB);
        System.out.println("Mr   ~ " + Mr);

        // In a robot axis controller, these metrics can be logged
        // and compared against target bandwidth and overshoot limits.
    }
}
      

Such a class can be integrated into robot controller tuning tools or dashboards to visualize how changes in desired overshoot and speed reflect back onto required loop bandwidth and frequency margins.

MATLAB and Simulink are standard tools in control and robotics. The following script constructs a second-order closed-loop model from time-domain specs, computes Bode and step responses, and automatically reports overshoot, settling time, and bandwidth.

% Desired specs (e.g., for a robot joint position loop)
Mp_max = 0.1;   % 10% max overshoot
ts_max = 1.0;   % 1 s settling time (2% criterion)

% Approximate mapping Mp -> zeta (could be refined via fsolve)
zeta = 0.6;  % approx for 10% Mp

wn   = 4 / (zeta * ts_max);

s = tf('s');
T = wn^2 / (s^2 + 2*zeta*wn*s + wn^2);

% Time-domain analysis
info = stepinfo(T);
fprintf('Mp    = %.3f\n', info.Overshoot/100);
fprintf('ts    = %.3f s\n', info.SettlingTime);
fprintf('tp    = %.3f s\n', info.PeakTime);

% Frequency-domain analysis
[mag, phase, w] = bode(T);
mag = squeeze(mag);
mag_db = 20*log10(mag);
[~, idx] = min(abs(mag_db + 3));
omega_B = w(idx);

fprintf('omega_B ~ %.3f rad/s\n', omega_B);

% Plot for inspection
figure;
subplot(2,1,1);
step(T);
grid on; title('Closed-loop step response');

subplot(2,1,2);
bodemag(T);
grid on; title('Closed-loop magnitude response');

% In Simulink, T can be realized with Transfer Fcn blocks,
% and connected in a unity-feedback loop around a plant model
% for robot joint dynamics.
      

In Simulink, one typically uses the Linear Analysis Tool or linmod to extract a linearized model around an operating point of a robotic manipulator, derive its closed-loop transfer function, and then apply the same frequency/time-domain analysis as above.

Mathematica can handle both symbolic derivations (e.g., of \( M_r \) and \( \omega_B \)) and numeric evaluation for specific design parameters.

(* Define symbolic parameters *)
Clear[zeta, wn, s, w];
Assumptions = 0 < zeta < 1 && wn > 0;

T[s_] := wn^2/(s^2 + 2 zeta wn s + wn^2);

(* Frequency response magnitude squared *)
Tjw[w_] := T[I w] // FullSimplify[#, Assumptions] &;
mag2[w_] := ComplexExpand[Abs[Tjw[w]]^2];

(* Resonant frequency: maximize |T(jw)| *)
wrSol = w /. 
  First@NMaximize[{Sqrt[mag2[w]], w > 0}, w];
MrVal = Sqrt[mag2[wrSol]];

Print["wr ~ ", wrSol];
Print["Mr ~ ", MrVal];

(* Time-domain metrics *)
tp[z_, w0_] := Pi/(w0*Sqrt[1 - z^2]);
Mp[z_] := Exp[-Pi z/Sqrt[1 - z^2]];
ts[z_, w0_] := 4/(z w0);

(* Example numeric design *)
zetaVal = 0.6;
tsMax   = 1.0;
wnVal   = 4/(zetaVal*tsMax);

Print["Example design:"];
Print["  zeta = ", zetaVal];
Print["  wn   = ", wnVal];
Print["  Mp   ~ ", Mp[zetaVal]];
Print["  ts   ~ ", ts[zetaVal, wnVal]];

Tnum = TransferFunctionModel[wnVal^2/(s^2 + 2 zetaVal wnVal s + wnVal^2), s];
BodePlot[Tnum, {w, 0.1, 50}]
      

Symbolic manipulation can also be used to re-derive the bandwidth expression in Section 4 or to explore how uncertainties in \( \zeta \) and \( \omega_n \) affect the mapping between time- and frequency-domain metrics.

Problem 1 (Overshoot and Resonant Peak Mapping): A closed-loop system is approximated by \( T(s) = \dfrac{\omega_n^2}{s^2 + 2\zeta \omega_n s + \omega_n^2} \). Show that the resonant peak \( M_r \) and maximum overshoot \( M_p \) are both monotone decreasing functions of \( \zeta \) for \( 0 < \zeta < 1/\sqrt{2} \).

Solution:

The expressions are

\[ M_p(\zeta) = e^{-\frac{\pi \zeta}{\sqrt{1-\zeta^2}}}, \qquad M_r(\zeta) = \frac{1}{2\zeta \sqrt{1-\zeta^2}}. \]

For \( 0 < \zeta < 1 \), the exponent in \( M_p(\zeta) \) is negative and its magnitude \( \frac{\pi \zeta}{\sqrt{1-\zeta^2}} \) is strictly increasing in \( \zeta \), hence \( M_p(\zeta) \) strictly decreases.

For \( M_r(\zeta) \), differentiate with respect to \( \zeta \):

\[ \frac{dM_r}{d\zeta} = -\frac{1}{2} \frac{ \sqrt{1-\zeta^2} + \frac{\zeta^2}{\sqrt{1-\zeta^2}} }{ \zeta^2 (1-\zeta^2) } < 0 \]

for \( 0 < \zeta < 1/\sqrt{2} \). Therefore both \( M_p \) and \( M_r \) are monotone decreasing in \( \zeta \), and specifying a lower bound on \( \zeta \) simultaneously limits overshoot and resonant amplification.

Problem 2 (Bandwidth and Settling Time Trade-Off): For the second-order model, show that if \( \omega_B \approx \omega_n \) for \( 0.4 \lesssim \zeta \lesssim 0.8 \), then \( t_s \approx \dfrac{4}{\zeta \omega_B} \). Discuss qualitatively how increasing bandwidth affects settling time and noise sensitivity.

Solution:

From Section 4, we have \( t_s \approx 4 / (\zeta \omega_n) \). If for the considered range of \( \zeta \) we approximate \( \omega_B \approx \omega_n \), then substitution gives

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

Thus, larger bandwidth (larger \( \omega_B \)) implies smaller settling time, provided \( \zeta \) is kept fixed. However, higher bandwidth also increases the transmission of high-frequency measurement noise through the closed loop and can reduce robustness to unmodeled dynamics, illustrating a fundamental trade-off between speed and robustness.

Problem 3 (Phase Margin Requirement from Overshoot Spec): A unity-feedback system is designed so that its closed-loop step response has no more than 15% overshoot. Assuming a second-order dominant behavior, estimate the required phase margin.

Solution:

For 15% overshoot, the damping ratio is approximately \( \zeta \approx 0.5 \) (from standard plots of overshoot versus damping ratio). Using the approximate mapping of Section 5, \( \zeta \approx 0.5 \) corresponds to \( \text{PM} \approx 50^\circ \). Hence, the design should target \( \text{PM} \gtrsim 50^\circ \).

Problem 4 (From Time Specs to Frequency Specs): A servo system must satisfy: \( M_p \leq 5\% \), \( t_s \leq 0.5 \,\text{s} \). Assuming second-order dominant behavior and \( 0.5 \leq \zeta \leq 0.8 \), derive approximate lower bounds on \( \omega_B \) and \( \omega_c \).

Solution:

For 5% overshoot, we require approximately \( \zeta \approx 0.7 \). Then from \( t_s \approx 4 / (\zeta \omega_n) \), we obtain

\[ \omega_n \geq \frac{4}{\zeta t_s} \approx \frac{4}{0.7 \cdot 0.5} \approx 11.4 \,\text{rad/s}. \]

For this damping range, we can take \( \omega_B \approx \omega_n \), so \( \omega_B \gtrsim 11 \,\text{rad/s} \). The gain crossover frequency \( \omega_c \) is typically of similar order (for unity-feedback), so we might specify \( \omega_c \gtrsim 10 \,\text{rad/s} \). These bounds can then be enforced in Bode-based controller design.

Problem 5 (Qualitative Trade-Off in Robot Joint Control): For a robot joint driven by a DC motor, explain qualitatively how increasing the closed-loop bandwidth and resonant peak affects: (i) tracking speed, (ii) overshoot, and (iii) sensitivity to gear backlash and structural flexibility.

Solution:

Increasing bandwidth generally decreases settling time and thus improves tracking speed (i). However, if damping is not sufficient, the resonant peak increases, which tends to increase overshoot (ii) and amplifies narrowband excitation near resonant frequencies. In a mechanical system with gear backlash and structural flexibility, a large resonant peak leads to amplified vibrations and oscillations (iii). Therefore, design must balance bandwidth (speed) against damping and resonant peak to avoid exciting flexible modes or backlash-induced oscillations.

In this lesson, we established rigorous connections between standard second-order closed-loop models and their time- and frequency-domain characterizations. We showed that damping ratio \( \zeta \) simultaneously controls overshoot, resonant peak, and phase margin, while natural frequency \( \omega_n \) is closely related to bandwidth, settling time, and peak time. These relationships enable systematic translation of design requirements: from time-domain specifications commonly demanded by users and mechanical engineers to frequency-domain inequalities that guide controller tuning using Bode, Nyquist, or Nichols plots. The implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica illustrate how such mappings can be embedded into analysis and design tools for linear control of robotic and mechatronic systems.