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

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

Stability of the closed-loop system is determined by the poles of \( T(s) \), i.e., the roots of the characteristic equation

\[ 1 + L(s) = 0. \]

As you learned in earlier chapters, asymptotic stability requires that all closed-loop poles lie in the open left half-plane: \( \Re(s) < 0 \).

Bode plots display the frequency response of \( L(j\omega) \): the magnitude \( |L(j\omega)| \) (in dB) and the phase \( \angle L(j\omega) \) (in degrees or radians). Although they show only steady-state sinusoidal behavior, they contain rich information about stability and transient performance of the closed-loop system.

Let \( L(j\omega) = |L(j\omega)| e^{j\phi(\omega)} \). Then

\[ 1 + L(j\omega) = 1 + |L(j\omega)|e^{j\phi(\omega)}. \]

The squared magnitude of this complex quantity is

\[ |1 + L(j\omega)|^2 = \bigl(1 + |L|\cos\phi\bigr)^2 + \bigl(|L|\sin\phi\bigr)^2 = 1 + |L|^2 + 2|L|\cos\phi, \]

where, for brevity, we write \( |L| = |L(j\omega)| \), \( \phi = \phi(\omega) \). The closed-loop gain magnitude is

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

Instability is approached when \( |1 + L(j\omega)| \) becomes very small for some frequency, so the Bode plot of \( L(j\omega) \) gives indirect but powerful information about the distance of \( 1 + L(j\omega) \) from zero in the complex plane.

A particularly important frequency is the gain crossover frequency \( \omega_{gc} \), defined by

\[ |L(j\omega_{gc})| = 1 \quad \Leftrightarrow \quad 20\log_{10}|L(j\omega_{gc})| = 0 \text{ dB}. \]

At this frequency the open-loop magnitude is unity, so the closed-loop response is highly sensitive to the phase of \( L(j\omega_{gc}) \). Write

\[ L(j\omega_{gc}) = e^{j\phi_{gc}}, \quad \phi_{gc} = \phi(\omega_{gc}). \]

Then

\[ 1 + L(j\omega_{gc}) = 1 + e^{j\phi_{gc}}, \quad |1 + L(j\omega_{gc})| = \sqrt{2 + 2\cos\phi_{gc}} = 2\left|\cos\frac{\phi_{gc}}{2}\right|. \]

The critical (dangerous) case is \( \phi_{gc} = -\pi \) (i.e., \(-180^\circ\)), where \( 1 + L(j\omega_{gc}) = 0 \), leading to instability. Therefore we define the phase margin as

\[ \text{PM} = \pi + \phi_{gc} \quad \text{(radians)} \quad \text{or} \quad \text{PM} = 180^\circ + \phi_{gc} \quad \text{(degrees)}. \]

A large positive phase margin means that at the point where \( |L(j\omega)| = 1 \), the phase is still far from \(-180^\circ\), so \( 1 + L(j\omega) \) maintains a comfortable distance from zero.

Similarly, the phase crossover frequency \( \omega_{pc} \) is defined by

\[ \phi(\omega_{pc}) = -\pi \quad \text{(or } -180^\circ \text{)}. \]

At this frequency the open-loop vector points opposite the real axis; instability is approached when the magnitude \( |L(j\omega_{pc})| \) becomes large. We define the gain margin as

\[ \text{GM} = \frac{1}{|L(j\omega_{pc})|}, \quad \text{GM}_{\text{dB}} = -20\log_{10}|L(j\omega_{pc})|. \]

Intuitively, the gain margin is the factor by which the loop gain can be multiplied before the gain crossover frequency coincides with a phase of \(-180^\circ\). A large gain margin indicates robust stability with respect to gain changes.

A complete theoretical justification of these stability margins uses the Nyquist criterion, which you will study in a later chapter. In this lesson we use the margins as practical indicators extracted from the Bode plot, and relate them to time-domain performance.

Many servo systems (e.g., robot joint controllers) are dominated by a complex-conjugate pair of closed-loop poles. The closed-loop behavior is approximately second order:

\[ T(s) \approx \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \]

