We consider a unity-feedback configuration with plant \( G(s) \) and controller \( K(s) \). The loop transfer function is

\[ L(s) = K(s)G(s), \quad T(s) = \frac{Y(s)}{R(s)} = \frac{L(s)}{1+L(s)}, \quad S(s) = \frac{R(s)-Y(s)}{R(s)} = \frac{1}{1+L(s)}. \]

The Nichols chart represents the open-loop response \( L(\mathrm{j}\omega) \) in terms of \( (20\log_{10}|L(\mathrm{j}\omega)|,\angle L(\mathrm{j}\omega)) \). On top of this chart we overlay:

• Closed-loop magnitude contours for \( |T(\mathrm{j}\omega)| = M \) (so-called M-circles).
• Sensitivity magnitude contours for \( |S(\mathrm{j}\omega)| = N \) (so-called N-circles).

Controller design using the Nichols chart consists of choosing a realizable controller \( K(s) \) so that the Nichols locus of \( L(s) = K(s)G(s) \) passes through prescribed regions determined by these contours and by gain/phase margin requirements. For many motion and robotic joint control problems, \( G(s) \) is a low-order, strictly proper transfer function obtained by linearizing the actuator and load dynamics around an operating point.

flowchart TD
  RQ["Frequency-domain specs (bandwidth, overshoot, margins)"]
    --> SPEC["Translate to target 'M' / 'N' levels and margin limits"]
  SPEC --> PLANT["Compute plant G(jw)"]
  PLANT --> STRUCT["Choose controller K(s) structure (gain or low-order rational)"]
  STRUCT --> NICH["Plot Nichols locus of L(s) = K(s) G(s)"]
  NICH --> CHECK["Check intersection with contours, gain/phase margins"]
  CHECK -->|ok| IMPLEMENT["Implement controller in code/robotics stack"]
  CHECK -->|not ok| TUNE["Adjust K(s) parameters"]
  TUNE --> NICH
        

Let \( L = L(\mathrm{j}\omega) \) be a complex number \( L = x + \mathrm{j}y \). The closed-loop transfer function at frequency \( \omega \) is

\[ T = \frac{L}{1+L}, \quad S = \frac{1}{1+L}. \]

2.1 Constant-Closed-Loop-Magnitude (M) Circles

Fix a desired closed-loop magnitude level \( |T| = M \). For unity-feedback regulation/tracking, one often constrains the resonant peak \( M_\mathrm{p} = \max_{\omega} |T(\mathrm{j}\omega)| \) to be below a given value in order to limit overshoot and amplification of narrow-band disturbances. The locus of all loop values \( L \) that yield a given \( |T| = M \) satisfies

\[ |T| = \left|\frac{L}{1+L}\right| = M \quad \Longrightarrow \quad |L|^2 = M^2 |1+L|^2. \]

Writing \( L = x + \mathrm{j}y \) gives

\[ x^2 + y^2 = M^2\big((1+x)^2 + y^2\big). \]

After algebraic manipulation and completing the square in \( x \), one obtains, for \( M \neq 1 \):

\[ \bigg(x + \frac{M^2}{M^2 - 1}\bigg)^2 + y^2 = \bigg(\frac{M}{M^2 - 1}\bigg)^2. \]

Thus, for \( M>1 \), the constant-closed-loop-magnitude contour is a circle in the \( L \)-plane with

• center on the real axis at \( -\dfrac{M^2}{M^2-1} \),
• radius \( \dfrac{M}{M^2-1} \).

Under the Nichols mapping, this circle becomes one of the M-circles plotted on the background chart. If the Nichols locus for \( L(\mathrm{j}\omega) \) is tangent to the \( M_\mathrm{p} \)-circle, then the closed-loop peak magnitude satisfies \( \max_\omega |T(\mathrm{j}\omega)|=M_\mathrm{p} \).

2.2 Constant-Sensitivity (N) Circles

Sensitivity \( S \) measures how strongly the closed-loop output reacts to reference and plant perturbations at each frequency. Fix a level \( |S| = N \). Because \( S = 1/(1+L) \), we have

\[ |S| = \left|\frac{1}{1+L}\right| = N \quad \Longrightarrow \quad |1+L| = \frac{1}{N}. \]

