Consider a unity-feedback SISO LTI loop with controller transfer function \( C(s) \) and plant transfer function \( G(s) \). The loop transfer function is

\[ L(s) = C(s)G(s). \]

The closed-loop transfer function from reference input \( R(s) \) to output \( Y(s) \) is

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

The characteristic equation is therefore \( 1 + L(s) = 0 \). The closed-loop poles are the zeros of \( 1 + L(s) \). We denote

\[ F(s) \triangleq 1 + L(s). \]

Let \( P \) be the number of poles of \( F(s) \) in the open right-half plane (RHP), counted with multiplicity, and \( Z \) the number of zeros of \( F(s) \) in the RHP. Since \( F(s) = 1 + L(s) \) and \( 1 \) has no poles or zeros, \( P \) is simply the number of RHP poles of \( L(s) \).

Goal: Determine whether \( Z = 0 \), i.e., whether all closed-loop poles lie in the open left-half plane and the system is asymptotically stable, using only the frequency response \( L(j\omega) \).

The Nyquist method uses a special contour in the complex \( s \)-plane and the mapping induced by \( F(s) \) onto the complex \( w \)-plane (the plane of \( w = F(s) \)). We assume here that \( L(s) \) is a proper rational function with no poles on the imaginary axis. (The case with imaginary-axis poles will be treated by small detours around the poles in later lessons.)

Define the Nyquist contour \( \Gamma \) as the closed contour that consists of:

• the imaginary axis from \( s = j\omega \) with \( \omega = -\Omega \) up to \( \omega = \Omega \) (with \( \Omega \) very large), and
• a semicircular arc of radius \( \Omega \) in the right-half plane, from \( s = j\Omega \) clockwise to \( s = -j\Omega \).

As \( \Omega \to \infty \), the contour \( \Gamma \) encloses the entire open RHP. Evaluating \( F(s) \) along \( \Gamma \) produces a closed curve in the \( w \)-plane. Translating by \( -1 \), the curve of \( L(s) = F(s) - 1 \) is just the Nyquist plot of the loop transfer function.

flowchart TD
  A["Nyquist contour Gamma in s-plane (RHP)"]
  B["Map via L(s) to L(Gamma) in complex plane"]
  C["Translate by +1: F(s) = 1 + L(s)"]
  D["Encirclements of origin by F(Gamma)"]
  E["Encirclements of -1 by L(Gamma)"]
  A --> B --> C --> D
  B --> E
        

Intuitively, as we traverse \( \Gamma \) once in the \( s \)-plane, the phase of \( F(s) \) changes. The total change in argument of \( F(s) \) along \( \Gamma \) is directly related to how many zeros and poles of \( F(s) \) lie inside the contour. This is formalized by the argument principle.

Let \( F(s) \) be a meromorphic function (analytic except at isolated poles) with no zeros or poles on \( \Gamma \). The argument principle states that

\[ \Delta_{\Gamma} \arg F(s) = 2\pi (Z - P), \]

where \( \Delta_{\Gamma} \arg F(s) \) is the net change in the argument of \( F(s) \) as \( s \) traverses \( \Gamma \) once in the positive (counterclockwise) direction, and \( Z, P \) are the numbers of zeros and poles of \( F(s) \) inside \( \Gamma \), counted with multiplicity.

On the other hand, if we track the curve \( w = F(s) \) in the complex \( w \)-plane, the same change in argument is related to the net number of encirclements of the origin. Let \( N_F \) be the net number of counterclockwise encirclements of the origin by the curve \( F(\Gamma) \). Then

\[ \Delta_{\Gamma} \arg F(s) = 2\pi N_F. \]

Hence,

\[ N_F = Z - P. \]

Now, recall \( F(s) = 1 + L(s) \). The translation \( w = F(s) = 1 + L(s) \) just shifts the curve \( L(\Gamma) \) by \( +1 \) on the real axis. Therefore, the number of encirclements of the origin by \( F(\Gamma) \) is exactly the number of encirclements of the point \( -1 \) by \( L(\Gamma) \). Denote the net number of counterclockwise encirclements of \( -1 \) by \( L(\Gamma) \) as \( N_{-1} \). Then