where \( \omega_n \) is the natural frequency and \( \zeta \) the damping ratio (\( 0 < \zeta < 1 \) for underdamped systems).

For this standard second-order form:

• The (2 % criterion) settling time is approximately \( t_s \approx \frac{4}{\zeta \omega_n} \).
• The peak overshoot to a unit step is

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

• The closed-loop resonant frequency (if it exists) is

  \[ \omega_r = \omega_n\sqrt{1 - 2\zeta^2}, \quad \text{for } \zeta < \frac{1}{\sqrt{2}}. \]

The frequency response magnitude of this second-order system is

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

Differentiating with respect to \( \omega \) and setting the derivative to zero yields the expression for \( \omega_r \) above. Evaluating \( |T(j\omega_r)| \) gives the resonant peak \( M_r \), which for \( 0 < \zeta < \frac{1}{\sqrt{2}} \) simplifies to

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

In many practical systems, the phase margin determined from the Bode plot of \( L(j\omega) \) is strongly correlated with the effective damping ratio \( \zeta \) of the dominant closed-loop poles. For typical control designs with \( 30^\circ \lesssim \text{PM} \lesssim 70^\circ \), a rough rule-of-thumb is

\[ \zeta \approx \frac{\text{PM}}{100} \quad \text{(PM in degrees)}. \]

Thus:

• PM around \( 45^\circ \) corresponds to \( \zeta \approx 0.4\text{–}0.5 \) and about 10 %–20 % overshoot.
• PM around \( 60^\circ \) corresponds to \( \zeta \approx 0.6 \) and much smaller overshoot.

The closed-loop bandwidth \( \omega_b \) is typically defined as the frequency at which \( |T(j\omega_b)| \) drops to \( 1/\sqrt{2} \) of its low-frequency value, i.e., by 3 dB. For moderately damped second-order systems one often has the approximation

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

Combining these relations, Bode plots allow you to estimate:

• Whether the closed-loop system is stable (margins positive).
• Rough overshoot (via correlation of phase margin with damping).
• Speed of response (via bandwidth and approximate settling time).

The following workflow summarizes how to interpret a Bode plot of \( L(j\omega) \) for a unity-feedback system to assess stability and performance:

flowchart TD
  A["Start with Bode of L(jw)"] --> B["Locate 0 dB crossing: w_gc"]
  B --> C["Read phase at w_gc: phi_gc"]
  C --> D["Compute phase margin: PM = 180 + phi_gc (deg)"]
  D --> E["Check PM: small PM -> lightly damped / oscillatory"]
  E --> F["Estimate dominant damping from PM"]
  F --> G["Approx. bandwidth from closed-loop magnitude or w_gc"]
  G --> H["Infer rise time / settling time from bandwidth"]
  H --> I["Decide if design meets specs; if not, reshape L(jw)"]
        

In later chapters (lead/lag compensation, loop shaping) you will learn systematic ways to modify \( C(s) \) so that \( L(j\omega) \) achieves desired margins and bandwidth.

In Python, the python-control library provides functions for Bode plots and margin computation. Robotic models (e.g., link or joint dynamics) can be obtained from roboticstoolbox-python and then analyzed via python-control.

Example: a second-order plant \( G(s) = \dfrac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2} \) with proportional controller \( C(s) = K \).

import numpy as np
import control as ct  # python-control
# For robotics models you can use:
# from roboticstoolbox import DHRobot, RevoluteDH, etc.

# Design parameters
wn = 10.0      # natural frequency [rad/s]
zeta = 0.4     # damping ratio
K = 2.0        # proportional gain

# Plant G(s) = wn^2 / (s^2 + 2*zeta*wn s + wn^2)
numG = [wn**2]
denG = [1.0, 2.0*zeta*wn, wn**2]
G = ct.TransferFunction(numG, denG)

# Controller C(s) = K
C = ct.TransferFunction([K], [1.0])

# Loop transfer function L(s) and closed-loop T(s)
L = C * G
T = ct.feedback(L, 1)  # unity feedback

# Bode plot of L(s) and computation of margins
w = np.logspace(-1, 2, 500)  # frequency grid
mag, phase, omega = ct.bode(L, w, Plot=False)