Writing \( L = x + \mathrm{j}y \) again, we obtain

\[ (1+x)^2 + y^2 = \frac{1}{N^2}, \]

which is the circle centered at \( (-1,0) \) with radius \( 1/N \). For control design it is common to bound the maximum sensitivity \( M_S = \max_\omega |S(\mathrm{j}\omega)| \); large \( M_S \) typically indicates poor robustness to gain variations and modeling errors.

The N-circles (constant-|S| curves) on the Nichols chart are simply images of these circles. A Nichols-based design that respects a specified robustness level \( M_S^\star \) ensures that the Nichols locus stays outside the corresponding \( |S| = M_S^\star \) contour.

The Nichols chart allows frequency-domain constraints to be expressed as geometric regions:

• Bandwidth and tracking: frequencies for which \( |T(\mathrm{j}\omega)| \approx 1 \) are associated with Nichols points near the \( M = 1 \) contour.
• Overshoot / resonant peak: limiting \( M_\mathrm{p} = \max_\omega |T(\mathrm{j}\omega)| \) translates into requiring that the Nichols locus does not penetrate inside the circle corresponding to \( M = M_\mathrm{p} \).
• Robustness and disturbance rejection: bounding \( M_S = \max_\omega |S(\mathrm{j}\omega)| \) is equivalent to keeping the Nichols locus outside the \( |S| = M_S \) circles.
• Stability margins: gain and phase margins can be read from the distance between the Nichols locus and the critical point \( L = -1 \), particularly around the \( 0\ \mathrm{dB} \) line.

For a nominal second-order closed-loop behavior with damping ratio \( \zeta \) and natural frequency \( \omega_n \), the classical relation between maximum closed-loop magnitude \( M_\mathrm{p} \) and \( \zeta \) is

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

Thus, specifying an overshoot bound in the time domain indirectly determines an allowable range for \( M_\mathrm{p} \), which in turn specifies a forbidden region inside an M-circle on the Nichols chart. By placing the Nichols locus to be tangent to a prescribed \( M_\mathrm{p} \)-circle, one approximately enforces the desired overshoot.

Similarly, a desired bound \( M_S^\star \) for maximum sensitivity yields a closed boundary: the Nichols locus must not cross the \( |S| = M_S^\star \) curve.

We summarize a typical iterative design loop used in classical Nichols-based design. The loop can be implemented interactively in software (MATLAB, Python/control, etc.) or embedded into optimization routines for automatic tuning.

flowchart TD
  A["Start with plant G(s) and specs (Mp, Ms, margins)"]
    --> B["Choose controller structure K(s) (e.g., gain or low-order rational)"]
  B --> C["Initialize parameters (e.g., K, time constants)"]
  C --> D["Compute Nichols locus of L(s) = K(s) G(s)"]
  D --> E["Check: Mp, Ms, gain/phase margins on chart"]
  E -->|satisfied| F["Fix K(s) and validate in time-domain simulation"]
  E -->|violated| G["Modify parameters \n(e.g., shift gain, move zero/pole)"]
  G --> D
        

In the remainder of this lesson we make this loop explicit for simple controller structures and show how to implement it programmatically.

Consider a unity-feedback system with plant \( G(s) \) and purely proportional controller \( K(s) = K \). The loop function is

\[ L(s) = K G(s), \quad L(\mathrm{j}\omega) = K G(\mathrm{j}\omega). \]

For any fixed frequency \( \omega \), increasing \( K \) simply shifts the Nichols point \( L(\mathrm{j}\omega) \) vertically (in dB) without changing its phase. If \( G(s) \) is minimum-phase and stable, a common design procedure is:

1. Choose a candidate crossover frequency \( \omega_c \) that meets bandwidth requirements and yields a desirable phase margin when combined with the phase of \( G(\mathrm{j}\omega_c) \).
2. At this frequency, compute \( G(\mathrm{j}\omega_c) \) and set the gain \( K \) so that the magnitude condition for crossover is satisfied:

\[ 20\log_{10} |L(\mathrm{j}\omega_c)| = 20\log_{10}\big(K|G(\mathrm{j}\omega_c)|\big) = 0\ \mathrm{dB} \quad \Longrightarrow \quad K = \frac{1}{|G(\mathrm{j}\omega_c)|}. \]