\[ N_{-1} = N_F = Z - P. \]

Many control textbooks, however, define \( N \) as the net number of clockwise encirclements of \( -1 \). If we adopt that convention, then

\[ N = P - Z, \]

where \( N > 0 \) means more clockwise than counterclockwise encirclements. This is the sign convention we will use in the remainder of this lesson.

We can now state the Nyquist stability criterion for unity-feedback SISO loops with loop transfer function \( L(s) \).

Assumptions:

• \( L(s) \) is rational and proper.
• No poles of \( L(s) \) lie on the imaginary axis.
• The Nyquist contour \( \Gamma \) encloses the open RHP and avoids any poles on the imaginary axis.

Definitions:

• \( P \): number of open-loop poles of \( L(s) \) in the RHP (i.e., poles of \( F(s) \)).
• \( Z \): number of closed-loop poles in the RHP (i.e., zeros of \( F(s)=1+L(s) \)).
• \( N \): net number of clockwise encirclements of the point \( -1 \) by the Nyquist plot of \( L(s) \) as we trace \( \Gamma \).

Nyquist Criterion (unity feedback):

\[ N = P - Z. \]

Closed-loop stability requires \( Z = 0 \), so the Nyquist stability condition is

\[ Z = 0 \quad \Longleftrightarrow \quad N = P. \]

In words:

• If the open-loop is stable (\( P = 0 \)), the closed loop is stable if and only if the Nyquist plot of \( L(s) \) makes no net clockwise encirclements of \( -1 \), i.e., \( N = 0 \).
• If the open loop has \( P > 0 \) RHP poles, the Nyquist plot must make exactly \( P \) net clockwise encirclements of \( -1 \) for closed-loop stability.

This connects the algebraic closed-loop stability condition to a purely graphical frequency-domain test.

For engineering practice (including robotics and mechatronics), we rarely trace the full semicircular contour. Instead, under mild conditions on \( L(s) \), the contribution of the large semicircle can be inferred from the high-frequency asymptote, and the Nyquist plot is generated from the frequency response \( L(j\omega) \) for \( \omega \in [0,\infty) \), using symmetry for negative frequencies.

A typical procedure for a unity-feedback loop:

1. Count the number \( P \) of open-loop poles of \( L(s) \) in the RHP (using, e.g., Routh-Hurwitz).
2. Generate the Nyquist plot of \( L(j\omega) \) from \( \omega = 0^+ \) to \( \omega \to \infty \).
3. Complete the Nyquist contour using the symmetry \( L(-j\omega) = \overline{L(j\omega)} \) for real-coefficient systems.
4. Count the net number \( N \) of clockwise encirclements of \( -1 \).
5. Apply the relation \( N = P - Z \) to compute \( Z \). If \( Z = 0 \), the closed loop is stable.

flowchart TD
  S["Start with L(s) = C(s)G(s)"] --> P["Find P = # of RHP poles of L(s)"]
  P --> FR["Compute frequency response L(jw) for w in [0, inf)"]
  FR --> NYQ["Draw Nyquist plot using symmetry"]
  NYQ --> CNT["Count clockwise encirclements of -1 (N)"]
  CNT --> COMP["Compute Z = P - N"]
  COMP --> STAB{"Z = 0 ?"}
  STAB -->|yes| STABLE["Closed loop stable"]
  STAB -->|no| UNST["Closed loop unstable (RHP poles present)"]
        

For robotic actuators and servo drives, \( L(s) \) typically has an integrator and second-order dynamics. The Nyquist plot helps verify that controller gain and dynamic compensation do not push closed-loop poles into the RHP when actuator and sensor dynamics are included.

Consider a simple unity-feedback loop often used to model a robot joint position servo:

• Plant: \( G(s) = \dfrac{1}{s(s+1)} \) (integrator plus first-order dynamics).
• Controller: proportional gain \( C(s) = K \).

The loop transfer function is

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

The closed-loop characteristic equation is

\[ 1 + L(s) = 0 \quad \Longleftrightarrow \quad s(s+1) + K = 0, \]

i.e.,

