In previous lessons you learned how to compute the frequency response \( G(j\omega) \) of a linear time-invariant (LTI) system and interpret magnitude and phase. In control design, especially for servo systems in robotics, three frequency-domain quantities are fundamental:

• Resonant peak \( M_r \): the maximum magnitude of the closed-loop frequency response (typically in the vicinity of the natural frequency).
• Resonant frequency \( \omega_r \): the frequency at which \( M_r \) occurs.
• Bandwidth \( \omega_b \): the frequency at which the magnitude drops to a specified level (conventionally the \(-3\,\text{dB}\) point where \( |G(j\omega_b)| = \frac{1}{\sqrt{2}}|G(0)| \)).

These quantities are tightly coupled to the damping ratio \( \zeta \) and natural frequency \( \omega_n \) of a standard second-order closed-loop system. For many well-designed feedback loops (e.g. one robot joint with a PID controller), the closed-loop transfer function from reference to output can be approximated by the canonical form

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

Our goal in this lesson is to derive \( M_r \), \( \omega_r \), and \( \omega_b \) in terms of \( \zeta \) and \( \omega_n \), and to interpret the trade-offs for control design.

flowchart TD
  A["Closed-loop model T(s) (2nd order)"] --> B["Frequency response T(jw)"]
  B --> C["Magnitude |T(jw)| vs w"]
  C --> D["Locate resonant peak Mr at wr"]
  C --> E["Find bandwidth wb at -3 dB"]
  D --> F["Adjust damping zeta"]
  E --> F
  F --> G["Tune wn and gains for robot servo"]
        

Consider the standard second-order closed-loop transfer function

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

Its sinusoidal steady-state response to an input \( r(t) = \sin(\omega t) \) (or any sinusoid with frequency \( \omega \)) is described by \( T(j\omega) \), 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 magnitude squared of the frequency response is

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

It is convenient to normalize the frequency by \( \omega_n \). Define \( x = \frac{\omega}{\omega_n} \). Then

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

Note that the DC gain is \( |T(j0)| = 1 \), so this form directly shows how the magnitude varies with normalized frequency \( x \) and damping ratio \( \zeta \).

The resonant peak \( M_r \) is defined as

\[ M_r = \max_{\omega \ge 0} |T(j\omega)|. \]

Since the numerator of \( |T(j\omega)|^2 \) is constant, maximizing \( |T(j\omega)| \) is equivalent to minimizing the denominator

\[ D(x) = \left(1 - x^2\right)^2 + (2\zeta x)^2 = 1 + (4\zeta^2 - 2)x^2 + x^4. \]

To find the stationary points, differentiate \( D(x) \) with respect to \( x \) and set the derivative to zero:

\[ \begin{aligned} D'(x) &= 2(4\zeta^2 - 2)x + 4x^3 \\ &= 2x\left(4\zeta^2 - 2 + 2x^2\right) = 0. \end{aligned} \]

Hence the stationary points satisfy either \( x = 0 \) or \( 4\zeta^2 - 2 + 2x^2 = 0 \), i.e.

\[ x^2 = 1 - 2\zeta^2. \]

A real positive solution exists only when \( 0 \le \zeta < \frac{1}{\sqrt{2}} \). In this case, the resonant (normalized) frequency is

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

Substituting \( x_r \) into the magnitude expression yields the resonant peak \( M_r \). First note that \( 1 - x_r^2 = 2\zeta^2 \), so

\[ \begin{aligned} D(x_r) &= (1 - x_r^2)^2 + (2\zeta x_r)^2 \\ &= (2\zeta^2)^2 + 4\zeta^2 x_r^2 \\ &= 4\zeta^4 + 4\zeta^2(1 - 2\zeta^2) = 4\zeta^2(1 - \zeta^2). \end{aligned} \]

Therefore

\[ M_r^2 = \frac{1}{D(x_r)} = \frac{1}{4\zeta^2(1 - \zeta^2)} \quad \Rightarrow \quad M_r = \frac{1}{2\zeta\sqrt{1 - \zeta^2}}, \quad 0 \le \zeta < \frac{1}{\sqrt{2}}. \]

For \( \zeta \ge \frac{1}{\sqrt{2}} \), the function \( |T(j\omega)| \) is monotonically decreasing with \( \omega \), and there is no resonant peak above the DC gain; thus \( M_r = 1 \) and \( \omega_r = 0 \).

Interpretation: small damping ratios (\( \zeta \) close to 0) yield large resonant peaks, meaning the closed-loop system strongly amplifies sinusoidal inputs near the natural frequency. Increasing damping reduces \( M_r \), improving robustness to oscillatory disturbances.

In classical control, the closed-loop bandwidth \( \omega_b \) is often defined as the frequency at which the magnitude has dropped by \( -3 \,\text{dB} \) from its low-frequency value. Since \( |T(j0)| = 1 \), this means

\[ |T(j\omega_b)| = \frac{1}{\sqrt{2}}. \]

In normalized coordinates \( x_b = \frac{\omega_b}{\omega_n} \), this condition becomes

\[ \frac{1}{(1 - x_b^2)^2 + (2\zeta x_b)^2} = \frac{1}{2} \quad \Leftrightarrow \quad (1 - x_b^2)^2 + (2\zeta x_b)^2 = 2. \]

Expanding and simplifying,

\[ \begin{aligned} (1 - x_b^2)^2 + (2\zeta x_b)^2 &= 1 - 2x_b^2 + x_b^4 + 4\zeta^2 x_b^2 \\ &= x_b^4 + (4\zeta^2 - 2)x_b^2 + 1. \end{aligned} \]

Setting this equal to 2 leads to

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

Introducing \( y = x_b^2 \) (with \( y \ge 0 \)) gives a quadratic

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

Solving for \( y \) using the quadratic formula and selecting the positive root,

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

Hence the normalized bandwidth and bandwidth are

\[ x_b = \sqrt{1 - 2\zeta^2 + \sqrt{4\zeta^4 - 4\zeta^2 + 2}}, \quad \omega_b = \omega_n x_b. \]

This exact expression is somewhat complicated, but it reveals the dependence of bandwidth on damping ratio. For practical design, it is important to remember qualitative trends:

• For moderate damping (e.g. \( 0.4 \lesssim \zeta \lesssim 0.8 \)), bandwidth is on the order of \( \omega_n \).
• For very small damping, resonance dominates; the bandwidth tends to cluster around the resonant frequency \( \omega_r \).
• For very large damping, the system becomes sluggish and bandwidth decreases.

In Chapter 6 you saw that for a unit-step input, the percent overshoot \( M_p \) of a standard underdamped second-order system is

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

Together with \( M_r = \frac{1}{2\zeta\sqrt{1 - \zeta^2}} \), both overshoot and resonant peak are monotone decreasing functions of the damping ratio \( \zeta \) for \( 0 < \zeta < 1 \). Thus:

• Small \( \zeta \): large \( M_p \), large \( M_r \). Fast response but oscillatory; high amplification of disturbances near \( \omega_r \).
• Large \( \zeta \): small \( M_p \), \( M_r \approx 1 \). Well-damped but reduced bandwidth (slower tracking).

In robotics, one often selects \( \zeta \approx 0.6 \) to \( 0.8 \) for joint servos to balance tracking speed and overshoot, yielding a modest resonant peak and a reasonably wide bandwidth.

flowchart LR
  ZL["Small zeta"] --> O1["Large overshoot Mp"]
  ZL --> R1["Large resonant peak Mr"]
  ZL --> B1["Wide but oscillatory bandwidth"]
  ZH["Large zeta"] --> O2["Small overshoot Mp"]
  ZH --> R2["No strong resonance (Mr ~ 1)"]
  ZH --> B2["Narrower bandwidth (slower)"]
  O1 --> D1["Risk of oscillations in robot joint"]
  R1 --> D1
  O2 --> D2["Safer motions, less oscillation"]
        

Python provides several useful libraries for control and robotics: python-control for linear systems, and roboticstoolbox for robot models. Below we:

1. Define a second-order closed-loop model.
2. Sample its frequency response using python-control.
3. Estimate \( M_r \), \( \omega_r \), and \( \omega_b \) numerically.

import numpy as np
import matplotlib.pyplot as plt

# Control and robotics related libraries
# python-control: general LTI analysis
# roboticstoolbox: robot models whose joints are often approximated by 2nd-order systems
import control

# Closed-loop 2nd-order model parameters
wn = 10.0   # natural frequency [rad/s]
zeta = 0.3  # damping ratio

# Transfer function T(s) = wn^2 / (s^2 + 2*zeta*wn*s + wn^2)
num = [wn**2]
den = [1.0, 2.0*zeta*wn, wn**2]
T = control.tf(num, den)

# Frequency grid for analysis
w = np.logspace(-1, 2, 2000)  # 0.1 to 100 rad/s

# Bode magnitude (no plotting for programmatic analysis)
mag, phase, w_out = control.bode(T, w, Plot=False)
mag = np.squeeze(mag)   # shape (N,)
phase = np.squeeze(phase)

# Resonant peak Mr and resonant frequency wr
idx_Mr = int(np.argmax(mag))
Mr_num = mag[idx_Mr]
wr_num = w_out[idx_Mr]

# -3 dB target magnitude relative to DC gain
mag0 = mag[0]  # should be ~1
target = mag0 / np.sqrt(2.0)

# Find first frequency where magnitude falls below target
wb_num = w_out[-1]
for wi, mi in zip(w_out, mag):
    if mi <= target:
        wb_num = wi
        break

print(f"Numeric resonant peak Mr  : {Mr_num:.3f}")
print(f"Numeric resonant freq wr  : {wr_num:.3f} rad/s")
print(f"Numeric bandwidth wb      : {wb_num:.3f} rad/s")

# Analytical expressions for comparison (valid for zeta < 1/sqrt(2))
if zeta < 1.0/np.sqrt(2.0):
    wr_analytic = wn * np.sqrt(1.0 - 2.0*zeta**2)
    Mr_analytic = 1.0 / (2.0*zeta*np.sqrt(1.0 - zeta**2))
    print(f"Analytic Mr               : {Mr_analytic:.3f}")
    print(f"Analytic wr               : {wr_analytic:.3f} rad/s")

# Optional: plot magnitude
plt.figure()
plt.semilogx(w_out, 20*np.log10(mag))
plt.axhline(20*np.log10(target), linestyle="--")
plt.axvline(wr_num, linestyle=":", label="wr")
plt.axvline(wb_num, linestyle="--", label="wb")
plt.xlabel("w [rad/s]")
plt.ylabel("Magnitude [dB]")
plt.legend()
plt.grid(True, which="both")
plt.title("Closed-loop 2nd-order magnitude")
plt.show()
      

In a robotic application, the above T could represent the closed-loop joint transfer function after tuning a PD controller. The choice of \( \zeta \) and \( \omega_n \) determines how aggressively the joint tracks commanded trajectories and how sensitive it is to structural resonances and flexible modes in the robot.

In C++, control and robotics software often runs inside middleware such as ROS (ros_control or ros2_control). Here we show a standalone numeric computation of \( M_r \), \( \omega_r \), and \( \omega_b \).

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

struct FrequencyResponse {
    double Mr;
    double wr;
    double wb;
};

FrequencyResponse analyzeSecondOrder(double wn, double zeta) {
    // Log-spaced frequency grid
    const int N = 2000;
    double w_min = 0.1;
    double w_max = 100.0;
    std::vector<double> w(N);
    for (int k = 0; k < N; ++k) {
        double alpha = static_cast<double>(k) / (N - 1);
        w[k] = w_min * std::pow(w_max / w_min, alpha);
    }

    // Compute magnitude
    std::vector<double> mag(N);
    for (int k = 0; k < N; ++k) {
        double wi = w[k];
        double x = wi / wn;
        double denom = std::pow(1.0 - x * x, 2.0) + std::pow(2.0 * zeta * x, 2.0);
        mag[k] = 1.0 / std::sqrt(denom);
    }

    // Resonant peak
    double Mr = mag[0];
    double wr = w[0];
    for (int k = 1; k < N; ++k) {
        if (mag[k] > Mr) {
            Mr = mag[k];
            wr = w[k];
        }
    }

    // -3 dB bandwidth
    double target = mag[0] / std::sqrt(2.0);
    double wb = w.back();
    for (int k = 0; k < N; ++k) {
        if (mag[k] <= target) {
            wb = w[k];
            break;
        }
    }

    return {Mr, wr, wb};
}

int main() {
    double wn = 10.0;
    double zeta = 0.3;
    FrequencyResponse fr = analyzeSecondOrder(wn, zeta);

    std::cout << "Mr = " << fr.Mr
              << ", wr = " << fr.wr
              << " rad/s, wb = " << fr.wb
              << " rad/s" << std::endl;

    // In a ROS-based robot controller, such analysis can be used offline
    // to check that the joint-space PD gains produce acceptable resonance and bandwidth.

    return 0;
}
      

Within ROS or other robotics frameworks, similar computations can be integrated into offline tuning tools that analyze joint transfer functions extracted from identified models or simulation data.

Java is widely used in educational and industrial robotics frameworks such as FIRST WPILib. Below is a simple Java routine that mimics the calculations above and could be embedded in a tuning tool or dashboard.

public class SecondOrderAnalysis {

    public static class Result {
        public double Mr;
        public double wr;
        public double wb;
    }

    public static Result analyze(double wn, double zeta) {
        int N = 2000;
        double wMin = 0.1;
        double wMax = 100.0;
        double[] w = new double[N];
        double[] mag = new double[N];

        for (int k = 0; k < N; ++k) {
            double alpha = (double) k / (double) (N - 1);
            w[k] = wMin * Math.pow(wMax / wMin, alpha);
            double x = w[k] / wn;
            double denom = Math.pow(1.0 - x * x, 2.0)
                         + Math.pow(2.0 * zeta * x, 2.0);
            mag[k] = 1.0 / Math.sqrt(denom);
        }

        // Resonant peak
        double Mr = mag[0];
        double wr = w[0];
        for (int k = 1; k < N; ++k) {
            if (mag[k] > Mr) {
                Mr = mag[k];
                wr = w[k];
            }
        }

        // -3 dB bandwidth
        double target = mag[0] / Math.sqrt(2.0);
        double wb = w[N - 1];
        for (int k = 0; k < N; ++k) {
            if (mag[k] <= target) {
                wb = w[k];
                break;
            }
        }

        Result r = new Result();
        r.Mr = Mr;
        r.wr = wr;
        r.wb = wb;
        return r;
    }

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

        Result r = analyze(wn, zeta);
        System.out.println("Mr = " + r.Mr
                + ", wr = " + r.wr + " rad/s"
                + ", wb = " + r.wb + " rad/s");

        // In a robot codebase (e.g. using WPILib), this could be distributed
        // as an offline tool to check servo bandwidth and resonance.
    }
}
      