gm, pm, w_pc, w_gc = ct.margin(L)
print(f"Gain margin (dB): {20*np.log10(gm):.2f}")
print(f"Phase margin (deg): {pm:.2f}")
print(f"Gain crossover freq w_gc: {w_gc:.2f} rad/s")
print(f"Phase crossover freq w_pc: {w_pc:.2f} rad/s")

# Closed-loop bandwidth from T(s) magnitude
magT, phaseT, omegaT = ct.bode(T, w, Plot=False)
# Find -3 dB bandwidth (magnitude drop by factor 1/sqrt(2))
mag0 = magT[0]
idx_bw = np.where(magT < mag0/np.sqrt(2))[0]
if idx_bw.size > 0:
    wb = omegaT[idx_bw[0]]
    print(f"Approximate closed-loop bandwidth wb: {wb:.2f} rad/s")
    ts_approx = 4.0 / wb
    print(f"Approximate settling time ts ~ 4/wb: {ts_approx:.2f} s")

# For visualization (in a Jupyter notebook) you can call:
# ct.bode_plot(L)
# ct.bode_plot(T)
      

In a robotic application, G(s) would represent the linearized joint or end-effector dynamics, while C(s) is a joint-space or task-space controller. The Bode plot of L(s) reveals whether the chosen gains yield sufficient stability margins for flexible links, motor inertia variations, or payload changes.

In C++, there is no de facto standard control library, but the standard library's std::complex combined with Eigen (for linear algebra) allows custom Bode computation. In ROS-based robotics systems, packages such as ros_control and control_toolbox implement controllers whose dynamics can be analyzed offline using such utilities.

Below is a simple C++ program that evaluates the magnitude and phase of a second-order transfer function at logarithmically spaced frequencies.

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

int main() {
    using std::complex;
    using std::cout;
    using std::endl;

    double wn = 10.0;   // natural frequency
    double zeta = 0.4;  // damping ratio
    double K = 2.0;     // proportional gain

    // Frequencies for Bode computation (logspace)
    std::vector<double> omega;
    int N = 200;
    double wmin = 0.1, wmax = 100.0;
    double logwmin = std::log10(wmin), logwmax = std::log10(wmax);
    for (int i = 0; i < N; ++i) {
        double lw = logwmin + (logwmax - logwmin) * i / (N - 1);
        omega.push_back(std::pow(10.0, lw));
    }

    complex<double> j(0.0, 1.0);

    double pm_deg = 0.0;
    double w_gc = 0.0;
    bool found_gc = false;

    cout << "omega, mag_dB, phase_deg" << endl;

    for (double w : omega) {
        // s = j*w
        complex<double> s = j * w;

        // Plant G(s) = wn^2 / (s^2 + 2*zeta*wn s + wn^2)
        complex<double> numG(wn * wn, 0.0);
        complex<double> denG = s * s + 2.0 * zeta * wn * s
                                 + complex<double>(wn * wn, 0.0);
        complex<double> G = numG / denG;

        // Controller C(s) = K
        complex<double> C(K, 0.0);

        complex<double> L = C * G;

        double mag = std::abs(L);
        double mag_dB = 20.0 * std::log10(mag);
        double phase_rad = std::arg(L);
        double phase_deg = phase_rad * 180.0 / M_PI;

        cout << w << ", " << mag_dB << ", "
             << phase_deg << endl;

        // Rough gain crossover detection: |L| ~ 1 (0 dB)
        if (!found_gc && std::abs(mag - 1.0) < 0.02) {
            found_gc = true;
            w_gc = w;
            pm_deg = 180.0 + phase_deg;
        }
    }

    if (found_gc) {
        std::cout << "Approx gain crossover w_gc = "
                  << w_gc << " rad/s" << std::endl;
        std::cout << "Approx phase margin PM = "
                  << pm_deg << " deg" << std::endl;
    } else {
        std::cout << "Gain crossover not found in scanned range."
                  << std::endl;
    }

    return 0;
}
      

