Consider a unity-feedback loop with plant \( G(s) \) and controller \( C(s) \). The loop transfer function is \( L(s) = C(s)G(s) \). For unity feedback, the closed-loop command-to-output transfer function is

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

In the frequency domain, we write \( L(\mathrm{j}\omega) \) and \( T(\mathrm{j}\omega) \). The gain crossover frequency \( \omega_c \) solves

\[ \left|L(\mathrm{j}\omega_c)\right| = 1 \quad (\text{0 dB crossover}). \]

Intuitively, \( \omega_c \) marks the boundary between frequencies where the loop has high gain (tracking and disturbance rejection) and where feedback weakens. For well-shaped loops, the closed-loop bandwidth \( \omega_b \) is of the same order as \( \omega_c \); a central design task is to choose a suitable \( \omega_b \) and then adjust loop gain so that \( \omega_c \approx \omega_b \) while maintaining adequate phase margin and actuator limits.

flowchart TD
  R["Specify specs: t_s, overshoot, disturbance/noise bands"] --> A["Approximate target omega_b from t_s, overshoot"]
  A --> C["Check plant: resonances, delays, actuator/sensor limits"]
  C --> D{"Constraints satisfied?"}
  D -->|no| A2["Adjust target omega_b \n(increase/decrease)"]
  A2 --> C
  D -->|yes| E["Choose controller structure C(s)"]
  E --> F["Tune loop gain so that \n|L(j omega_c)| = 1 near omega_b"]
  F --> G["Verify margins and refine loop shape"]
        

In robotic servo systems (e.g., joint position control), this loop gain determines how aggressively the servo rejects load disturbances and tracks reference trajectories. Too small bandwidth leads to sluggish motion; too large bandwidth can excite structural resonances, amplify sensor noise, and saturate actuators.

For a stable unity-gain closed loop with \( T(0) = 1 \), a common definition of the bandwidth \( \omega_b \) is the frequency where the magnitude of the closed-loop frequency response falls to \(1/\sqrt{2}\) of its low-frequency value (−3 dB point):

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

For many servo designs with reasonably shaped loops, the bandwidth is strongly correlated with time-domain speed of response. To make this precise, we recall two canonical models from earlier chapters.

2.1 First-order closed-loop system

A standard first-order closed-loop model is

\[ T(s) = \frac{1}{\tau_{\mathrm{cl}} s + 1}, \]

where \( \tau_{\mathrm{cl}} > 0 \) is the closed-loop time constant. The squared magnitude on the imaginary axis is

\[ \left|T(\mathrm{j}\omega)\right|^2 = \frac{1}{1 + (\omega \tau_{\mathrm{cl}})^2}. \]

Imposing the −3 dB condition \( \left|T(\mathrm{j}\omega_b)\right|^2 = \tfrac{1}{2} \) gives

\[ \frac{1}{1 + (\omega_b \tau_{\mathrm{cl}})^2} = \frac{1}{2} \quad \Rightarrow \quad 1 + (\omega_b \tau_{\mathrm{cl}})^2 = 2 \quad \Rightarrow \quad \omega_b = \frac{1}{\tau_{\mathrm{cl}}}. \]

The 2% settling time for this first-order model is approximately \( t_s \approx 4\tau_{\mathrm{cl}} \), so

\[ \omega_b = \frac{1}{\tau_{\mathrm{cl}}} \approx \frac{4}{t_s}. \]

Thus specifying a desired settling time directly sets a target bandwidth; for example \( t_s = 0.2 \,\mathrm{s} \) suggests \( \omega_b \approx 20 \,\mathrm{rad/s} \).

2.2 Second-order closed-loop system

A standard second-order model with natural frequency \( \omega_n \) and damping ratio \( \zeta \) is

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

The magnitude at \(s = \mathrm{j}\omega\) is

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

The −3 dB bandwidth is found from \( \left|T(\mathrm{j}\omega_b)\right|^2 = \tfrac{1}{2} \), which leads (after algebra) to

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

For typical servo damping ratios \(0.5 \lesssim \zeta \lesssim 0.8\), the factor multiplying \( \omega_n \) is close to one, so \( \omega_b \approx \omega_n \). Combined with the approximate settling time formula \( t_s \approx \tfrac{4}{\zeta\omega_n} \), we obtain the useful rule