Libraries such as WPILib provide abstractions for motor controllers and encoders; the above analysis can be applied to the identified closed-loop transfer functions for these components to ensure sufficient damping and acceptable bandwidth.

MATLAB with the Control System Toolbox is a standard tool in control engineering and robotics. The Robotics System Toolbox and Robotics Toolbox (third-party) allow robot modeling; here we focus on a single joint approximated as a second-order system.

% Parameters
wn   = 10;    % natural frequency [rad/s]
zeta = 0.4;   % damping ratio

% Closed-loop 2nd-order transfer function T(s)
s = tf('s');
T = wn^2 / (s^2 + 2*zeta*wn*s + wn^2);

% Bode data (frequency response)
w = logspace(-1, 2, 2000);
[mag, phase, wout] = bode(T, w);
mag = squeeze(mag);    % N-by-1
phase = squeeze(phase);

% Resonant peak and frequency
[Mr_num, idxMr] = max(mag);
wr_num = wout(idxMr);

% -3 dB bandwidth
mag0   = mag(1);
target = mag0 / sqrt(2);
idxBw  = find(mag <= target, 1, 'first');
wb_num = wout(idxBw);

fprintf('Numeric Mr  = %.3f\n', Mr_num);
fprintf('Numeric wr  = %.3f rad/s\n', wr_num);
fprintf('Numeric wb  = %.3f rad/s\n', wb_num);

