Consider a standard single-input single-output (SISO) negative-feedback loop with a plant (the process, e.g., a robot joint) described by a transfer function \( G(s) \), a controller gain \( K \), and (for now) unity feedback. The open-loop transfer function is

\[ L(s) = K\,G(s). \]

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

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

By Chapters 4–7, you already know that the closed-loop poles are the roots of the characteristic equation

\[ 1 + K\,G(s) = 0. \]

More generally, if the feedback path is not unity but has transfer function \( H(s) \), the open-loop transfer function is \( L(s) = K\,G(s)H(s) \) and the characteristic equation remains

\[ 1 + L(s) = 0 \quad \Leftrightarrow \quad 1 + K\,G(s)H(s) = 0. \]

Writing the plant and feedback product as a rational transfer function \( G(s)H(s) = \dfrac{N(s)}{D(s)} \) with real-coefficient polynomials \( N(s), D(s) \) and \( \deg D = P, \; \deg N = Z \), we obtain the polynomial characteristic equation

\[ 1 + K \frac{N(s)}{D(s)} = 0 \quad \Longleftrightarrow \quad D(s) + K\,N(s) = 0. \]

For a fixed value of \( K \), the roots of \( D(s) + K\,N(s) \) are the closed-loop poles. As \( K \) varies over a continuum of nonnegative real numbers, these roots trace out continuous curves in the complex plane.

Definition (Root locus). The root locus of the open-loop transfer function \( L(s) = K\,G(s)H(s) \) is the set of all points \( s \in \mathbb{C} \) for which

\[ 1 + L(s) = 0 \quad \text{for some real } K \ge 0. \]

Equivalently, the root locus is the union over all \( K \ge 0 \) of the closed-loop pole sets \( \{ s_i(K) \}_{i=1}^P \), where \( P \) is the number of poles of \( G(s)H(s) \).

flowchart TD
  A["Plant model G(s)"] --> B["Open-loop L(s) = K * G(s)"]
  B --> C["Closed-loop char. eq. 1 + L(s) = 0"]
  C --> D["Solve for poles s_i(K)"]
  D --> E["Plot s_i(K) in complex plane"]
  E --> F["Interpret stability & transient response vs K"]
        

In robotics, \( G(s) \) often models an actuated joint or link, and \( K \) is a proportional (or part of a PID) gain. The root locus lets you see how changing \( K \) modifies the locations of the joint dynamics poles and therefore the speed, damping, and stability of the motion.

Let us write the denominator and numerator as real polynomials

\[ D(s) = s^P + a_{P-1}s^{P-1} + \dots + a_1 s + a_0, \quad N(s) = b_Z s^Z + b_{Z-1} s^{Z-1} + \dots + b_1 s + b_0. \]

The characteristic polynomial then becomes

\[ \Delta(s;K) = D(s) + K N(s) = s^P + \alpha_{P-1}(K) s^{P-1} + \dots + \alpha_0(K), \]

where each coefficient \( \alpha_i(K) \) depends affinely on \( K \):

\[ \alpha_i(K) = a_i + K\,\tilde{b}_i, \quad \tilde{b}_i = 0 \text{ if the power corresponding to } a_i \text{ is higher than } Z. \]

The mapping \( K \mapsto (\alpha_{P-1}(K), \dots, \alpha_0(K)) \) is continuous, and the roots of a polynomial depend continuously on its coefficients. Therefore, each closed-loop pole \( s_i(K) \) moves along a continuous curve as \( K \) varies.

Because all coefficients are real for real \( K \), if \( s \) is a complex root, so is its conjugate \( \bar{s} \). Thus the root locus is symmetric with respect to the real axis.

Stability for a given \( K \) is determined by whether all poles lie in the open left half-plane:

\[ \text{Closed-loop stable for gain } K \quad \Longleftrightarrow \quad \Re\big(s_i(K)\big) < 0 \text{ for all } i. \]

To understand the root locus conceptually, it is essential to study the behavior of the roots as \( K \) approaches extreme values.

3.1 Behaviour as \( K \to 0^+ \)

For very small positive gain \( K \), we can treat \( K N(s) \) as a perturbation of \( D(s) \):

\[ \Delta(s;K) = D(s) + K N(s), \quad K \approx 0. \]