\[ s^2 + s + K = 0. \]

By Routh-Hurwitz for a second-order polynomial \( s^2 + a_1 s + a_0 \), stability requires \( a_1 > 0 \) and \( a_0 > 0 \). Here, \( a_1 = 1 \) and \( a_0 = K \), so closed-loop stability occurs if and only if

\[ K > 0. \]

Let us verify this with the Nyquist criterion.

Step 1: Open-loop RHP poles \( P \).

The poles of \( L(s) \) are at \( s = 0 \) and \( s = -1 \). Neither lies in the open RHP, but \( s = 0 \) lies on the imaginary axis, which violates our basic assumption. In a rigorous Nyquist analysis, we modify the contour by creating a small semicircular detour around \( s = 0 \). For this example, one can show that this contributes a half-encirclement of the point at infinity and leads to the same stability condition as below. For pedagogical clarity, we also examine a slightly modified example with no imaginary-axis pole.

Modified plant (no axis pole):

Replace \( G(s) \) with \( \tilde{G}(s) = \dfrac{1}{(s+0.1)(s+1)} \), which approximates the integrator near low frequencies. Then

\[ \tilde{L}(s) = \frac{K}{(s+0.1)(s+1)}. \]

The closed-loop characteristic polynomial is

\[ (s+0.1)(s+1) + K = s^2 + 1.1 s + (0.1 + K). \]

Routh-Hurwitz yields stability if and only if \( 1.1 > 0 \) and \( 0.1 + K > 0 \), i.e.

\[ K > -0.1. \]

Now all open-loop poles \( s = -0.1, -1 \) lie in the LHP, so \( P = 0 \).

Step 2: Nyquist plot and encirclements.

The frequency response is

\[ \tilde{L}(j\omega) = \frac{K}{(j\omega + 0.1)(j\omega + 1)}. \]

The Nyquist plot of \( \tilde{L}(j\omega) \) for \( \omega \in [0,\infty) \) is a curve in the complex plane. For sufficiently small positive \( K \), the curve passes to the right of \( -1 \), and there are no encirclements of \( -1 \). Increasing \( K \) moves the curve outward; once it passes through \( -1 \), further increases will cause one clockwise encirclement of \( -1 \), indicating one RHP closed-loop pole.

With \( P = 0 \), Nyquist predicts that closed-loop stability is equivalent to \( N = 0 \). This corresponds to all gains \( K \) such that the Nyquist plot does not encircle \( -1 \), which matches the Routh-Hurwitz condition \( K > -0.1 \) once the full contour (including the large arc) is taken into account.

In robotic servo design, such analytical checks can be used to verify that proportional gains chosen via simple tuning do not unexpectedly destabilize the joint when motor inductances, friction, and sensor dynamics are included.

Python, together with scientific libraries used in robotics and control (e.g., python-control, scipy), provides convenient tools for generating Nyquist plots and performing stability checks. The following script:

• Defines a loop transfer function \( L(s) \).
• Plots its Nyquist curve.
• Approximates the encirclement count \( N \) by tracking the change in argument of \( 1 + L(j\omega) \).

import numpy as np
import matplotlib.pyplot as plt

# Optional: python-control, widely used in robotics and control courses
try:
    import control  # python-control library
except ImportError:
    control = None

def loop_transfer_function(s, K=5.0):
    """
    Example loop L(s) = K / ((s + 0.1)(s + 1)),
    representing a lightly damped servo-like plant with proportional gain K.
    """
    return K / ((s + 0.1) * (s + 1.0))

def nyquist_data(K=5.0, w_min=1e-2, w_max=1e2, n_points=4000):
    # Positive frequencies
    w = np.logspace(np.log10(w_min), np.log10(w_max), n_points)
    s = 1j * w
    L = loop_transfer_function(s, K=K)
    return w, L

def count_encirclements(L):
    """
    Approximate encirclements of -1 by monitoring the winding of 1 + L(jw)
    around the origin. We compute the unwrapped phase and divide by 2*pi.
    Positive result corresponds to counterclockwise; we negate to match
    the clockwise-encirclement convention N = P - Z (for P = 0 here).
    """
    F = 1.0 + L
    phi = np.unwrap(np.angle(F))
    dphi = np.diff(phi)
    total_phase_change = np.sum(dphi)
    N_ccw = total_phase_change / (2.0 * np.pi)
    N_clockwise = -N_ccw
    return N_clockwise