% Compare to analytic expressions (if valid)
if zeta < 1/sqrt(2)
    wr_analytic = wn * sqrt(1 - 2*zeta^2);
    Mr_analytic = 1 / (2*zeta*sqrt(1 - zeta^2));
    fprintf('Analytic wr = %.3f rad/s\n', wr_analytic);
    fprintf('Analytic Mr = %.3f\n',     Mr_analytic);
end

% Plot Bode magnitude
figure;
bodemag(T, {0.1, 100});
grid on;
title('Closed-loop 2nd-order magnitude');

% Simulink remark:
% A Simulink model could use a Transfer Fcn block with numerator [wn^2]
% and denominator [1, 2*zeta*wn, wn^2] to represent the closed-loop joint.
% Tools like "Linear Analysis" can compute bandwidth directly from the model.
      

In a robot model, the above closed-loop transfer function can correspond to the position control of one joint. Varying \( \zeta \) and \( \omega_n \) (through PID gains) lets you directly observe how bandwidth and resonant peak change, which is crucial for safe and precise motion.

Wolfram Mathematica offers symbolic and numeric tools for control analysis. The following code defines the second-order transfer function, produces a Bode plot, and numerically computes approximate \( M_r \), \( \omega_r \), and \( \omega_b \).

(* Parameters *)
wn   = 10.0;
zeta = 0.3;