When \( K = 0 \), we have \( \Delta(s;0) = D(s) \), so the roots of \( \Delta(s;0) \) are precisely the poles of \( G(s)H(s) \). By continuity of roots with respect to coefficients, each closed-loop root \( s_i(K) \) for small \( K > 0 \) is close to a distinct root of \( D(s) = 0 \). Hence:

Property. As \( K \to 0^+ \), each branch of the root locus originates at an open-loop pole of \( G(s)H(s) \).

3.2 Behaviour as \( K \to +\infty \)

For large gain \( K \), factor \( K \) from the characteristic polynomial:

\[ \Delta(s;K) = D(s) + K N(s) = K \left( N(s) + \frac{1}{K}D(s) \right). \]

For \( K \to +\infty \), the term \( \dfrac{1}{K}D(s) \) vanishes, so the dominant equation is

\[ N(s) = 0. \]

Thus, provided \( N(s) \not\equiv 0 \),

Property. As \( K \to +\infty \), each branch of the root locus terminates either at an open-loop zero (finite root of \( N(s) \)) or at infinity along certain asymptotic directions.

If the number of poles is \( P \) and the number of zeros is \( Z \), then there are \( P \) branches (one branch per open-loop pole). Exactly \( Z \) of these branches terminate at finite open-loop zeros, and the remaining \( P - Z \) branches go to infinity. The detailed asymptotic geometry (centroid and angles) will be developed in later lessons.

Consider a robot joint approximated by a double integrator with viscous damping (e.g., motor inertia and viscous friction). A simplified transfer function from control torque to joint position might be modeled as

\[ G(s) = \frac{1}{s(s+2)}. \]

With unity feedback and proportional gain \( K \), the open-loop transfer function is \( L(s) = K G(s) \). The closed-loop characteristic equation is

\[ 1 + \frac{K}{s(s+2)} = 0 \quad \Longleftrightarrow \quad s(s+2) + K = 0 \quad \Longleftrightarrow \quad s^2 + 2s + K = 0. \]

The roots are given explicitly by the quadratic formula:

\[ s_{1,2}(K) = -1 \pm \sqrt{1 - K}. \]

• For \( 0 \le K < 1 \), the roots are real and distinct. Both poles lie on the real axis and move toward each other as \( K \) increases.
• At \( K = 1 \), the roots coincide at \( s = -1 \).
• For \( K > 1 \), the roots form a complex-conjugate pair with real part \( -1 \) and imaginary part \( \pm \sqrt{K - 1} \). Thus they move vertically along the line \( \Re(s) = -1 \).

The root locus for this system therefore consists of:

• Two real poles starting at \( s = 0 \) and \( s = -2 \) when \( K = 0 \).
• The poles collide at \( s = -1 \) for \( K = 1 \).
• A complex-conjugate pair going off along the vertical line \( \Re(s) = -1 \) as \( K \) increases.

For all \( K \ge 0 \), the real part is \( -1 \), so the system remains asymptotically stable. However, as \( K \) increases, the imaginary part grows and transient oscillations increase, which earlier chapters relate to reduced damping ratio and increased overshoot.

Most modern control-design tools (MATLAB, Python control libraries, and robot design environments) compute root loci numerically. Given numerator and denominator coefficient vectors for \( G(s)H(s) = \frac{N(s)}{D(s)} \), a straightforward algorithm is:

1. Choose a grid of gain values \( K_0, K_1, \dots, K_M \).
2. For each \( K_j \), form the characteristic polynomial \( \Delta(s;K_j) = D(s) + K_j N(s) \).
3. Compute all roots of \( \Delta(s;K_j) \) (e.g., via the companion matrix or a numerical root-finding routine).
4. Plot the roots in the complex plane and connect points corresponding to nearby \( K_j \) values.

flowchart TD
  K["Select gain grid K_0,...,K_M"] --> LOOP["For each K_j"]
  LOOP --> POLY["Form char. poly D(s) + K_j N(s)"]
  POLY --> ROOTS["Compute roots s_i(K_j)"]
  ROOTS --> STORE["Store (Re, Im) pairs"]
  STORE --> PLOT["Plot points; connect to form root locus"]
        