\[ \omega_b \approx \omega_n \approx \frac{4}{\zeta t_s} \quad \text{for} \quad 0.5 \lesssim \zeta \lesssim 0.8. \]

This gives a direct mapping from time-domain specifications \( (t_s, \zeta) \) to a target closed-loop bandwidth \( \omega_b \).

We now derive explicit relations between controller gain and bandwidth for a simple first-order plant, which already captures key design intuition used in many robotic servo loops (e.g., DC motor speed control).

3.1 Plant and controller

Let the plant be \( G(s) = \dfrac{1}{\tau s + 1} \), with time constant \( \tau > 0 \), and choose a pure proportional controller \( C(s) = K \) with gain \( K > 0 \). The loop transfer function is

\[ L(s) = C(s)G(s) = \frac{K}{\tau s + 1}. \]

The closed-loop transfer function with unity feedback is

\[ T(s) = \frac{L(s)}{1 + L(s)} = \frac{K}{\tau s + 1 + K}. \]

Factor out \(1+K\) to reveal first-order structure:

\[ T(s) = \frac{K}{1+K}\, \frac{1}{\dfrac{\tau}{1+K}s + 1}. \]

Thus the closed-loop time constant is \( \tau_{\mathrm{cl}} = \dfrac{\tau}{1+K} \), and if the steady-state gain \(K/(1+K)\) is close to one (i.e., for moderately large \(K\)), the effective closed-loop bandwidth is

\[ \omega_b = \frac{1}{\tau_{\mathrm{cl}}} = \frac{1+K}{\tau}. \]

Solving for the proportional gain gives a simple formula for achieving a desired bandwidth:

\[ K = \tau \,\omega_b - 1. \]

3.2 Relation to gain crossover

On the imaginary axis, \( L(\mathrm{j}\omega) = \dfrac{K}{1 + \mathrm{j}\tau\omega} \), so

\[ \left|L(\mathrm{j}\omega)\right|^2 = \frac{K^2}{1 + (\tau\omega)^2}. \]

The gain crossover frequency \( \omega_c \) solves \( \left|L(\mathrm{j}\omega_c)\right| = 1 \), hence

\[ \frac{K^2}{1 + (\tau\omega_c)^2} = 1 \quad \Rightarrow \quad (\tau\omega_c)^2 = K^2 - 1 \quad \Rightarrow \quad \omega_c = \frac{\sqrt{K^2 - 1}}{\tau}, \quad K > 1. \]

If we choose \( K = \tau \omega_b - 1 \) with \( \tau\omega_b \gg 1 \), then \( K \approx \tau \omega_b \) and \( \omega_c \approx \omega_b \). This justifies using the target bandwidth to pick the proportional gain in such first-order-like plants.

In more complex plants (with additional poles and zeros), the same principle holds qualitatively: we select \( \omega_b \), then tune the controller (gain and additional dynamics) so that \( \left|L(\mathrm{j}\omega)\right| \approx 1 \) near \( \omega_b \) with sufficient phase margin.

Many servo loops for robotic joints and precision motion stages are designed so that the dominant closed-loop poles form a second-order pair with specified damping ratio \( \zeta \) and natural frequency \( \omega_n \). Using the approximate relations from Section 2, we can map performance requirements directly to a target bandwidth.

4.1 From overshoot to damping ratio

For a standard second-order step response, the maximum overshoot \( M_p \) satisfies

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

Given an admissible overshoot (for example \( M_p \approx 0.1 \) for 10% overshoot), one solves this equation (numerically in practice) to obtain the required damping ratio \( \zeta \). For 10% overshoot one finds roughly \( \zeta \approx 0.6 \).

4.2 From settling time and damping ratio to bandwidth

The 2% settling time satisfies approximately \( t_s \approx \tfrac{4}{\zeta\omega_n} \). Combining this with the relation \( \omega_b \approx \omega_n \) from Section 2 yields

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

Example. Suppose we require \( t_s \leq 0.4 \,\mathrm{s} \) and \( M_p \leq 10\% \). Taking \( \zeta \approx 0.6 \) and \( t_s = 0.4 \,\mathrm{s} \),

