Consider a standard unity-feedback loop with plant \( P(s) \) and controller \( C(s) \). The open-loop transfer function is \( L(s) = C(s)P(s) \). For reference input \( R(s) \) and output \( Y(s) \), the closed-loop transfer function from reference to output is

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

In the frequency domain, for sinusoidal steady-state with \( s = j\omega \), we have \( T(j\omega) = \frac{L(j\omega)}{1 + L(j\omega)} \). The error signal is \( E(s) = R(s) - Y(s) \), so

\[ \frac{E(s)}{R(s)} = \frac{1}{1 + L(s)}, \quad \frac{E(j\omega)}{R(j\omega)} = \frac{1}{1 + L(j\omega)}. \]

Thus, for each frequency \( \omega \):

• Tracking / steady-state accuracy: dominated by \( \left|\frac{1}{1 + L(j\omega)}\right| \) at low frequencies.
• Closed-loop shape: \( |T(j\omega)| = \left| \frac{L(j\omega)}{1+L(j\omega)} \right| \) controls overshoot, resonant peaks, and bandwidth.
• Noise and actuator effort: depend on the shape of \( L(j\omega) \) at medium and high frequencies.

The key point is that changing \( L(j\omega) \) to improve one of these properties usually worsens another. This is the essence of performance trade-offs in frequency shaping.

flowchart TD
  A["Performance goals"] --> B["Good tracking at low freq"]
  A --> C["Disturbance rejection"]
  A --> D["Noise attenuation \nat high freq"]
  B --> E["Increase low-frequency loop gain"]
  C --> E
  E --> F["Higher crossover / bandwidth"]
  F --> G["Faster response"]
  F --> H["Smaller phase margin"]
  F --> I["Larger control effort"]
  H --> J["More overshoot, \noscillations"]
  I --> K["Actuator limits, \nheating"]
  H --> L["Reduced robustness \nto uncertainties"]
  D --> M["Require small \nhigh-frequency gain"]
  F --> M
        

To quantify trade-offs, we consider three main frequency bands for a typical loop:

• Low frequencies: tracking and steady-state error.
• Mid frequencies: transient oscillations and resonance.
• High frequencies: sensor noise, unmodeled dynamics, and actuator stress.

Let \( \omega_c \) denote the gain crossover frequency where \( |L(j\omega_c)| = 1 \).

\[ |T(j\omega)| = \frac{|L(j\omega)|}{|1 + L(j\omega)|}. \]

Using this expression:

• For \( |L(j\omega)| \gg 1 \) (typically \( \omega \ll \omega_c \)): \( T(j\omega) \approx 1 \) and \( E(j\omega)/R(j\omega) \approx 1/L(j\omega) \), so the error is small.
• For \( |L(j\omega)| \ll 1 \) (typically \( \omega \gg \omega_c \)): \( T(j\omega) \approx L(j\omega) \), so the closed-loop behaves like the open-loop plant, and tracking is poor.
• For \( |L(j\omega)| \approx 1 \) (around \( \omega_c \)), the detailed shape of \( L(j\omega) \) and its phase determine overshoot, damping, and robustness.

If measurement noise \( N(s) \) is added at the sensor, standard block-diagram algebra gives the transfer function from noise to output:

\[ \frac{Y(s)}{N(s)} = -\frac{L(s)}{1 + L(s)}, \quad \left|\frac{Y(j\omega)}{N(j\omega)}\right| = \frac{|L(j\omega)|}{|1 + L(j\omega)|}. \]

To attenuate high-frequency noise at the output, we need \( |L(j\omega)| \ll 1 \) at those frequencies. But this conflicts with the desire for large \( |L(j\omega)| \) to improve disturbance rejection and tracking if disturbances or commands have significant high-frequency content. Thus, the shape of \( |L(j\omega)| \) must compromise between these objectives.

Many closed-loop feedback systems can be approximated by a dominant second-order model in the vicinity of the crossover frequency:

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

The magnitude 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 }. \]

The resonant frequency \( \omega_r \) (where the magnitude is maximal) and the resonant peak \( M_r \) are found by differentiating \( |T(j\omega)|^2 \) with respect to \( \omega \) and setting the derivative to zero. For \( \zeta < 1/\sqrt{2} \), one obtains

\[ \omega_r = \omega_n\sqrt{1 - 2\zeta^2}, \quad M_r = |T(j\omega_r)| = \frac{1}{2\zeta\sqrt{1 - \zeta^2}}. \]