In a robot controller development workflow, you might log identified plant parameters (inertia, damping, stiffness) from experiments, build a C++ utility like this to compute stability margins, and then tune the gains used by ros_control PID or state-space controllers.

In Java, numerical libraries such as EJML or Apache Commons Math can be used to implement Bode computations. In educational and industrial robotics, frameworks like WPILib (used in FRC robots) provide control primitives; dynamic models can be exported and analyzed with custom Java code.

Below is a minimal Java snippet that computes magnitude and phase of a second-order plant with proportional control at a few frequencies.

public class BodeExample {
    public static void main(String[] args) {
        double wn = 10.0;
        double zeta = 0.4;
        double K = 2.0;

        double[] omega = {0.5, 1.0, 5.0, 10.0, 20.0, 50.0};

        System.out.println("omega, mag_dB, phase_deg");

        for (double w : omega) {
            // Complex arithmetic via manual real/imag parts
            double sr = 0.0;
            double si = w; // s = j*w

            // G(s) = wn^2 / (s^2 + 2*zeta*wn s + wn^2)
            double numGr = wn * wn;
            double numGi = 0.0;

            // s^2
            double s2r = -w * w;
            double s2i = 0.0;

            // 2*zeta*wn*s
            double t = 2.0 * zeta * wn;
            double tSr = 0.0;
            double tSi = t * w;

            double denGr = s2r + tSr + wn * wn;
            double denGi = s2i + tSi + 0.0;

            double denomNorm2 = denGr * denGr + denGi * denGi;

            double Gr = (numGr * denGr + numGi * denGi) / denomNorm2;
            double Gi = (numGi * denGr - numGr * denGi) / denomNorm2;

            // C(s) = K
            double Cr = K;
            double Ci = 0.0;

            // L(s) = C(s) * G(s)
            double Lr = Cr * Gr - Ci * Gi;
            double Li = Cr * Gi + Ci * Gr;

            double mag = Math.hypot(Lr, Li);
            double mag_dB = 20.0 * Math.log10(mag);
            double phase_rad = Math.atan2(Li, Lr);
            double phase_deg = phase_rad * 180.0 / Math.PI;

            System.out.printf("%6.2f, %8.2f, %8.2f%n",
                              w, mag_dB, phase_deg);
        }
    }
}
      

This kind of computation can be wrapped into library utilities for automatic margin checking, which is particularly useful when designing controllers for autonomous mobile robots or robotic arms in Java-based environments (for example, simulation or competition frameworks).

MATLAB's Control System Toolbox provides direct functions for Bode plots and margin computation. Robotic manipulators and mobile robots can be modeled using the Robotics System Toolbox and linearized for frequency-domain analysis.

wn   = 10;     % natural frequency
zeta = 0.4;    % damping ratio
K    = 2;      % proportional gain

s = tf('s');

G = wn^2 / (s^2 + 2*zeta*wn*s + wn^2);  % plant
C = K;                                   % controller

L = C*G;
T = feedback(L, 1);                      % closed-loop

% Bode plot with margins
figure;
margin(L); grid on;
title('Loop transfer function L(s) with stability margins');

[gm, pm, w_pc, w_gc] = margin(L);
fprintf('Gain margin (dB): %g\n', 20*log10(gm));
fprintf('Phase margin (deg): %g\n', pm);
fprintf('w_gc = %g rad/s, w_pc = %g rad/s\n', w_gc, w_pc);

% Closed-loop bandwidth
figure;
bode(T); grid on;
title('Closed-loop transfer function T(s)');

% Estimate -3 dB bandwidth
[magT, phaseT, w] = bode(T);
magT = squeeze(magT);
w = squeeze(w);
mag0 = magT(1);
idx = find(magT < mag0/sqrt(2), 1, 'first');
if ~isempty(idx)
    wb = w(idx);
    fprintf('Approx. bandwidth wb = %g rad/s\n', wb);
    fprintf('Approx. settling time ts ~ 4/wb = %g s\n', 4/wb);
end

% Robotics note:
% For a robot joint model, you might derive a state-space model using
% robotics toolbox functions, then convert to tf and repeat the same steps.