(* Transfer function model *)
s = LaplaceTransformVariable;
sys = TransferFunctionModel[
   wn^2/(s^2 + 2*zeta*wn*s + wn^2),
   s
];

(* Bode plot *)
BodePlot[sys, {w, 0.1, 100},
  PlotLayout -> "Magnitude",
  GridLines -> Automatic,
  PlotLabel -> "Second-order closed-loop magnitude"
];

(* Magnitude function (normalized form) *)
mag[w_] := Abs[wn^2/(-w^2 + I*2*zeta*wn*w + wn^2)];

(* Numeric search for resonance and bandwidth *)
wGrid = Exp[Range[Log[0.1], Log[100], (Log[100] - Log[0.1])/1999]];
magVals = mag /@ wGrid;

(* Resonant peak and frequency *)
{MrNum, idxMr} = MaximalBy[Transpose[{magVals, wGrid}], First][[1]];
wrNum = idxMr;

(* -3 dB bandwidth: first frequency where magnitude drops below 1/sqrt(2) *)
target = magVals[[1]]/Sqrt[2];
wbNum = Last[wGrid];
Do[
  If[magVals[[k]] <= target,
    wbNum = wGrid[[k]];
    Break[];
  ],
  {k, 1, Length[wGrid]}
];

Print["Numeric Mr  = ", N[MrNum]];
Print["Numeric wr  = ", N[wrNum], " rad/s"];
Print["Numeric wb  = ", N[wbNum], " rad/s"];

(* Optional: verify analytic formulas when zeta < 1/Sqrt[2] *)
If[zeta < 1/Sqrt[2],
  wrAnalytic = wn*Sqrt[1 - 2*zeta^2];
  MrAnalytic = 1/(2*zeta*Sqrt[1 - zeta^2]);
  Print["Analytic wr = ", N[wrAnalytic], " rad/s"];
  Print["Analytic Mr = ", N[MrAnalytic]];
];
      

Mathematica can also be used symbolically to re-derive the expressions for resonant peak and bandwidth by performing exact algebraic manipulations on \( |T(j\omega)|^2 \).

Problem 1 (Resonant Peak and Frequency): A closed-loop second-order system has \( \omega_n = 20 \,\text{rad/s} \) and \( \zeta = 0.3 \). Compute the resonant frequency \( \omega_r \) and resonant peak \( M_r \). Does a resonant peak exist?

Solution: Since \( \zeta = 0.3 \), we have

\[ \zeta = 0.3 < \frac{1}{\sqrt{2}} \approx 0.707, \]

so a resonant peak exists. The resonant frequency is

\[ \omega_r = \omega_n \sqrt{1 - 2\zeta^2} = 20 \sqrt{1 - 2(0.3)^2} = 20 \sqrt{1 - 0.18} = 20 \sqrt{0.82} \approx 20 \times 0.9055 \approx 18.1\,\text{rad/s}. \]

The resonant peak is

\[ M_r = \frac{1}{2\zeta\sqrt{1 - \zeta^2}} = \frac{1}{2 \cdot 0.3 \sqrt{1 - 0.09}} = \frac{1}{0.6 \sqrt{0.91}} \approx \frac{1}{0.6 \cdot 0.9539} \approx \frac{1}{0.5723} \approx 1.75. \]

Thus the system exhibits a resonant amplification of about 1.75 at \( \omega_r \approx 18.1\,\text{rad/s} \).

Problem 2 (Condition for Resonance): Prove that a standard second-order closed-loop system has a resonant peak \( M_r > 1 \) if and only if \( 0 \le \zeta < \frac{1}{\sqrt{2}} \).

Solution:

1. From the derivation of stationary points, a finite positive resonant frequency \( \omega_r \) exists if and only if \( x_r^2 = 1 - 2\zeta^2 > 0 \), i.e. \( \zeta < \frac{1}{\sqrt{2}} \).
2. For this range, the maximum occurs at \( \omega_r > 0 \), and \( M_r = \frac{1}{2\zeta\sqrt{1 - \zeta^2}} \). Since \( 0 < \zeta < \frac{1}{\sqrt{2}} \), we have \( 0 < 2\zeta\sqrt{1 - \zeta^2} < 1 \), hence \( M_r > 1 \).
3. For \( \zeta \ge \frac{1}{\sqrt{2}} \), the derivative analysis shows that the only stationary point is \( \omega = 0 \), where \( |T(j0)| = 1 \), and the magnitude monotonically decreases with \( \omega \). Thus the maximum is \( M_r = 1 \).