\[ \omega_b \approx \frac{4}{0.6 \cdot 0.4} = \frac{4}{0.24} \approx 16.7 \,\mathrm{rad/s}. \]

A loop-shaping design would then seek a controller \( C(s) \) such that the closed-loop response is dominated by a pair of poles with natural frequency near \(16\)–\(20 \,\mathrm{rad/s}\) and damping ratio near 0.6, leading to a bandwidth in that range.

The target bandwidth \( \omega_b \) must reconcile competing objectives: fast tracking and disturbance rejection versus noise amplification, actuator limits, and robustness to unmodeled dynamics. The following guidelines are widely used in classical servo design:

• Tracking frequency range. If reference trajectories contain most of their energy below \( \omega_{\text{ref,max}} \), choose \( \omega_b \) roughly 3–5 times \( \omega_{\text{ref,max}} \) to obtain accurate tracking in that band.
• Disturbance spectrum. If dominant disturbances (e.g., periodic load torques in a robot) are below \( \omega_d \), a bandwidth several times \( \omega_d \) improves disturbance rejection.
• Noise and unmodeled dynamics. Sensor noise and high-frequency unmodeled dynamics often become significant above some frequency \( \omega_n \). To avoid amplification, the bandwidth is usually chosen so that \( \omega_b \ll \omega_n \), and additional high-frequency roll-off is introduced (treated in the next lessons).
• Actuator and structural limits. Very high bandwidth demands large control signals and can excite flexible modes. In robotic arms, a common heuristic is to keep the bandwidth of the joint servo below one-third to one-fifth of the lowest significant structural resonance frequency.
• Sampling (if digital control). For discretized controllers, the sampling frequency is typically chosen much larger than the bandwidth (for example, at least 10 times) to faithfully realize the intended continuous-time loop shape.

Once a feasible interval for \( \omega_b \) has been determined, loop shaping proceeds by selecting controller structure and tuning parameters so that \( \left|L(\mathrm{j}\omega)\right| \) crosses 0 dB near the chosen \( \omega_b \) with acceptable phase margin.

flowchart TD
  S["Start from performance and hardware limits"] --> B1["Choose candidate omega_b (tracking/disturbance)"]
  B1 --> B2["Check vs noise and unmodeled dynamics"]
  B2 --> B3["Check vs actuator and resonance limits"]
  B3 --> J{"All constraints satisfied?"}
  J -->|no| B1
  J -->|yes| D["Freeze target bandwidth and tune loop gain"]
        

We illustrate automatic gain selection for a first-order plant model using Python. The same pattern appears inside many robotic software stacks: for instance, the python-control library can be combined with roboticstoolbox to design joint servo loops based on simplified motor models.

We consider \( G(s) = \dfrac{1}{\tau s + 1} \) and choose proportional gain according to \( K = \tau \omega_b - 1 \), then numerically verify the bandwidth of the resulting closed loop.

import numpy as np
import control as ct   # python-control library
# In robotics, this plant can approximate a motor or joint velocity loop.

# Plant parameter
tau = 0.1  # seconds

# Target closed-loop bandwidth (rad/s)
omega_b_target = 20.0

# Proportional gain from the formula K = tau * omega_b - 1
K = tau * omega_b_target - 1.0
print(f"Designed proportional gain K = {K:.3f}")

# Define plant and controller
G = ct.tf([1.0], [tau, 1.0])
C = ct.tf([K], [1.0])

# Closed-loop transfer function T(s) = L(s)/(1+L(s))
T = ct.feedback(C * G, 1)

# Simple numerical bandwidth estimate: find the first frequency where |T(jw)| <= 1/sqrt(2)
def estimate_bandwidth(sys, w_min=1e-1, w_max=1e3, n=2000):
    w = np.logspace(np.log10(w_min), np.log10(w_max), n)
    # freqresp returns complex frequency response over w
    _, mag, _ = ct.bode(sys, w, Plot=False)
    mag = np.squeeze(mag)  # magnitude as array
    target = mag[0] / np.sqrt(2.0)  # -3 dB relative to low-frequency value
    idx = np.where(mag <= target)[0]
    if idx.size == 0:
        return None
    return w[idx[0]]