3. Inspect the Nichols locus: the point with phase \( \angle G(\mathrm{j}\omega_c) \) at \( 0\ \mathrm{dB} \) should lie in an acceptable region with respect to M- and N-circles and to the critical point \( -1 \) (for gain and phase margins).

For example, a joint of a robotic arm approximated as \( G(s) = \dfrac{1}{s(s+1)} \) (inertia plus viscous damping) yields a Nichols locus which, once scaled by \( K \), can be shaped so that it is tangent to a desired \( M_\mathrm{p} \)-circle, thus indirectly controlling overshoot of joint position.

Proportional control may not simultaneously meet bandwidth, overshoot, and robustness constraints. A standard refinement is to use a first-order dynamic compensator of the form

\[ K(s) = K_c \frac{\tau_z s + 1}{\tau_p s + 1}, \quad \tau_z, \tau_p > 0. \]

The loop function becomes

\[ L(s) = K_c \frac{\tau_z s + 1}{\tau_p s + 1} G(s), \quad L(\mathrm{j}\omega) = K_c \frac{\mathrm{j}\omega \tau_z + 1}{\mathrm{j}\omega \tau_p + 1} G(\mathrm{j}\omega). \]

In frequency domain, the compensator contributes an additional magnitude and phase:

\[ |K(\mathrm{j}\omega)| = K_c \frac{\sqrt{(\omega \tau_z)^2 + 1}}{\sqrt{(\omega \tau_p)^2 + 1}}, \quad \angle K(\mathrm{j}\omega) = \arctan(\omega \tau_z) - \arctan(\omega \tau_p). \]

By appropriately choosing \( (\tau_z,\tau_p) \) and \( K_c \), one can locally increase or decrease the loop phase around a target crossover frequency while adjusting the gain. On the Nichols chart this corresponds to curving and shifting the locus so that it threads between the specified M- and N-contours and yields acceptable margins. Detailed design heuristics for such compensators will be studied further in later chapters; here we focus on how to evaluate a given choice on the Nichols chart.

We now implement a Nichols-based design loop in Python for the plant \( G(s) = \dfrac{1}{s(s+1)} \). We first try proportional control, then allow a first-order compensator. The python-control library provides nichols_plot and frequency-response tools, while robotics-oriented packages such as roboticstoolbox can be used to obtain joint or actuator models for more realistic plants.

import numpy as np
import matplotlib.pyplot as plt
from control import tf, feedback, nichols_plot, magphase

# Plant G(s) = 1 / (s (s + 1))
s = tf([1, 0], [1])
G = 1 / (s * (s + 1))

# Frequency grid
w = np.logspace(-2, 2, 500)

# Design requirement (informal):
# - target crossover around wc ~ 1 rad/s
# - approximate resonant peak Mp <= 2 (about 6 dB)
Mp_target = 2.0

# --- Step 1: proportional controller ---
def closed_loop_peak_mag(K):
    """Compute peak |T(jw)| for proportional gain K."""
    L = K * G
    T = feedback(L, 1)
    mag, phase, _ = magphase(T(w), deg=True)
    return mag.max(), mag, phase

Kp_guess = 5.0
Mp, magT, phaseT = closed_loop_peak_mag(Kp_guess)
print(f"Proportional K = {Kp_guess:.2f}, peak |T| = {Mp:.3f}")

# Nichols plot of loop L(s) = K G(s)
L_prop = Kp_guess * G
plt.figure()
nichols_plot(L_prop, w)
plt.title("Nichols plot for proportional controller")
plt.grid(True)

# --- Step 2: simple first-order compensator K(s) = Kc (tau_z s + 1)/(tau_p s + 1) ---
def make_compensator(Kc, tau_z, tau_p):
    return Kc * tf([tau_z, 1], [tau_p, 1])

def design_compensator(Kc_init=5.0, tau_z=0.5, tau_p=0.1):
    Kc = Kc_init
    K = make_compensator(Kc, tau_z, tau_p)
    L = K * G
    T = feedback(L, 1)
    mag, phase, _ = magphase(T(w), deg=True)
    print(f"Kc={Kc:.2f}, tau_z={tau_z:.3f}, tau_p={tau_p:.3f}, peak |T| = {mag.max():.3f}")
    return K, L, T, mag, phase