The step response overshoot (peak value minus 1 for a unit step) is

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

These formulas reveal a crucial trade-off:

• As \( \zeta \) decreases, both \( M_r \) and \( M_p \) increase dramatically. You get a faster but more oscillatory response.
• As \( \zeta \) increases, overshoot and resonant peak decrease, but the bandwidth and response speed deteriorate.

An approximate relation between \( \omega_n \), \( \zeta \), and the settling time \( t_s \) (to a 2&percnt; band) is

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

For fixed \( t_s \), increasing \( \zeta \) (to reduce overshoot) forces a smaller \( \omega_n \) and therefore a lower bandwidth. This is an explicit mathematical expression of the speed vs overshoot trade-off.

Gain and phase margins (studied in Chapter 17) impose further constraints on how aggressively we can increase bandwidth. For a given plant, increasing the controller gain typically:

• moves the gain crossover frequency \( \omega_c \) to higher values,
• reduces phase margin as the plant contributes more negative phase at higher frequencies,
• increases the closed-loop bandwidth.

Consider a plant \( P(s) = \frac{1}{s(s+1)(s+2)} \) with a proportional controller \( C(s) = K \). The closed-loop characteristic polynomial is

\[ 1 + K P(s) = 0 \quad \Rightarrow \quad s(s+1)(s+2) + K = 0 \quad \Rightarrow \quad s^3 + 3s^2 + 2s + K = 0. \]

Using the Routh–Hurwitz criterion, the Routh array for \( s^3 + 3s^2 + 2s + K \) is

\[ \begin{array}{c|cc} s^3 & 1 & 2 \\ s^2 & 3 & K \\ s^1 & \dfrac{3\cdot 2 - 1\cdot K}{3} & 0 \\ s^0 & K & 0 \end{array} = \begin{array}{c|cc} s^3 & 1 & 2 \\ s^2 & 3 & K \\ s^1 & \dfrac{6 - K}{3} & 0 \\ s^0 & K & 0 \end{array}. \]

For stability, all first-column entries must be positive:

\[ 1 > 0, \quad 3 > 0, \quad \frac{6 - K}{3} > 0, \quad K > 0 \quad \Rightarrow \quad 0 < K < 6. \]

Increasing \( K \) boosts bandwidth and reduces steady-state error, but beyond \( K = 6 \) the closed-loop becomes unstable. Even well within this interval, phase margin constraints typically require a comfortable distance from the limit to ensure robustness. This illustrates a hard trade-off: bandwidth cannot be increased arbitrarily without violating stability margins.

Let the control input be \( U(s) \). For unity feedback,

\[ U(s) = C(s)\bigl(R(s) - Y(s)\bigr) = \frac{C(s)}{1 + L(s)}R(s) - \frac{C(s)P(s)}{1 + L(s)}D(s) - \frac{C(s)}{1 + L(s)}N(s), \]

where \( D(s) \) is a disturbance at the plant input and \( N(s) \) is measurement noise. The magnitude of the transfer function from \( R(s) \) to \( U(s) \) is

\[ \left|\frac{U(j\omega)}{R(j\omega)}\right| = \left|\frac{C(j\omega)}{1 + L(j\omega)}\right|. \]

To achieve small tracking error at low frequencies, we often use integrators and large proportional gains so that \( |L(j\omega)| \) is large for small \( \omega \). But then:

• Control effort increases: the low-frequency gain of \( C(j\omega)/(1 + L(j\omega)) \) grows, producing larger control signals \( U(t) \), which can saturate actuators.
• High-frequency noise: if \( |L(j\omega)| \) is not sufficiently small where the noise spectrum is large, the output will contain significant noise, as we saw in Section 2.

A common engineering rule is to place the closed-loop bandwidth well below frequencies where:

• sensor noise power is high, or
• unmodeled high-frequency dynamics become significant.

For example, if a robot joint exhibits unmodeled flexible modes near \( \omega_f \), one usually enforces \( \omega_c \approx \omega_{\text{bw}} \ll \omega_f \) (e.g., a factor of 3–5 separation) to maintain robustness. Attempting to shape the loop for bandwidth close to \( \omega_f \) may produce dangerous amplification near the resonance.

Consider again the plant \( P(s) = \frac{1}{s(s+1)(s+2)} \) and a PI controller

\[ C(s) = K_p + \frac{K_i}{s} = \frac{K_p s + K_i}{s}. \]

The open-loop transfer function is