omega_b_est = estimate_bandwidth(T)
print(f"Estimated bandwidth omega_b ≈ {omega_b_est:.2f} rad/s")

# Time-domain check: step response
t = np.linspace(0, 0.6, 600)
t_out, y_out = ct.step_response(T, t)

# A robotics application could wrap this into an automatic tuning routine for joint servos.
      

In a robotic joint controller implemented in Python (e.g., using ROS 2 with rclpy and roboticstoolbox), a similar computation would be used to select a default proportional gain based on an identified time constant \( \tau \) and a desired bandwidth \( \omega_b \), after which additional integral or derivative action would be tuned.

We now sketch implementations of the bandwidth-based gain rule in C++, Java, MATLAB/Simulink, and Wolfram Mathematica. In C++ and Java, such code would be embedded in real-time control loops (e.g., robot joint controllers). In MATLAB and Mathematica, it would support analysis and off-line design.

7.1 C++ (with Eigen/ROS-style context)

The snippet below uses the analytic relation \( \omega_b = \dfrac{1+K}{\tau} \) for a first-order plant. In a realistic robotic system, this logic would be included in a ROS ros_control controller, with dynamics represented using Eigen.

#include <iostream>

// Compute proportional gain for a first-order plant G(s) = 1/(tau s + 1)
// to achieve target closed-loop bandwidth omega_b (rad/s).
double computeGainFromBandwidth(double tau, double omega_b) {
    // K = tau * omega_b - 1
    return tau * omega_b - 1.0;
}

// Compute corresponding closed-loop bandwidth (first-order model)
double closedLoopBandwidth(double tau, double K) {
    return (1.0 + K) / tau;
}

int main() {
    double tau = 0.05;          // identified time constant (s)
    double omega_b_target = 40.0; // target bandwidth (rad/s)

    double K = computeGainFromBandwidth(tau, omega_b_target);
    std::cout << "Designed gain K = " << K << std::endl;

    double omega_b = closedLoopBandwidth(tau, K);
    std::cout << "Closed-loop bandwidth ≈ " << omega_b << " rad/s" << std::endl;

    // In a robotics controller, K would be used as the proportional gain in a joint servo.
    return 0;
}
      

7.2 Java (e.g., for ROSJava-based robotics applications)

Java-based robotics frameworks (such as ROSJava) can use the same formulas. Linear algebra for more complex models can be handled by libraries like EJML or Apache Commons Math.

public class FirstOrderServo {

    private final double tau;   // plant time constant
    private double K;           // proportional gain

    public FirstOrderServo(double tau) {
        this.tau = tau;
    }

    public void tuneForBandwidth(double omegaBTarget) {
        // K = tau * omega_b - 1
        this.K = tau * omegaBTarget - 1.0;
    }

    public double getGain() {
        return K;
    }

    public double getClosedLoopBandwidth() {
        return (1.0 + K) / tau;
    }

    public static void main(String[] args) {
        FirstOrderServo servo = new FirstOrderServo(0.1);
        servo.tuneForBandwidth(20.0);

        System.out.println("Proportional gain K = " + servo.getGain());
        System.out.println("Estimated bandwidth = " + servo.getClosedLoopBandwidth() + " rad/s");

        // In a ROSJava node, the gain K would be applied to the position or velocity error.
    }
}
      

7.3 MATLAB/Simulink (with Control System and Robotics System Toolboxes)

MATLAB provides built-in functions for frequency-response analysis and direct bandwidth computation. The design below can be integrated into Simulink by using a Transfer Fcn block for \( G(s) \) and a Gain block for \( K \); joint-level models in robotic arms can be created using Robotics System Toolbox and linearized for servo design.

% Plant parameter
tau = 0.1;

% Desired bandwidth (rad/s)
omega_b_target = 20;

% Proportional gain
K = tau * omega_b_target - 1;

% Plant and controller
G = tf(1, [tau 1]);
C = K;

% Closed-loop transfer function
T = feedback(C * G, 1);

% MATLAB's built-in bandwidth function
[omega_b_est, ~] = bandwidth(T);

fprintf("Designed K = %.3f\n", K);
fprintf("Estimated bandwidth omega_b ≈ %.2f rad/s\n", omega_b_est);