Therefore, \( M_r > 1 \) holds if and only if \( 0 \le \zeta < \frac{1}{\sqrt{2}} \).

Problem 3 (Overshoot and Resonant Peak Connection): A robot joint servo is modeled as a second-order system with damping ratio \( \zeta \). Suppose the design requirement is a step overshoot \( M_p \le 10\% \). Approximate the corresponding resonant peak \( M_r \).

Solution:

The step overshoot is

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

Setting \( M_p = 10\% \) yields

\[ 0.10 = \exp\!\left(-\frac{\pi \zeta}{\sqrt{1 - \zeta^2}}\right). \]

Taking natural logarithms:

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

Numerically solving this equation gives approximately \( \zeta \approx 0.59 \). For this damping ratio,

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

Thus, a 10% overshoot requirement corresponds roughly to a resonant peak of about \( 1.2 \) (or \( \approx 1.6 \,\text{dB} \)).

Problem 4 (Bandwidth Formula Derivation): Starting from the magnitude condition \( |T(j\omega_b)| = \frac{1}{\sqrt{2}} \), derive the biquadratic equation for \( x_b^2 \) and obtain \( x_b^2 = 1 - 2\zeta^2 + \sqrt{4\zeta^4 - 4\zeta^2 + 2} \).

Solution:

1. The condition \( |T(j\omega_b)|^2 = \frac{1}{2} \) becomes \( (1 - x_b^2)^2 + (2\zeta x_b)^2 = 2 \).
2. Expanding gives \( x_b^4 + (4\zeta^2 - 2)x_b^2 + 1 = 2 \), i.e. \( x_b^4 + (4\zeta^2 - 2)x_b^2 - 1 = 0 \).
3. Let \( y = x_b^2 \). Then \( y^2 + (4\zeta^2 - 2)y - 1 = 0 \).
4. Solving this quadratic: \[ y = \frac{-(4\zeta^2 - 2) + \sqrt{(4\zeta^2 - 2)^2 + 4}}{2} = 1 - 2\zeta^2 + \sqrt{4\zeta^4 - 4\zeta^2 + 2}, \] where we select the positive root since \( y \ge 0 \).

Hence \( x_b^2 = 1 - 2\zeta^2 + \sqrt{4\zeta^4 - 4\zeta^2 + 2} \), as required.

Problem 5 (Design Trade-Off Flow): A robotic joint must track trajectories up to \( 5\,\text{rad/s} \) with small overshoot and no strong resonance. Sketch a decision flow on how you would choose \( \zeta \) and \( \omega_n \) using the relationships between bandwidth, resonant peak, and damping.

Solution (conceptual flow):

flowchart TD
  S["Start: tracking up to 5 rad/s"] --> B["Choose target bandwidth wb ~ 3*5 = 15 rad/s"]
  B --> Z["Select zeta ~ 0.6..0.8 for modest overshoot and Mr ~ 1.1..1.3"]
  Z --> WN["Pick wn via wb = wn * xb(zeta)"]
  WN --> C["Check that wr (if exists) is not near structural resonances"]
  C --> T["Tune gains in simulation and adjust zeta, wn"]
        

Here \( x_b(\zeta) \) is the normalized bandwidth factor derived earlier. You would iterate between analytic approximations and simulation until the joint shows acceptable overshoot, disturbance rejection, and bandwidth.

• For a standard second-order closed-loop system with \( T(s) = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2} \), the normalized magnitude is \( |T(j\omega)|^2 = \frac{1}{(1 - x^2)^2 + (2\zeta x)^2} \) with \( x = \omega/\omega_n \).
• The resonant frequency and peak (when they exist) are \( \omega_r = \omega_n\sqrt{1 - 2\zeta^2} \) and \( M_r = \frac{1}{2\zeta\sqrt{1 - \zeta^2}} \), valid for \( 0 \le \zeta < 1/\sqrt{2} \).
• The closed-loop bandwidth \( \omega_b \) at \(-3\,\text{dB}\) satisfies \( x_b^2 = 1 - 2\zeta^2 + \sqrt{4\zeta^4 - 4\zeta^2 + 2} \), giving \( \omega_b = \omega_n x_b \).
• Both overshoot \( M_p \) and resonant peak \( M_r \) decrease with increasing \( \zeta \); bandwidth shows a more nuanced dependence but is typically on the order of \( \omega_n \) for moderate damping.
• Python, C++, Java, MATLAB/Simulink, and Mathematica all provide ways to compute and visualize resonant peaks and bandwidths, and these tools are essential for tuning robotic servos and other control loops.