\[ L(s) = C(s)P(s) = \frac{K_p s + K_i}{s}\cdot\frac{1}{s(s+1)(s+2)} = \frac{K_p s + K_i}{s^2(s+1)(s+2)}. \]

At low frequencies \( \omega \approx 0 \), the integral term dominates, so

\[ |L(j\omega)| \approx \frac{K_i}{\omega^2\cdot 1\cdot 2} = \frac{K_i}{2\omega^2}, \]

which grows very rapidly as \( \omega \rightarrow 0 \). This yields:

• excellent low-frequency tracking and small steady-state error,
• but very large control effort for slow reference changes.

At higher frequencies, the proportional term \( K_p s \) dominates, and the magnitude of \( L(j\omega) \) decays approximately as \( 1/\omega^3 \). Increasing either \( K_p \) or \( K_i \) will:

• increase crossover frequency and bandwidth,
• reduce phase margin (because the additional phase lag from the plant is sampled at higher frequencies),
• increase resonant peak \( M_r \) of the closed loop,
• amplify mid-frequency noise and disturbances.

In practice, one chooses \( K_p \) and \( K_i \) to satisfy a combination of:

• bandwidth (or rise-time) requirement,
• maximum allowed overshoot (bound on \( M_p \) or \( M_r \)),
• control effort limits (peak or RMS),
• noise amplification limits (e.g., maximum gain at known noise frequencies).

We now illustrate trade-offs numerically using Python. For robotics applications, common libraries include control (python-control) for LTI systems and roboticstoolbox for manipulator models.

import numpy as np
import control  # python-control library, often used in robotics courses
# (Optional) from roboticstoolbox import DHRobot, RevoluteDH  # robot models

# Plant: P(s) = 1 / (s (s + 1) (s + 2))
P = control.tf([1.0], [1.0, 3.0, 2.0, 0.0])

# Two PI controllers:
# "Conservative" (lower bandwidth, larger phase margin)
Kp1, Ki1 = 2.0, 1.0
C1 = control.tf([Kp1, Ki1], [1.0, 0.0])

# "Aggressive" (higher bandwidth, smaller phase margin)
Kp2, Ki2 = 6.0, 4.0
C2 = control.tf([Kp2, Ki2], [1.0, 0.0])

L1 = C1 * P
L2 = C2 * P

T1 = control.feedback(L1, 1)  # closed-loop from r to y
T2 = control.feedback(L2, 1)

# Bode plots to compare loop shapes
w = np.logspace(-2, 2, 500)
mag1, phase1, wout1 = control.bode(L1, w, Plot=False)
mag2, phase2, wout2 = control.bode(L2, w, Plot=False)

bw1 = control.bandwidth(T1)
bw2 = control.bandwidth(T2)

print("Conservative controller:  bandwidth ~", bw1, "rad/s")
print("Aggressive controller:    bandwidth ~", bw2, "rad/s")

# Step responses to compare time-domain performance
t = np.linspace(0, 10, 1000)
t1, y1 = control.step_response(T1, T=t)
t2, y2 = control.step_response(T2, T=t)

# Compute overshoot
Mp1 = (np.max(y1) - 1.0) * 100.0
Mp2 = (np.max(y2) - 1.0) * 100.0
print("Conservative overshoot ~ {:.1f}%".format(Mp1))
print("Aggressive overshoot   ~ {:.1f}%".format(Mp2))

# Optional: control effort for a unit step
U1 = control.forced_response(C1 / (1 + L1), T=t, U=np.ones_like(t))[1]
U2 = control.forced_response(C2 / (1 + L2), T=t, U=np.ones_like(t))[1]
print("Peak control effort (conservative):", np.max(np.abs(U1)))
print("Peak control effort (aggressive):  ", np.max(np.abs(U2)))
      

Typical output is that the aggressive controller has larger bandwidth, smaller steady-state error, but significantly higher overshoot and peak control effort. Bode plots will show a higher resonant peak and reduced phase margin for the aggressive design.

In C++-based robotic control (e.g., with ROS and ros_control), one often uses Eigen for linear algebra and custom code for simple SISO frequency-response analysis.

#include <iostream>
#include <complex>
#include <vector>
#include <cmath>
// In robotics projects, Eigen is frequently used:
// #include <Eigen/Dense>

using std::complex;
using std::vector;

// Plant P(s) = 1 / (s (s + 1) (s + 2))
complex<double> P_eval(double w) {
    complex<double> jw(0.0, w);
    return 1.0 / (jw * (jw + 1.0) * (jw + 2.0));
}