% Example Simulink usage:
% - Build a unity feedback loop with C(s) and G(s) blocks.
% - Use the Linear Analysis Tool to linearize the model about an
%   operating point and generate Bode and Nyquist plots automatically.
      

In a robot arm application, G would represent the linearized joint dynamics around a fixed pose. Bode and margin analysis allow you to choose gains that guarantee stability over variations in payload and link inertia.

Wolfram Mathematica provides symbolic manipulation and direct plotting of frequency responses. This is useful for analytically exploring how parameters \( K, \zeta, \omega_n \) affect stability margins and bandwidth.

(* Parameters *)
wn   = 10.0;
zeta = 0.4;
K    = 2.0;

s = I*ω;

(* Loop transfer function L(s) *)
L[ω_] := Module[{num, den},
  num = K*wn^2;
  den = (s^2 + 2*zeta*wn*s + wn^2) /. s -> I*ω;
  num/den
];

(* Magnitude (dB) and phase (deg) *)
magdB[ω_]  := 20*Log10[Abs[L[ω]]];
phaseDeg[ω_] := Arg[L[ω]]*180/Pi;

(* Bode-like plots *)
magPlot = Plot[magdB[ω], {ω, 0.1, 100},
  AxesLabel -> {"ω (rad/s)", "Magnitude (dB)"},
  PlotRange -> All
];

phasePlot = Plot[phaseDeg[ω], {ω, 0.1, 100},
  AxesLabel -> {"ω (rad/s)", "Phase (deg)"},
  PlotRange -> All
];

(* Show the plots *)
GraphicsRow[{magPlot, phasePlot}]

(* Solve approximately for gain crossover frequency: |L(jω)| == 1 *)
wgcSol = FindRoot[Abs[L[ω]] - 1.0 == 0, {ω, wn}];
wgc = ω /. wgcSol;
phiGc = phaseDeg[wgc];
pm = 180 + phiGc;

Print["Approx gain crossover w_gc = ", wgc];
Print["Phase at w_gc = ", phiGc, " deg"];
Print["Phase margin PM ≈ ", pm, " deg"];
      

For robotics, symbolic models of link inertia and actuator dynamics can be manipulated to obtain analytic expressions for \( L(s) \). Studying how the Bode plot changes with symbolic parameters yields insight into how mechanical design choices (e.g., gear ratios) affect achievable control performance.

Problem 1 (Phase Margin and Damping): A unity-feedback system has loop transfer function \( L(s) \). From its Bode plot, the gain crossover frequency is \( \omega_{gc} = 8 \,\text{rad/s} \), and the phase at that frequency is \( \phi(\omega_{gc}) = -135^\circ \).
(a) Compute the phase margin.
(b) Estimate the effective damping ratio of the dominant closed-loop poles.
(c) Estimate the settling time.

Solution:

(a) Phase margin is

\[ \text{PM} = 180^\circ + \phi(\omega_{gc}) = 180^\circ - 135^\circ = 45^\circ. \]

(b) Using the rough rule \( \zeta \approx \text{PM}/100 \) (PM in degrees),

\[ \zeta \approx \frac{45}{100} = 0.45. \]

For \( \zeta \approx 0.45 \), the step overshoot is on the order of 15 %–20 %.

(c) The closed-loop bandwidth is typically close to \( \omega_{gc} \), so take \( \omega_b \approx 8 \,\text{rad/s} \). Then

\[ t_s \approx \frac{4}{\omega_b} \approx \frac{4}{8} = 0.5 \,\text{s}. \]

Alternatively, using the second-order approximation \( t_s \approx \frac{4}{\zeta\omega_n} \) with \( \omega_n \approx \omega_b \) gives a similar result.

Problem 2 (Gain Margin from Bode Plot): For a unity-feedback system, the Bode phase plot shows that the phase crosses \( -180^\circ \) at \( \omega_{pc} = 5 \,\text{rad/s} \). The magnitude plot at this frequency is \( 20\log_{10}|L(j\omega_{pc})| = -12 \,\text{dB} \).
(a) Compute the gain margin in linear units and in dB.
(b) Comment on the robustness of the system with respect to gain increases.

Solution:

(a) At the phase crossover frequency,

\[ |L(j\omega_{pc})| = 10^{-12/20} = 10^{-0.6} \approx 0.251. \]

The gain margin is

\[ \text{GM} = \frac{1}{|L(j\omega_{pc})|} \approx \frac{1}{0.251} \approx 3.98, \quad \text{GM}_{\text{dB}} = 20\log_{10}(3.98) \approx 12 \,\text{dB}. \]

(b) A gain margin of about 4 (12 dB) means that the loop gain could be increased by almost a factor of 4 before the system becomes marginally stable. This is generally considered a comfortable safety margin for many industrial servo applications.

Problem 3 (Resonant Peak and Damping Ratio): A closed-loop system has a measured resonant peak in its magnitude response of \( M_r = 1.8 \). Assuming the response is dominated by a single pair of complex poles, estimate the damping ratio \( \zeta \).

Solution:

For a standard second-order system with \( 0 < \zeta < \frac{1}{\sqrt{2}} \),

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

We need to solve \( 1.8 = \frac{1}{2\zeta\sqrt{1 - \zeta^2}} \). Rearranging,

\[ 2\zeta\sqrt{1 - \zeta^2} = \frac{1}{1.8}. \]

Square both sides:

\[ 4\zeta^2(1 - \zeta^2) = \frac{1}{1.8^2}. \]

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

\[ 4x(1 - x) = \frac{1}{1.8^2} \quad \Rightarrow \quad 4x - 4x^2 = \frac{1}{1.8^2}. \]

This is a quadratic in \( x \) that can be solved analytically or numerically. Solving numerically gives \( \zeta \approx 0.3 \). Thus the system is lightly damped and likely to exhibit significant overshoot.

Problem 4 (Bandwidth and Settling Time): The closed-loop transfer function of a servo axis has a measured bandwidth \( \omega_b = 15 \,\text{rad/s} \) (defined as the frequency where the magnitude has dropped by 3 dB). Assuming the response is approximately second order and moderately damped, estimate the settling time and comment on what would happen to overshoot if you increase bandwidth by changing controller gains.

Solution:

For moderately damped systems, \( \omega_b \approx \omega_n \) and \( t_s \approx \frac{4}{\omega_b} \), so

\[ t_s \approx \frac{4}{15} \approx 0.27 \,\text{s}. \]

Increasing bandwidth (e.g., by raising loop gain) usually decreases settling time but also reduces phase margin, which in turn lowers effective damping \( \zeta \). Therefore, overshoot will generally increase. Bode plots help balance the trade-off between speed (bandwidth) and overshoot (damping).

Problem 5 (Qualitative Design from Bode): A Bode plot of the loop transfer function \( L(j\omega) \) shows:

• Phase margin about \( 25^\circ \),
• Gain margin about 6 dB,
• Closed-loop bandwidth close to the first flexible mode of a robot arm.

Qualitatively describe how you would modify \( C(s) \) to obtain a more robust design.

Solution:

A phase margin of \( 25^\circ \) and gain margin of 6 dB are relatively small, indicating the closed-loop poles are lightly damped and close to instability, especially near the flexible mode. One possible strategy is:

• Reduce the low- and mid-frequency loop gain to increase both phase and gain margin (improving robustness to parameter variations).
• Introduce a phase-lead compensator to add positive phase around the gain crossover frequency, increasing phase margin without excessive loss of bandwidth.
• Implement notch or low-pass filtering to attenuate the flexible mode region, ensuring the loop gain is small where the mechanical resonance is strong.

All of these modifications correspond to reshaping \( L(j\omega) \) via controller design, which you will study systematically in later chapters (lead/lag compensation and loop shaping).

In this lesson we linked Bode plots of the loop transfer function \( L(s) = C(s)G(s) \) to closed-loop stability and performance. By analyzing the gain crossover and phase crossover frequencies, we introduced gain and phase margins as practical measures of stability. We related phase margin to effective damping of the dominant closed-loop poles, and used resonant peak and bandwidth to infer overshoot and settling time. Finally, we implemented these concepts in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, highlighting their role in the analysis and design of robotic control loops.