This algorithm is language-agnostic and underlies the root-locus plotting routines in control libraries that are widely used in robotics (for example, when tuning joint servo gains in simulation before deploying to a robot).

The python-control library is a standard tool for classical control analysis and is often used alongside robotics toolboxes (e.g., Python Robotics Toolbox) to tune joint-level controllers in simulation. Below we:

• Define the plant \( G(s) = \frac{1}{s(s+2)} \).
• Compute a numerical root locus via a simple loop.
• Compare with the built-in control.root_locus function.

import numpy as np
import matplotlib.pyplot as plt

# Optional: python-control library, very common in robotics/control workflows
try:
    import control
except ImportError:
    control = None

# Open-loop plant: G(s) = 1 / (s (s + 2))
# Numerator and denominator of G(s)
num = np.array([1.0])             # N(s) = 1
den = np.array([1.0, 2.0, 0.0])   # D(s) = s^2 + 2 s + 0

# Pad numerator to same degree as denominator
deg = max(len(den), len(num))
den_padded = np.pad(den, (deg - len(den), 0), mode="constant")
num_padded = np.pad(num, (deg - len(num), 0), mode="constant")

K_values = np.linspace(0.0, 50.0, 200)
poles_real = []
poles_imag = []

for K in K_values:
    # Characteristic polynomial Delta(s;K) = D(s) + K N(s)
    char_poly = den_padded + K * num_padded
    roots = np.roots(char_poly)

    for r in roots:
        poles_real.append(np.real(r))
        poles_imag.append(np.imag(r))

plt.figure()
plt.scatter(poles_real, poles_imag, s=10)
plt.axhline(0.0, linewidth=0.5)
plt.axvline(0.0, linewidth=0.5)
plt.xlabel("Real(s)")
plt.ylabel("Imag(s)")
plt.title("Numerical root locus: G(s) = 1 / (s (s + 2))")

# If python-control is available, overlay its root locus
if control is not None:
    G = control.TransferFunction(num, den)
    control.root_locus(G, kvect=K_values, plot=True)

plt.show()
      

In a robotics context, G could instead represent a linearized joint model (possibly identified experimentally from a robot arm). The same code structure applies; only the numerator and denominator coefficients change.

C++ is commonly used in robotics middleware (e.g., ROS and Orocos). While such frameworks provide higher-level controllers, root-locus reasoning is still used offline when choosing gains. Below is a minimal C++ program that computes the closed-loop poles for the same second-order example as the gain varies.

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

// Example: G(s) = 1 / (s (s + 2)) with unity feedback
// Char. poly: s^2 + 2 s + K = 0

int main() {
    std::vector<double> K_values = {0.0, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 20.0};

    for (double K : K_values) {
        double a2 = 1.0;   // s^2
        double a1 = 2.0;   // s term
        double a0 = K;     // constant term

        double disc = a1 * a1 - 4.0 * a2 * a0;
        std::complex<double> sqrt_disc = std::sqrt(std::complex<double>(disc, 0.0));

        std::complex<double> s1 = (-a1 + sqrt_disc) / (2.0 * a2);
        std::complex<double> s2 = (-a1 - sqrt_disc) / (2.0 * a2);

        std::cout << "K = " << K
                  << "  poles: " << s1
                  << ", " << s2 << std::endl;
    }

    return 0;
}
      

In a ROS-based joint controller, the same math underlies how proportional gains in a ros_control PID loop influence the eigenvalues of the joint dynamics. The above computation can be embedded in offline tuning tools using Eigen for more general polynomial or state-space models.

Java is used in some robotics environments (for example, in educational robots and FIRST robotics via WPILib). We can numerically compute the poles for different gains using a complex-number class. Below we rely on org.apache.commons.math3.complex.Complex.

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

public class RootLocusDemo {
    // Char. poly: s^2 + 2 s + K = 0 for G(s) = 1 / (s (s + 2))