// PI controller C(s) = (Kp s + Ki) / s
complex<double> C_eval(double w, double Kp, double Ki) {
    complex<double> jw(0.0, w);
    return (Kp * jw + Ki) / jw;
}

int main() {
    double Kp1 = 2.0, Ki1 = 1.0;
    double Kp2 = 6.0, Ki2 = 4.0;

    vector<double> w;
    int N = 200;
    double wmin = 0.01, wmax = 100.0;
    for (int i = 0; i < N; ++i) {
        double logw = std::log10(wmin) +
                      (std::log10(wmax) - std::log10(wmin)) * i / (N - 1);
        w.push_back(std::pow(10.0, logw));
    }

    std::cout << "# w  |L1(jw)|  |L2(jw)|" << std::endl;
    for (double wi : w) {
        complex<double> P = P_eval(wi);
        complex<double> C1 = C_eval(wi, Kp1, Ki1);
        complex<double> C2 = C_eval(wi, Kp2, Ki2);

        complex<double> L1 = C1 * P;
        complex<double> L2 = C2 * P;

        double magL1 = std::abs(L1);
        double magL2 = std::abs(L2);

        std::cout << wi << "  "
                  << magL1 << "  "
                  << magL2 << std::endl;
    }

    // In a full implementation, you would also numerically simulate the
    // step response by discretizing the state-space realization, or by
    // using an ODE integrator (e.g. Runge-Kutta) on the differential equations.

    return 0;
}
      

This skeleton shows how to compare loop gains for different controllers. In a robotics context, this logic could be integrated into a ros_control controller to tune gains while monitoring bandwidth, noise, and actuator torques.

Java is sometimes used in high-level robotic frameworks. Libraries such as EJML or Apache Commons Math provide complex numbers and linear algebra. Below is a minimal illustration using Apache Commons Math.

import org.apache.commons.math3.complex.Complex;
import java.util.ArrayList;
import java.util.List;

public class FrequencyTradeOffs {

    // P(s) = 1 / (s (s + 1) (s + 2))
    static Complex P(Complex s) {
        return Complex.ONE.divide(s.multiply(s.add(Complex.ONE))
                                 .multiply(s.add(new Complex(2.0, 0.0))));
    }

    // C(s) = (Kp s + Ki) / s
    static Complex C(Complex s, double Kp, double Ki) {
        return (new Complex(Kp, 0.0).multiply(s)
                .add(new Complex(Ki, 0.0))).divide(s);
    }

    public static void main(String[] args) {
        double Kp1 = 2.0, Ki1 = 1.0;
        double Kp2 = 6.0, Ki2 = 4.0;

        int N = 100;
        double wmin = 0.01, wmax = 100.0;
        List<Double> w = new ArrayList<>();

        for (int i = 0; i < N; ++i) {
            double logw = Math.log10(wmin)
                        + (Math.log10(wmax) - Math.log10(wmin)) * i / (N - 1);
            w.add(Math.pow(10.0, logw));
        }

        System.out.println("w, |L1(jw)|, |L2(jw)|");
        for (double wi : w) {
            Complex jw = new Complex(0.0, wi);
            Complex Pval = P(jw);

            Complex C1 = C(jw, Kp1, Ki1);
            Complex C2 = C(jw, Kp2, Ki2);

            Complex L1 = C1.multiply(Pval);
            Complex L2 = C2.multiply(Pval);

            System.out.println(wi + ", " + L1.abs() + ", " + L2.abs());
        }

        // Step responses can be obtained by discretizing the system and using
        // numerical integration or control libraries built on top of EJML.
    }
}
      

This type of analysis is useful for verifying that a Java-based control module respects bandwidth and noise constraints before deployment on a robotic platform.

MATLAB and Simulink are standard in control and robotics (e.g., with the Robotics System Toolbox). The following commands inspect the trade-offs between two PI controllers via Bode and step plots.

% Plant and controllers
s = tf('s');
P = 1 / (s * (s + 1) * (s + 2));

% Conservative PI
Kp1 = 2; Ki1 = 1;
C1 = Kp1 + Ki1 / s;

% Aggressive PI
Kp2 = 6; Ki2 = 4;
C2 = Kp2 + Ki2 / s;

L1 = C1 * P;
L2 = C2 * P;

T1 = feedback(L1, 1);
T2 = feedback(L2, 1);