Kc0 = 4.0
K_dyn, L_dyn, T_dyn, mag_dyn, phase_dyn = design_compensator(Kc0, tau_z=0.5, tau_p=0.05)

plt.figure()
nichols_plot(L_dyn, w)
plt.title("Nichols plot with first-order dynamic compensator")
plt.grid(True)

plt.show()
      

In practice one would adjust Kc, tau_z, and tau_p until the Nichols locus becomes tangent to the desired M-circle (for the allowed resonant peak) and stays outside the sensitivity contours corresponding to the chosen robustness level. For robotic joint position control, this procedure can be applied to each linearized joint axis independently (SISO design per joint).

On embedded systems or in robotic middleware (e.g., ros_control with C++), one typically implements the controller in the time domain, but the tuning can still be guided by Nichols-chart calculations performed offline. A minimal C++ program using the standard library and a linear algebra package such as Eigen can compute \( L(\mathrm{j}\omega) \) on a grid and export magnitude/phase data.

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

// Simple transfer G(s) = 1 / (s (s + 1)) evaluated at s = j w
std::complex<double> G_of_jw(double w) {
    std::complex<double> jw(0.0, w);
    return 1.0 / (jw * (jw + 1.0));
}

// First-order compensator K(s) = Kc (tau_z s + 1)/(tau_p s + 1)
std::complex<double> K_of_jw(double w, double Kc, double tau_z, double tau_p) {
    std::complex<double> jw(0.0, w);
    return Kc * (tau_z * jw + 1.0) / (tau_p * jw + 1.0);
}

int main() {
    double Kc = 4.0;
    double tau_z = 0.5;
    double tau_p = 0.05;

    std::vector<double> w_grid;
    for (int k = 0; k <= 400; ++k) {
        double w = std::pow(10.0, -2.0 + 4.0 * k / 400.0); // 10^-2 ... 10^2
        w_grid.push_back(w);
    }

    for (double w : w_grid) {
        std::complex<double> L = K_of_jw(w, Kc, tau_z, tau_p) * G_of_jw(w);
        double mag = std::abs(L);
        double phase = std::atan2(L.imag(), L.real()) * 180.0 / M_PI;
        double mag_dB = 20.0 * std::log10(mag);
        std::cout << w << " " << mag_dB << " " << phase << std::endl;
    }

    return 0;
}
      

The output can be imported into plotting tools to overlay with pre-computed Nichols contours. In robotic applications, the same approach can be used with axis-specific plants obtained from a dynamics library such as orocos-kdl or integrated with ros_control controllers.

Java-based robotic frameworks (e.g., educational robots with WPILib) may require similar offline Nichols analysis. We can compute magnitude/phase on a frequency grid using Apache Commons Math for complex arithmetic.

import org.apache.commons.math3.complex.Complex;

public class NicholsExample {

    static Complex Gofjw(double w) {
        Complex jw = new Complex(0.0, w);
        return Complex.ONE.divide(jw.multiply(jw.add(Complex.ONE)));
    }

    static Complex Kofjw(double w, double Kc, double tauZ, double tauP) {
        Complex jw = new Complex(0.0, w);
        Complex num = jw.multiply(tauZ).add(Complex.ONE);
        Complex den = jw.multiply(tauP).add(Complex.ONE);
        return num.divide(den).multiply(Kc);
    }

    public static void main(String[] args) {
        double Kc = 4.0;
        double tauZ = 0.5;
        double tauP = 0.05;

        for (int k = 0; k <= 400; ++k) {
            double w = Math.pow(10.0, -2.0 + 4.0 * k / 400.0);
            Complex L = Kofjw(w, Kc, tauZ, tauP).multiply(Gofjw(w));

            double mag = L.abs();
            double phase = Math.toDegrees(Math.atan2(L.getImaginary(), L.getReal()));
            double magdB = 20.0 * Math.log10(mag);

            System.out.printf("%e %f %f%n", w, magdB, phase);
        }
    }
}
      

These data can be plotted in a Java-based GUI or exported to other environments for overlay with Nichols contours, guiding the choice of \( K_c \), \( \tau_z \), and \( \tau_p \).