    public static void main(String[] args) {
        List<Double> gains = Arrays.asList(0.0, 0.5, 1.0, 2.0, 5.0, 10.0, 20.0);

        for (double K : gains) {
            double a2 = 1.0;
            double a1 = 2.0;
            double a0 = K;

            double disc = a1 * a1 - 4.0 * a2 * a0;
            Complex sqrtDisc = new Complex(disc, 0.0).sqrt();

            Complex s1 = new Complex(-a1, 0.0).add(sqrtDisc).divide(2.0 * a2);
            Complex s2 = new Complex(-a1, 0.0).subtract(sqrtDisc).divide(2.0 * a2);

            System.out.println("K = " + K + "  poles: " + s1 + ", " + s2);
        }
    }
}
      

In a Java-based robotics stack, you can connect such computations to tools that model actuators and links (e.g., using Apache Commons Math for matrix operations) to visualize how gain selection shifts closed-loop poles before deploying gains to the robot.

9.1 MATLAB/Simulink

MATLAB and Simulink are dominant in robotics and control. The Control System Toolbox offers rlocus and interactive design tools like rltool that are tightly integrated with Robotics System Toolbox models.

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

% Root locus plot
figure;
rlocus(G);
title('Root locus of G(s) = 1 / (s (s + 2))');

% Closed-loop transfer function for a specific gain K
K = 5;
T = feedback(K * G, 1);   % Unity feedback
pole(T)

% In Simulink:
% - Use a Transfer Fcn block for G(s)
% - A Gain block for K
% - Sum block for negative feedback
% - Use the "Control System Designer" or "Root Locus" app to interactively move poles.
      

In a robotic arm model built in Simulink using Robotics System Toolbox, you can linearize around a configuration to obtain \( G(s) \) and then use rlocus to tune joint-space proportional gains.

9.2 Wolfram Mathematica

Mathematica also provides root-locus plotting functions via RootLocusPlot for transfer-function models.

(* Define transfer function model *)
g = TransferFunctionModel[1/(s (s + 2)), s];

(* Root locus as K varies from 0 to 50 *)
RootLocusPlot[g, {k, 0, 50},
  PlotRange -> All,
  Frame -> True,
  FrameLabel -> {"Re(s)", "Im(s)"},
  PlotLabel -> "Root locus of 1/(s (s + 2))"
]

(* Closed-loop poles for a specific gain, e.g., k = 5 *)
cl = SystemsModelFeedback[k g, 1];
Pole[cl] /. k -> 5
      

Such symbolic and numeric tools are useful when deriving theoretical properties of root loci for families of plants arising from robotic manipulators or mobile robots.

Problem 1 (Characteristic equation and root-locus definition). Consider a unity-feedback system with \( G(s)H(s) = \dfrac{N(s)}{D(s)} \). Show that the root locus is the set of all \( s \in \mathbb{C} \) such that \( D(s) + K N(s) = 0 \) for some \( K \ge 0 \).

Solution. The closed-loop transfer function is

\[ T(s) = \frac{K G(s)H(s)}{1 + K G(s)H(s)} = \frac{K N(s)}{D(s) + K N(s)}. \]

Poles of \( T(s) \) are the zeros of its denominator, i.e. the solutions of \( D(s) + K N(s) = 0 \). For each \( K \ge 0 \), the set of closed-loop poles is therefore \( \{ s : D(s) + K N(s) = 0 \} \), and the root locus is the union over all such gains, which proves the statement.

Problem 2 (Start at poles, end at zeros). Let \( D(s) \) and \( N(s) \) be real-coefficient polynomials with no common factors and \( \deg D = P, \deg N = Z \). Argue that the root locus has \( P \) branches that originate at the poles of \( G(s)H(s) \) and terminate at its zeros (finite or at infinity).

Solution. The characteristic polynomial is

\[ \Delta(s;K) = D(s) + K N(s). \]

For \( K = 0 \), the roots of \( \Delta(s;0) = D(s) \) are exactly the poles of \( G(s)H(s) \), and there are \( P \) of them counted with multiplicity. As \( K \) increases from zero, the coefficients change continuously and the roots trace out continuous curves. Thus there are exactly \( P \) branches, each starting at a pole.

As \( K \to +\infty \), we factor out \( K \):

\[ \Delta(s;K) = K\!\left( N(s) + \frac{1}{K}D(s) \right). \]

The roots of \( \Delta(s;K) \) converge to the roots of \( N(s) \) (the zeros of \( G(s)H(s) \)) and, if \( P > Z \), the remaining \( P - Z \) roots go to infinity along certain directions. Hence branches terminate at zeros or at infinity.