figure;
bode(L1, 'b', L2, 'r');
grid on;
legend('Conservative L1', 'Aggressive L2');
title('Loop-shape comparison');

figure;
step(T1, T2);
grid on;
legend('Conservative T1', 'Aggressive T2');
title('Step response comparison');

info1 = stepinfo(T1);
info2 = stepinfo(T2);
disp(info1);
disp(info2);

% Simulink integration:
% - Implement P(s) and C(s) using Transfer Fcn and Sum blocks.
% - Use 'Scope' blocks to monitor y(t) and u(t).
% - Add band-limited white noise at the sensor to visualize noise amplification.

      

In a robotic joint-control model, one can replace \( P(s) \) by a linearized motor–mechanics transfer function and directly inspect how changes to PI gains affect bandwidth, overshoot, and noise sensitivity in Simulink simulations.

Mathematica is powerful for both symbolic derivations (e.g., the resonant peak formula) and numeric frequency-domain analysis.

(* Define Laplace variable and transfer functions *)
s =.; Clear[s];
P = TransferFunctionModel[1/(s (s + 1) (s + 2)), s];

Kp1 = 2; Ki1 = 1;
Kp2 = 6; Ki2 = 4;

C1 = TransferFunctionModel[(Kp1 s + Ki1)/s, s];
C2 = TransferFunctionModel[(Kp2 s + Ki2)/s, s];

L1 = C1 P;
L2 = C2 P;

T1 = SystemsModelFeedbackConnect[L1, 1];
T2 = SystemsModelFeedbackConnect[L2, 1];

(* Bode magnitude plots *)
BodePlot[{L1, L2},
  {10^-2, 10^2},
  PlotLegends -> {"L1 conservative", "L2 aggressive"}
]

(* Step responses *)
StepResponsePlot[{T1, T2}, {0, 10},
  PlotLegends -> {"T1 conservative", "T2 aggressive"}
]

(* Symbolic derivation for second-order resonant peak *)
Clear[wn, z, w];
T2nd = wn^2/(s^2 + 2 z wn s + wn^2);
Tjw = T2nd /. s -> I w // ComplexExpand;
magSq = Simplify[Re[Tjw]^2 + Im[Tjw]^2];

(* Solve d|T|^2/dw == 0 for resonant frequency wr *)
dmag = D[magSq, w];
wrsol = Solve[dmag == 0 && w > 0, w, Reals];

(* Substitute wr into |T(jw)| to obtain Mr *)
Mr = Simplify[Sqrt[magSq /. wrsol[[1]]],
  Assumptions -> 0 < z < 1/Sqrt[2]
]

(* This reproduces Mr = 1 / (2 z Sqrt[1 - z^2]) *)
      

Such symbolic derivations help confirm textbook formulas for resonant peak and highlight explicitly how damping ratio shapes the trade-off between bandwidth and overshoot.

Problem 1 (Resonant Peak of a Second-Order System). Consider \( T(s) = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2} \) with \( 0 < \zeta < 1 \). Derive the expressions for the resonant frequency \( \omega_r \) and resonant peak \( M_r = \max_{\omega \ge 0} |T(j\omega)| \).

Solution.

Compute the squared magnitude:

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

Let \( x = \omega^2 \). Then

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

Differentiating with respect to \( x \) and setting the derivative to zero yields

\[ \frac{\partial}{\partial x}|T(j\omega)|^2 = 0 \quad \Rightarrow \quad x = \omega_n^2(1 - 2\zeta^2), \quad \omega_r = \omega_n\sqrt{1 - 2\zeta^2}, \]

which is meaningful for \( \zeta < 1/\sqrt{2} \). Substituting \( \omega = \omega_r \) into the magnitude expression and simplifying gives

\[ M_r = |T(j\omega_r)| = \frac{1}{2\zeta\sqrt{1 - \zeta^2}}. \]

Thus, \( M_r \) grows rapidly as \( \zeta \) decreases, illustrating the trade-off between damping and resonant amplification.

Problem 2 (Overshoot Constraint vs Bandwidth). For the same second-order model, suppose you require the step overshoot to be at most 10&percnt;. Determine a lower bound on \( \zeta \), and discuss how this constrains the bandwidth if the settling time \( t_s \) is fixed.

Solution.

The overshoot is given by

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

The constraint \( M_p \le 0.1 \) implies

\[ -\frac{\pi\zeta}{\sqrt{1 - \zeta^2}} \le \ln(0.1) \quad \Rightarrow \quad \frac{\pi\zeta}{\sqrt{1 - \zeta^2}} \ge -\ln(0.1) \approx 2.3026. \]