def main():
    K = 5.0
    w, L = nyquist_data(K=K)

    # Nyquist plot (positive frequencies only; mirror is conjugate)
    plt.figure()
    plt.plot(L.real, L.imag, label="L(jw), w > 0")
    plt.plot(L.real, -L.imag, "--", label="L(jw), w < 0 (mirror)")
    plt.scatter([-1.0], [0.0], marker="x", s=80, label="-1 point")
    plt.axhline(0, linewidth=0.5)
    plt.axvline(0, linewidth=0.5)
    plt.xlabel("Re{L(jw)}")
    plt.ylabel("Im{L(jw)}")
    plt.title(f"Nyquist plot, K = {K}")
    plt.legend()
    plt.grid(True)

    # Encirclement count
    N = count_encirclements(L)
    print(f"Approximate clockwise encirclements of -1: N = {N:.2f}")

    plt.show()

if __name__ == "__main__":
    main()
      

In a robotics context, the transfer function loop_transfer_function can be replaced by the identified dynamics of a robot joint (from Chapter 3) and the chosen controller \( C(s) \) (e.g., PI, PD, or PID from Chapters 11–12) to assess Nyquist stability.

If the python-control library is available, one can also directly use:

if control is not None:
    num = [5.0]
    den = [1.0, 1.1, 0.5]  # Example polynomial; adjust to match your plant
    L_sys = control.TransferFunction(num, den)
    control.nyquist(L_sys)  # built-in Nyquist plot
      

MATLAB and Simulink are standard tools in control and robotics. The Control System Toolbox provides a direct nyquist command, and Simulink models can be used to verify closed-loop behavior in time domain.

MATLAB script:

% Loop transfer function for a robot joint position servo
% G(s) = 1 / ((s+0.1)(s+1)), C(s) = K
K = 5;
s = tf('s');
G = 1 / ((s + 0.1) * (s + 1));
C = K;
L = C * G;

% Nyquist plot
figure;
nyquist(L);
grid on;
title('Nyquist plot of L(s) = C(s)G(s)');

% Nyquist-based closed-loop stability (open-loop stable, P=0)
% For unity feedback, use feedback(L,1) or feedback(C*G,1)
T = feedback(L, 1);
disp('Closed-loop poles:');
disp(pole(T));

if all(real(pole(T)) < 0)
    disp('Closed loop is asymptotically stable.');
else
    disp('Closed loop is unstable (some poles in RHP or on jw axis).');
end
      

Simulink workflow (conceptual):

1. Create a new Simulink model.
2. Place blocks: Step → Sum → Gain → Transfer Fcn.
3. Configure the transfer function block with numerator [1] and denominator [1 1.1 0.5] (for example).
4. Connect feedback around the plant using a Sum block implementing \( r(t) - y(t) \).
5. Run the simulation and inspect step response and stability.

This Simulink model can represent a simplified robot joint or servo axis. Nyquist plots from the MATLAB side verify stability margins, while Simulink simulations show transient behavior.

9.1 C++: Sampling the Nyquist Curve

In C++, Nyquist analysis can be implemented as a small numerical tool, e.g. as part of a robotics control stack (ROS, real-time controllers) for offline verification. The following example uses std::complex<double>:

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

using Complex = std::complex<double>;

Complex L(Complex s, double K) {
    // Example L(s) = K / ((s + 0.1)(s + 1))
    return K / ((s + Complex(0.1, 0.0)) * (s + Complex(1.0, 0.0)));
}