Problem 3 (Stability range of a simple plant). For the plant \( G(s) = \dfrac{1}{s(s+2)} \) with unity feedback and gain \( K \ge 0 \), use the explicit poles \( s_{1,2}(K) = -1 \pm \sqrt{1 - K} \) to determine the range of \( K \) values for which the closed loop is asymptotically stable.

Solution. The real part of both poles is always

\[ \Re\big(s_{1,2}(K)\big) = -1. \]

Thus \( \Re\big(s_{1,2}(K)\big) < 0 \) for all \( K \ge 0 \), and the closed loop is asymptotically stable for all nonnegative \( K \). Stability does not constrain \( K \) in this particular example, although transient response (overshoot and oscillation) does.

Problem 4 (Robot joint model with damping). Consider a simplified joint model in a robotic manipulator:

\[ G(s) = \frac{10}{s^2 + 3s}, \]

with unity feedback and proportional gain \( K \). Derive the characteristic equation and show that the closed-loop poles satisfy \( s^2 + 3s + 10K = 0 \). For what range of \( K \ge 0 \) is the system asymptotically stable?

Solution. The open-loop transfer function is

\[ L(s) = K G(s) = \frac{10K}{s^2 + 3s}. \]

The characteristic equation is

\[ 1 + \frac{10K}{s^2 + 3s} = 0 \quad \Longleftrightarrow \quad s^2 + 3s + 10K = 0. \]

This is a second-order polynomial with positive coefficients for \( K \ge 0 \). By the Routh-Hurwitz criterion for second-order polynomials, the system is asymptotically stable if and only if all coefficients are positive. Here \( 1 > 0 \), \( 3 > 0 \), and \( 10K \ge 0 \) for \( K \ge 0 \), so the system is asymptotically stable for all \( K \ge 0 \). As \( K \) increases the poles move further into the left half-plane, resulting in faster but potentially more oscillatory motion depending on the damping ratio.

Problem 5 (Numerical root-locus algorithm). Suppose you are given coefficient vectors \( \mathbf{d} \) and \( \mathbf{n} \) for \( D(s) \) and \( N(s) \). Describe how you would implement a numerical root-locus plotter in software without relying on a control library. Specify the main steps and explain why the algorithm approximates the true root locus.

Solution. The algorithm is:

• Pad \( \mathbf{d} \) and \( \mathbf{n} \) with zeros so that they correspond to polynomials of the same degree \( P = \max(\deg D, \deg N) \).
• Choose a grid of gain values, e.g., \( K_0, \dots, K_M \) covering the interval of interest.
• For each \( K_j \), form the characteristic polynomial coefficients \( \boldsymbol{\alpha}(K_j) = \mathbf{d} + K_j \mathbf{n} \).
• Compute its roots numerically (e.g., via eigenvalues of the companion matrix). Store the real and imaginary parts \( (\Re(s_i(K_j)), \Im(s_i(K_j))) \).
• Plot all stored points in the complex plane and connect those with adjacent gains to visualize branches.

This approximates the true root locus because the polynomial \( \Delta(s;K) = D(s) + K N(s) \) depends continuously on \( K \), and so do its roots. A sufficiently fine gain grid samples the continuous root curves closely.

In this lesson we formally defined the root locus for a SISO feedback system as the set of closed-loop poles obtained from the characteristic equation \( 1 + K G(s)H(s) = 0 \) as the real gain \( K \ge 0 \) varies. By expressing the closed-loop characteristic polynomial as \( \Delta(s;K) = D(s) + K N(s) \), we showed that its coefficients depend affinely on \( K \), which implies that closed-loop poles move continuously in the complex plane and occur in complex-conjugate pairs. We proved that branches of the root locus originate at open-loop poles and terminate at open-loop zeros or infinity. A simple second-order example illustrated how pole locations (and hence stability and transient response) change with gain.

We also outlined a general numerical algorithm for computing root loci and demonstrated implementations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, emphasizing how these tools are used in robotic control design for tuning joint-level controllers. Subsequent lessons will develop the geometric construction rules (angle and magnitude conditions, asymptotes, breakaway points, and imaginary-axis crossings) that make root locus a powerful manual and computer-aided design tool.