Solving numerically yields \( \zeta \approx 0.59 \). Thus we need \( \zeta \gtrsim 0.6 \). Using the approximate relation \( t_s \approx 4/(\zeta\omega_n) \), fixing \( t_s \) and increasing \( \zeta \) forces \( \omega_n \) to decrease:

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

Since the bandwidth is on the order of \( \omega_n \), the overshoot constraint reduces the maximal achievable bandwidth for a given settling time, demonstrating a trade-off between speed and oscillatory behavior.

Problem 3 (Gain Range for Stability and Trade-Off with Tracking). For the plant \( P(s) = \frac{1}{s(s+1)(s+2)} \) with proportional control \( C(s) = K \), verify the stability condition \( 0 < K < 6 \) and explain the implication for improving tracking via larger gains.

Solution.

As derived in Section 4, the closed-loop characteristic polynomial is \( s^3 + 3s^2 + 2s + K \), and the Routh array gives the stability condition \( 0 < K < 6 \). Increasing \( K \) reduces steady-state error (via higher low-frequency gain) and increases bandwidth, but cannot exceed \( K = 6 \) without instability. In practice, one chooses a safety margin, e.g. \( K \le 3 \), to ensure acceptable phase margin and robustness. This shows that tracking improvement via gain increase is fundamentally limited by stability.

Problem 4 (Noise Attenuation Limit at a Given Frequency). Suppose measurement noise is concentrated near frequency \( \omega_n \), and the noise-to-output transfer function magnitude is \( |Y(j\omega)/N(j\omega)| = |L(j\omega)|/|1+L(j\omega)| \). You require \( |Y(j\omega_n)/N(j\omega_n)| \le 0.1 \). Assuming \( L(j\omega_n) \) is real and positive, find an upper bound on \( |L(j\omega_n)| \).

Solution.

Let \( r = |L(j\omega_n)| \). The condition is

\[ \frac{r}{|1 + r|} \le 0.1. \]

For real positive \( r \), we have \( |1 + r| = 1 + r \), so

\[ \frac{r}{1 + r} \le 0.1 \quad \Rightarrow \quad r \le 0.1(1 + r) \quad \Rightarrow \quad r - 0.1 r \le 0.1 \quad \Rightarrow \quad 0.9 r \le 0.1 \quad \Rightarrow \quad r \le \frac{1}{9}. \]

Thus, the loop gain at the noise frequency must satisfy \( |L(j\omega_n)| \le 1/9 \), corresponding to approximately \( -19 \) dB. This upper bound may conflict with disturbance-rejection requirements and therefore shapes the allowable high-frequency loop gain.

Problem 5 (Qualitative Trade-Off Design Flow). Sketch a conceptual flow for selecting bandwidth and loop gain given specifications on tracking, disturbance rejection, noise attenuation, and actuator limits.

Solution (conceptual flow).

flowchart TD
  S["Start: specs on tracking, noise, effort"] --> B["Choose target bandwidth"]
  B --> T["Check tracking & \ndisturbance specs"]
  B --> N["Check noise spectrum \nnear bandwidth"]
  B --> U["Check actuator torque / \nvoltage limits"]
  T -->|not met| INC["Increase low-frequency gain \nor add integrator"]
  N -->|noise too large| DEC["Reduce bandwidth \nor add filtering"]
  U -->|limits violated| DEC
  INC --> B
  DEC --> B
  B --> OK["Compromise: \nbalanced shape"]
        

The loop indicates that design is an iterative search for a compromise bandwidth and loop shape that satisfy all constraints, rather than a one-shot optimization of a single metric.

In this lesson, we showed that frequency shaping in feedback systems is fundamentally about trade-offs. The open-loop transfer function \( L(s) = C(s)P(s) \) determines closed-loop tracking accuracy, disturbance rejection, noise sensitivity, control effort, and robustness. Using second-order prototypes, we derived explicit relations for resonant frequency, resonant peak, overshoot, and settling time, highlighting conflicts between bandwidth and damping. Routh–Hurwitz analysis illustrated hard gain limits set by stability, while noise-attenuation requirements imposed upper bounds on high-frequency loop gain. Multi-language implementations (Python, C++, Java, MATLAB/Simulink, Mathematica) illustrated how these trade-offs are explored in practice, especially in robotic control applications. In later chapters, sensitivity functions will formalize these trade-offs even further.