int main() {
    const double K = 5.0;
    const int N = 4000;
    const double w_min = 1e-2;
    const double w_max = 1e2;

    std::vector<Complex> F_values;
    F_values.reserve(N);

    // Log-spaced frequency grid
    for (int k = 0; k < N; ++k) {
        double alpha = static_cast<double>(k) / (N - 1);
        double w = std::pow(10.0, std::log10(w_min) +
                                   alpha * (std::log10(w_max) - std::log10(w_min)));
        Complex s(0.0, w);
        Complex Ljw = L(s, K);
        F_values.push_back(Complex(1.0, 0.0) + Ljw); // F(s) = 1 + L(s)
    }

    // Approximate total change in argument of F(s) to estimate encirclements
    double total_phase_change = 0.0;
    for (int k = 1; k < N; ++k) {
        double phi_prev = std::atan2(F_values[k-1].imag(), F_values[k-1].real());
        double phi_curr = std::atan2(F_values[k].imag(), F_values[k].real());
        double dphi = phi_curr - phi_prev;

        // Wrap into [-pi, pi]
        if (dphi > M_PI) dphi -= 2.0 * M_PI;
        if (dphi < -M_PI) dphi += 2.0 * M_PI;

        total_phase_change += dphi;
    }

    double N_ccw = total_phase_change / (2.0 * M_PI);
    double N_clockwise = -N_ccw;

    std::cout << "Approximate clockwise encirclements of -1: N = "
              << N_clockwise << std::endl;

    // In a robotics setting, this tool can be integrated into an offline tuning workflow
    // for joint controllers or mobile robot steering controllers.
    return 0;
}
      

9.2 Java: Using a Simple Complex Class

In Java-based robotics libraries (e.g., custom control modules, some industrial APIs), a similar approach can be used. Below we sketch a minimal complex type and Nyquist sampling loop (for clarity; production code should use a tested library such as Apache Commons Math).

class Complex {
    public final double re;
    public final double im;

    public Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }

    public Complex add(Complex other) {
        return new Complex(this.re + other.re, this.im + other.im);
    }

    public Complex mul(Complex other) {
        return new Complex(
            this.re * other.re - this.im * other.im,
            this.re * other.im + this.im * other.re
        );
    }

    public Complex div(Complex other) {
        double den = other.re * other.re + other.im * other.im;
        return new Complex(
            (this.re * other.re + this.im * other.im) / den,
            (this.im * other.re - this.re * other.im) / den
        );
    }

    public double arg() {
        return Math.atan2(im, re);
    }
}

public class NyquistDemo {

    static Complex L(Complex s, double K) {
        Complex num = new Complex(K, 0.0);
        Complex den = (new Complex(1.0, 0.0)).add(s.mul(new Complex(1.1, 0.0)))
                        .add(new Complex(0.5, 0.0)); // Example polynomial
        return num.div(den);
    }

    public static void main(String[] args) {
        int N = 4000;
        double wMin = 1e-2;
        double wMax = 1e2;
        double K = 5.0;

        Complex[] F = new Complex[N];
        for (int k = 0; k < N; ++k) {
            double alpha = (double) k / (N - 1);
            double w = Math.pow(10.0,
                    Math.log10(wMin) + alpha * (Math.log10(wMax) - Math.log10(wMin)));
            Complex s = new Complex(0.0, w);
            Complex Ljw = L(s, K);
            F[k] = new Complex(1.0, 0.0).add(Ljw); // F(s) = 1 + L(s)
        }

        double totalPhaseChange = 0.0;
        for (int k = 1; k < N; ++k) {
            double phiPrev = F[k-1].arg();
            double phiCurr = F[k].arg();
            double dphi = phiCurr - phiPrev;
            if (dphi > Math.PI) dphi -= 2.0 * Math.PI;
            if (dphi < -Math.PI) dphi += 2.0 * Math.PI;
            totalPhaseChange += dphi;
        }

        double Nccw = totalPhaseChange / (2.0 * Math.PI);
        double Nclockwise = -Nccw;
        System.out.println("Approximate clockwise encirclements of -1: N = " + Nclockwise);
    }
}
      

9.3 Wolfram Mathematica: NyquistPlot

Mathematica provides symbolic manipulation and plotting for control systems. The following example constructs \( L(s) \) and plots its Nyquist curve:

(* Define Laplace variable and gain *)
s = ComplexExpand[s];
K = 5;

(* Loop transfer function L(s) = K / ((s + 0.1)(s + 1)) *)
L[s_] := K/((s + 0.1) (s + 1));