MATLAB provides built-in Nichols plotting and interactive design tools that naturally integrate with Simulink models of robotic actuators and mechanisms (e.g., via the Robotics System Toolbox or classical transfer-function models).

% Plant
s = tf('s');
G = 1 / (s * (s + 1));

% Proportional controller
Kp = 5;
L_prop = Kp * G;

figure;
nichols(L_prop);
grid on;
title('Nichols plot: proportional controller');

% First-order dynamic compensator
Kc    = 4;
tau_z = 0.5;
tau_p = 0.05;
Kdyn  = Kc * (tau_z * s + 1) / (tau_p * s + 1);
L_dyn = Kdyn * G;

figure;
nichols(L_dyn);
grid on;
title('Nichols plot: dynamic compensator');

% Closed-loop responses for comparison
T_prop = feedback(L_prop, 1);
T_dyn  = feedback(L_dyn, 1);

figure;
step(T_prop, T_dyn);
legend('Proportional', 'Dynamic compensator');
title('Step responses (for overshoot / settling comparison)');
      

In Simulink, the same controller can be represented as a transfer function or implemented via standard blocks. For robotic applications, a joint or axis model extracted from a multibody simulation can be placed inside a unity-feedback loop and tuned with Nichols-based guidelines.

Wolfram Mathematica (with control functionality loaded) can also generate Nichols plots and analyze closed-loop properties symbolically and numerically.

(* Define plant and compensator *)
s = ComplexExpand[I*omega];
G[s_] := 1/(s (s + 1));

Kc   = 4.0;
tauZ = 0.5;
tauP = 0.05;
K[s_] := Kc ((tauZ s + 1)/(tauP s + 1));

L[s_] := K[s] G[s];
T[s_] := L[s]/(1 + L[s]);

(* Frequency grid *)
omegaGrid = LogSpace[-2, 2, 400];

(* Nichols data: magnitude (dB) vs phase (deg) *)
nicholsData =
  Table[
    Module[{w = w0, val = L[I w0]},
      {20 Log[10, Abs[val]], Arg[val] 180/Pi}
    ],
    {w0, omegaGrid}
  ];

ListLinePlot[
  nicholsData,
  AxesLabel -> {"Magnitude (dB)", "Phase (deg)"},
  PlotRange -> All,
  PlotLegends -> {"L(j w)"},
  GridLines -> Automatic
]

(* Closed-loop peak magnitude approximation *)
magT[w_] := Abs[T[I w]];
maxMagT  = N[Max@Table[magT[w0], {w0, omegaGrid}]];
maxMagT
      

Mathematica is particularly useful when working with symbolic plant models derived from robot dynamics; after linearization, one can directly obtain transfer functions for joint coordinates and apply Nichols-based design analytically.

Problem 1 (Derivation of M-Circle Parameters): Starting from the definition \( T = \dfrac{L}{1+L} \) with \( L = x + \mathrm{j}y \), derive the center and radius of the constant-closed-loop-magnitude contour \( |T| = M \) in the \( (x,y) \)-plane.

Solution: The condition \( |T| = M \) implies

\[ |T|^2 = \frac{|L|^2}{|1+L|^2} = M^2 \quad \Longrightarrow \quad |L|^2 = M^2 |1+L|^2. \]

Write \( L = x + \mathrm{j}y \), so \( |L|^2 = x^2 + y^2 \) and \( |1+L|^2 = (1+x)^2 + y^2 \). Therefore

\[ x^2 + y^2 = M^2\big((1+x)^2 + y^2\big). \]

Expand the right-hand side: \( M^2((1+x)^2 + y^2) = M^2(x^2 + 2x + 1 + y^2) \), and bring all terms to one side:

\[ (1-M^2)x^2 + (1-M^2)y^2 - 2M^2 x - M^2 = 0. \]

Assuming \( M \neq 1 \), divide by \( 1-M^2 \) to obtain

\[ x^2 + y^2 + \frac{2M^2}{M^2-1}x + \frac{M^2}{M^2-1} = 0. \]

Completing the square in \( x \) yields

\[ \bigg(x + \frac{M^2}{M^2-1}\bigg)^2 + y^2 = \bigg(\frac{M}{M^2-1}\bigg)^2. \]