% In Simulink:
%  - Use a Transfer Fcn block with numerator [1] and denominator [tau 1].
%  - Use a Gain block with value K.
%  - Connect them in a unity feedback loop and verify bandwidth with Bode and step plots.
      

7.4 Wolfram Mathematica (symbolic and numerical design)

Mathematica can handle symbolic and numerical aspects of bandwidth-based tuning within its control systems functionality, which is suitable for deriving formulas and for prototyping robotic servo controllers.

(* Plant parameter and target bandwidth *)
tau = 0.1;
omegaBTarget = 20.0;

(* Gain from K = tau * omega_b - 1 *)
K = tau * omegaBTarget - 1;

(* Define plant and controller as transfer functions *)
s = LaplaceTransformVariable[s];
G[s_] := 1/(tau*s + 1);
C[s_] := K;

T[s_] := (C[s]*G[s])/(1 + C[s]*G[s]);

(* Convert to TransferFunctionModel for analysis *)
tf = TransferFunctionModel[T[s], s];

Print["Designed gain K = ", K];

(* Bode plot and approximate bandwidth inspection *)
BodePlot[tf, {0.1, 100}]

(* Step response for time-domain verification *)
StepResponsePlot[tf, {0, 1}]
      

For more complex robotic systems, Mathematica can symbolically derive linearized models of manipulator dynamics and then apply similar bandwidth-based rules to select loop gains.

Problem 1 (First-order bandwidth-based gain design). A plant is modeled as \( G(s) = \dfrac{1}{0.2 s + 1} \) (time constant \( \tau = 0.2 \,\mathrm{s} \)). We use unity feedback and a proportional controller \( C(s) = K \). Design \( K \) so that the closed-loop bandwidth is approximately \( \omega_b = 10 \,\mathrm{rad/s} \). Compute the resulting closed-loop time constant and 2% settling time.

Solution. For a first-order closed-loop system, \( \omega_b = \dfrac{1+K}{\tau} \). Hence

\[ K = \tau \omega_b - 1 = 0.2 \cdot 10 - 1 = 2 - 1 = 1. \]

The closed-loop time constant is \( \tau_{\mathrm{cl}} = \dfrac{\tau}{1+K} = \dfrac{0.2}{2} = 0.1 \,\mathrm{s} \). The 2% settling time is \( t_s \approx 4\tau_{\mathrm{cl}} = 0.4 \,\mathrm{s} \). By the first-order analysis, this design achieves the requested bandwidth and settling time.

Problem 2 (From step specifications to bandwidth). A second-order servo loop should have 2% settling time no larger than \(0.3 \,\mathrm{s}\) and overshoot no larger than 5%. Approximate the required damping ratio \( \zeta \) and a suitable bandwidth \( \omega_b \).

Solution. For 5% overshoot, solving \( M_p = \exp\!\big(-\tfrac{\zeta\pi}{\sqrt{1-\zeta^2}}\big) \approx 0.05 \) numerically yields approximately \( \zeta \approx 0.7 \). The 2% settling-time relation \( t_s \approx \tfrac{4}{\zeta\omega_n} \) gives

\[ \omega_n \approx \frac{4}{\zeta t_s} \approx \frac{4}{0.7 \cdot 0.3} = \frac{4}{0.21} \approx 19 \,\mathrm{rad/s}. \]

For \( \zeta \approx 0.7 \), we have \( \omega_b \approx \omega_n \approx 19 \,\mathrm{rad/s} \). Therefore a target bandwidth of roughly \(20 \,\mathrm{rad/s}\) is consistent with the step response specification.

Problem 3 (Gain crossover and bandwidth for a proportional loop). For the first-order plant of Problem 1 with proportional controller \( C(s) = K \), derive the gain crossover frequency \( \omega_c \) and show that for large enough \( K \), the ratio \( \omega_c / \omega_b \) approaches 1.

Solution. We have \( L(s) = \dfrac{K}{0.2 s + 1} \), so \( L(\mathrm{j}\omega) = \dfrac{K}{1 + \mathrm{j} 0.2 \omega} \) and

\[ \left|L(\mathrm{j}\omega)\right|^2 = \frac{K^2}{1 + (0.2\omega)^2}. \]