(* Nyquist plot on a specified frequency range *)
NyquistPlot[L[I*ω], {ω, 0.01, 100},
  PlotRange -> All,
  GridLines -> Automatic,
  PlotLegends -> {"L(jω)"},
  AxesLabel -> {"Re", "Im"}
]

(* Closed-loop transfer function T(s) = L(s)/(1 + L(s)) *)
T[s_] := L[s]/(1 + L[s]);

(* Find closed-loop poles *)
Solve[Denominator[T[s]] == 0, s]
      

For robotic applications, the symbolic definition of \( L(s) \) can be derived from a linearized manipulator or mobile robot model; NyquistPlot then offers an exact visualization of Nyquist stability.

Problem 1 (Counting Encirclements): A unity-feedback system has loop transfer function \( L(s) = \dfrac{K}{(s+1)(s+4)} \), with \( K > 0 \). The Nyquist plot for \( K = 10 \) makes no encirclements of \( -1 \). For \( K = 40 \), the Nyquist plot makes one clockwise encirclement of \( -1 \). Assume \( L(s) \) has no RHP poles. Determine the closed-loop stability for \( K = 10 \) and \( K = 40 \).

Solution:

First note that all poles of \( L(s) \) are at \( s = -1 \) and \( s = -4 \), so \( P = 0 \) for all \( K > 0 \). For \( K = 10 \), \( N = 0 \) (no encirclements). Nyquist relation \( N = P - Z \) gives

\[ 0 = 0 - Z \quad \Rightarrow \quad Z = 0. \]

Thus, the closed-loop system is stable for \( K = 10 \). For \( K = 40 \), the Nyquist plot makes one clockwise encirclement of \( -1 \), so \( N = 1 \). Then

\[ 1 = 0 - Z \quad \Rightarrow \quad Z = -1, \]

which indicates one RHP closed-loop pole (the negative sign appears because \( Z = P - N \) and \( P = 0 \Rightarrow Z = -N \); equivalently, we could define \( N \) as counterclockwise encirclements and change the sign convention). In either convention, the presence of a nonzero \( Z \) means the closed-loop system is unstable for \( K = 40 \).

Problem 2 (Nyquist and Routh-Hurwitz Consistency): Consider the unity-feedback loop with \( L(s) = \dfrac{K}{s(s+2)(s+4)} \), \( K > 0 \). The closed-loop characteristic polynomial is \( s^3 + 6 s^2 + 8 s + K = 0 \). Use Routh-Hurwitz to find the range of \( K \) for closed-loop stability, and explain how Nyquist must behave within this range.

Solution:

The Routh array for \( s^3 + 6 s^2 + 8 s + K \) is

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

Stability requires all first-column entries > 0:

\[ 1 > 0, \quad 6 > 0, \quad \frac{48 - K}{6} > 0, \quad K > 0. \]

Thus \( 0 < K < 48 \). Within this range, Nyquist must produce zero RHP closed-loop poles, so \( Z = 0 \). The open-loop poles are at \( s = 0, -2, -4 \); there are no RHP poles (but one pole on the imaginary axis). For a contour properly detoured around \( s = 0 \), Nyquist requires no net encirclement of \( -1 \) across all stable values of \( K \). At the critical value \( K = 48 \), the Nyquist plot passes exactly through \( -1 \), and on either side of this gain the encirclement count changes, corresponding to a root crossing the imaginary axis.

Problem 3 (Effect of a RHP Zero): Suppose \( L(s) = \dfrac{K (s-1)}{(s+2)(s+4)} \). Determine the number of RHP poles \( P \) of \( L(s) \), and describe qualitatively how the Nyquist plot is affected by the RHP zero at \( s = 1 \).

Solution:

The poles of \( L(s) \) are at \( s = -2 \) and \( s = -4 \), both in the LHP, so \( P = 0 \). The zero at \( s = 1 \) lies in the RHP. Zeros do not directly enter the pole count \( P \), but they modify the Nyquist shape: the RHP zero introduces an extra phase lag and causes the Nyquist curve to cross the real axis differently, often moving it closer to or beyond \( -1 \) for given gain. As a result, even though \( P = 0 \), the admissible stable gains (those yielding \( N = 0 \)) are typically more restricted than in a comparable system without a RHP zero. The Nyquist criterion is still \( N = P - Z \), but the geometric placement of the curve makes encirclements more likely for the same gain.