Hence, for \( M > 1 \), the constant-\( |T| \) contour is a circle centered at \( (-M^2/(M^2-1),0) \) with radius \( M/(M^2-1) \).

Problem 2 (N-Circle Geometry): Show that the constant-sensitivity contour \( |S| = N \) for \( S = 1/(1+L) \) and \( L = x + \mathrm{j}y \) is a circle centered at \( (-1,0) \) with radius \( 1/N \).

Solution: By definition,

\[ |S| = \left|\frac{1}{1+L}\right| = N \quad \Longrightarrow \quad |1+L| = \frac{1}{N}. \]

With \( L = x + \mathrm{j}y \), \( 1+L = (1+x) + \mathrm{j}y \), so

\[ (1+x)^2 + y^2 = \frac{1}{N^2}. \]

This is the equation of a circle with center at \( (-1,0) \) and radius \( 1/N \). Its Nichols image is the corresponding N-circle.

Problem 3 (Proportional Design by Nichols): Let \( G(s) = 1/(s(s+1)) \) and consider a proportional controller \( K(s) = K \). Suppose a desired crossover frequency \( \omega_c \) is chosen, and at this frequency the phase of the plant is \( \angle G(\mathrm{j}\omega_c) = -150^\circ \). Find the gain \( K \) that yields \( 0\ \mathrm{dB} \) at \( \omega_c \), and explain how to check the phase margin on the Nichols chart.

Solution: At crossover we require

\[ 20\log_{10}|L(\mathrm{j}\omega_c)| = 20\log_{10}\big(K|G(\mathrm{j}\omega_c)|\big) = 0. \]

This implies \( K|G(\mathrm{j}\omega_c)| = 1 \), hence

\[ K = \frac{1}{|G(\mathrm{j}\omega_c)|}. \]

The corresponding Nichols point is \( (0\ \mathrm{dB}, -150^\circ) \). The phase margin is the difference between \( -180^\circ \) and the phase at unity magnitude. Here it is \( 30^\circ \). On the Nichols chart, this appears as the horizontal separation (in degrees) between the unity-gain line at \( 0\ \mathrm{dB} \) and the vertical line through \( -180^\circ \) at that magnitude.

Problem 4 (Effect of First-Order Compensator): For the same plant \( G(s) = 1/(s(s+1)) \), consider the compensator \( K(s) = K_c(\tau_z s + 1)/(\tau_p s + 1) \) with \( \tau_z > \tau_p > 0 \). Show qualitatively (no numerical computation required) how the presence of the zero and pole affects the Nichols locus around \( \omega \approx 1/\tau_z \) and \( \omega \approx 1/\tau_p \).

Solution: At low frequencies \( \omega \ll 1/\tau_p \), both \( \tau_z s + 1 \) and \( \tau_p s + 1 \) are close to \( 1 \), so \( K(\mathrm{j}\omega) \approx K_c \). Around \( \omega \approx 1/\tau_z \), the zero begins to contribute a positive phase (its phase increases from \( 0^\circ \) toward \( +90^\circ \)) and a magnitude increase. Around \( \omega \approx 1/\tau_p \), the pole contributes negative phase (decreasing toward \( -90^\circ \)) and attenuates magnitude. Since \( \tau_z > \tau_p \), the zero is at a lower frequency than the pole, leading to a net positive phase contribution over a certain frequency band. On the Nichols chart this appears as a local phase-advance region (the locus bends upward in magnitude and leftward in phase) near the crossover frequency, which can increase phase margin while preserving bandwidth constraints.

Nichols charts provide a compact way to visualize and design SISO controllers by plotting the open-loop response \( L(\mathrm{j}\omega) \) in magnitude-phase coordinates and overlaying closed-loop performance contours. We derived the geometry of constant closed-loop magnitude (M) and constant sensitivity (N) circles and explained how time-domain requirements such as overshoot and robustness translate into forbidden regions on the chart. Simple proportional and first-order dynamic controllers can be tuned so that the Nichols locus threads between these constraints while achieving acceptable gain and phase margins. Computational tools in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica enable this design to be applied to realistic plants, including linearized models of robotic joints and actuators.