The gain crossover frequency satisfies \( \left|L(\mathrm{j}\omega_c)\right| = 1 \), hence

\[ \frac{K^2}{1 + (0.2\omega_c)^2} = 1 \quad \Rightarrow \quad (0.2\omega_c)^2 = K^2 - 1 \quad \Rightarrow \quad \omega_c = \frac{\sqrt{K^2 - 1}}{0.2}. \]

The bandwidth is \( \omega_b = \dfrac{1+K}{0.2} \). The ratio is

\[ \frac{\omega_c}{\omega_b} = \frac{\sqrt{K^2 - 1}}{1 + K}. \]

For large \( K \), we have \( \sqrt{K^2 - 1} \approx K \), so \( \omega_c / \omega_b \approx K /(1+K) \to 1 \) as \( K \to \infty \). This confirms that for sufficiently large proportional gain the bandwidth and gain crossover are nearly equal.

Problem 4 (Choosing bandwidth under disturbance and noise constraints). A robot joint is subject to a periodic load disturbance with dominant frequency \( \omega_d = 5 \,\mathrm{rad/s} \). The position sensor exhibits significant noise starting around \( \omega_n = 80 \,\mathrm{rad/s} \). Propose a reasonable range for the closed-loop bandwidth and explain your reasoning.

Solution. To attenuate the load disturbance at \( \omega_d = 5 \,\mathrm{rad/s} \), we want \( \omega_b \) several times larger, say \( \omega_b \geq 3 \omega_d \approx 15 \,\mathrm{rad/s} \). To avoid amplifying sensor noise, we want the bandwidth well below the noise onset \( \omega_n = 80 \,\mathrm{rad/s} \); for example, keeping \( \omega_b \leq \omega_n / 4 = 20 \,\mathrm{rad/s} \) provides a comfortable margin. A reasonable design range is thus \( \omega_b \in [15, 20] \,\mathrm{rad/s} \), after which loop shaping and margin checks can refine the exact value.

flowchart TD
  D["Disturbance at omega_d = 5"] --> R1["Require omega_b >= 3 * omega_d ≈ 15"]
  N["Noise rises near omega_n = 80"] --> R2["Require omega_b <= omega_n / 4 ≈ 20"]
  R1 --> J["Intersection: 15 <= omega_b <= 20"]
  R2 --> J
  J --> S["Select omega_b in [15, 20] and tune loop gain accordingly"]
        

Problem 5 (Mapping a specification to gain in software). For a plant with identified time constant \( \tau = 0.05 \,\mathrm{s} \) in a robotic actuator, we wish to implement in software (Python, C++, or Java) the automatic gain selection \( K = \tau \omega_b - 1 \) for a desired bandwidth \( \omega_b = 50 \,\mathrm{rad/s} \). Compute \( K \) and the resulting bandwidth. Is the first-order approximation likely to be accurate if higher-order dynamics are negligible above \( 200 \,\mathrm{rad/s} \)?

Solution. The gain is

\[ K = \tau \omega_b - 1 = 0.05 \cdot 50 - 1 = 2.5 - 1 = 1.5. \]

The closed-loop bandwidth according to the first-order formula is \( \omega_b = \dfrac{1+K}{\tau} = \dfrac{2.5}{0.05} = 50 \,\mathrm{rad/s} \), as intended. Since higher-order effects only become significant above \(200 \,\mathrm{rad/s}\), the designed bandwidth at \(50 \,\mathrm{rad/s}\) lies well inside the region where the first-order model is valid, so the approximation is expected to be quite accurate, provided phase margin is verified by Bode or Nyquist analysis.

In this lesson we defined closed-loop bandwidth rigorously and related it to the loop transfer function and gain crossover. For first-order plants with proportional control, we derived explicit formulas linking time constant, loop gain, and bandwidth, and we showed that for well-shaped loops the bandwidth closely tracks the natural frequency of the dominant second-order approximation.

Practical guidelines then connected desired tracking and disturbance rejection properties, noise and actuator limits, and structural resonances to an acceptable bandwidth range. Finally, we illustrated how bandwidth-based gain selection can be implemented in Python, C++, Java, MATLAB/Simulink, and Mathematica, as is commonly done in robotic servo controller design.