Problem 4 (Nyquist Test Procedure): Outline a step-by-step Nyquist test for a unity-feedback loop where the open-loop transfer function \( L(s) \) has one pole at the origin and no other RHP or imaginary-axis poles. How does the Nyquist contour need to be modified?

Solution:

Because \( L(s) \) has a pole on the imaginary axis at \( s = 0 \), the standard Nyquist contour cannot pass through the origin. The modified Nyquist test proceeds as follows:

1. Construct a contour that follows the imaginary axis from \( s = j\Omega \) down to \( s = j\varepsilon \) (with small \( \varepsilon > 0 \)), then detours around \( s = 0 \) using a small semicircle of radius \( \varepsilon \) in the right-half plane from \( s = j\varepsilon \) to \( s = -j\varepsilon \).
2. Continue along the imaginary axis from \( s = -j\varepsilon \) to \( s = -j\Omega \), then follow the large semicircle back to \( j\Omega \).
3. Evaluate \( L(s) \) along this modified contour and plot the mapped curve.
4. The small semicircular detour around \( s = 0 \) contributes a known half-encirclement of the origin in the \( F(s) = 1 + L(s) \) plane, which must be included when counting net encirclements of \( -1 \).
5. Use the adjusted encirclement count \( N \) and the number of RHP poles \( P \) of \( L(s) \) (excluding the pole at the origin) in the relation \( N = P - Z \).

This procedure properly accounts for the integrator and yields a correct Nyquist-based stability conclusion.

Problem 5 (Robotics Interpretation): A robot joint controller has loop transfer function \( L(s) = \dfrac{K_v}{s} \cdot \dfrac{\omega_n^2}{s^2 + 2\zeta \omega_n s + \omega_n^2} \), where \( K_v > 0 \) is a velocity gain for a PI-like controller, \( \omega_n > 0 \) is the natural frequency of the joint, and \( 0 < \zeta < 1 \). Describe qualitatively how increasing \( K_v \) affects the Nyquist plot and closed-loop stability.

Solution:

The factor \( \dfrac{K_v}{s} \) introduces an integrator and scales the magnitude of the loop transfer function. The second-order term contributes a resonant bump and phase lag around \( \omega_n \). As \( K_v \) increases, the Nyquist curve is radially expanded away from the origin by a factor proportional to \( K_v \), while its shape (as a function of \( \omega \)) is preserved.

For small \( K_v \), the Nyquist plot may stay well away from \( -1 \), yielding \( N = 0 \) and stable closed-loop behavior (after handling the integrator with a modified contour). As \( K_v \) increases, the curve moves closer to \( -1 \); at a critical gain, it passes through \( -1 \), corresponding to a closed-loop pole on the imaginary axis. Further increases cause the Nyquist plot to encircle \( -1 \), giving \( N \neq 0 \) and indicating closed-loop instability. Thus, tuning \( K_v \) requires balancing tracking performance (higher gain) against Nyquist-stability limits.

In this lesson we derived the Nyquist stability criterion from the argument principle of complex analysis, establishing the fundamental relation \( N = P - Z \) between encirclements of \( -1 \), open-loop RHP poles, and closed-loop RHP poles. For unity-feedback loops, Nyquist provides a complete frequency-domain test for closed-loop stability and applies directly to the servo and robotic control systems introduced earlier in the course.

We emphasized:

• The construction of the Nyquist contour and its mapping by \( L(s) \) and \( 1+L(s) \).
• The meaning of clockwise encirclements of \( -1 \) and their relation to RHP poles.
• The consistency between Nyquist and Routh-Hurwitz, illustrated via example closed-loop polynomials.
• Practical computational implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica, suitable for modern robotic control workflows.

Subsequent lessons will use Nyquist plots not only for binary stability decisions but also to quantify relative stability and stability margins in the frequency domain.