Consider the standard unity-feedback configuration with open-loop transfer function \( L(s) = K G(s) \), where \( K > 0 \) is a tunable scalar gain and \( G(s) \) is fixed:

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

The closed-loop poles are the roots of the characteristic equation

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

Writing \( G(s) = \dfrac{N(s)}{D(s)} \) with \( N(s) \), \( D(s) \) polynomials, the characteristic equation becomes

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

For any candidate complex point \( s^\star \) in the complex plane with \( G(s^\star) \neq 0 \), solve

\[ 1 + K G(s^\star) = 0 \quad \Rightarrow \quad K(s^\star) = -\frac{1}{G(s^\star)} = -\frac{D(s^\star)}{N(s^\star)}. \]

Since we restrict \( K \) to real positive values, a point \( s^\star \) belongs to the root locus if and only if

\[ \angle G(s^\star) = (2\ell+1)\pi,\quad \ell \in \mathbb{Z}, \qquad K = \frac{1}{|G(s^\star)|} > 0. \]

In practice, the root locus is first drawn for the fixed plant \( G(s) \), then a desired point \( s_d \) consistent with time-domain specifications is chosen on the locus, and finally the corresponding gain \( K = 1 / |G(s_d)| \) is calculated.

From Lesson 1 of this chapter, desired step-response specifications for a dominant complex-conjugate pole pair \( s_{1,2} = \sigma \pm j \omega_d \) are expressed in terms of damping ratio \( \zeta \) and natural frequency \( \omega_n \):

\[ \omega_n = \sqrt{\sigma^2 + \omega_d^2}, \qquad \zeta = -\frac{\sigma}{\omega_n},\quad \sigma < 0. \]

For a standard underdamped second-order model, approximate relations are:

\[ M_p \approx 100 \exp\!\left( -\frac{\pi \zeta}{\sqrt{1-\zeta^2}} \right)\ \%, \qquad T_s^{(2\%)} \approx \frac{4}{\zeta \omega_n}. \]

A typical specification such as \( M_p \le 10\% \), \( T_s^{(2\%)} \le 2 \,\text{s} \) defines a wedge and a vertical line in the left-half plane:

• Damping ratio constraint: all admissible poles must lie to the right of a straight line through the origin making angle \( \cos^{-1}(\zeta_{\min}) \) with the negative real axis.
• Settling-time constraint: real part must satisfy \( \sigma \le -\dfrac{4}{T_s^{(2\%)}} \).

Overlaying these regions on the root locus enables geometric gain selection: one searches for the intersection of the locus with the admissible region of the s-plane.

The generic workflow for selecting \( K \) using the root locus can be summarized as follows:

1. Express plant dynamics in transfer-function form \( G(s) \) for the open-loop system.
2. Draw the root locus of \( L(s) = K G(s) \) for \( K \ge 0 \) using analytical rules or software.
3. Convert time-domain requirements to constraints on \( \zeta \), \( \omega_n \) and hence to a region in the s-plane (rays and vertical lines).
4. Choose a candidate dominant pole location \( s_d \) where the root locus intersects the admissible region.
5. Compute the gain \( K \) from the magnitude condition \( K = 1 / |G(s_d)| \).
6. Verify the full closed-loop pole set and time response; iterate if necessary.

flowchart TD
  A["Start with plant G(s)"] --> B["Plot root locus for K >= 0"]
  B --> C["Convert specs to zeta_min, Ts_max"]
  C --> D["Draw admissible region (damping lines + sigma line)"]
  D --> E["Choose candidate pole s_d on locus in region"]
  E --> F["Compute K = 1 / |G(s_d)|"]
  F --> G["Form closed-loop system with this K"]
  G --> H{"Specs satisfied?"}
  H -->|yes| J["Accept K and implement controller"]
  H -->|no| I["Adjust s_d or modify plant/compensator"]
  I --> B
        

For second-order or dominated systems, a single complex-conjugate pair controls the visible transient response. For higher-order systems, one must ensure that the remaining poles are sufficiently fast (far left) so that their effect is negligible.

Consider a normalized DC-motor-like plant with transfer function

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

With proportional gain \( K \), the open-loop transfer function is \( L(s) = K G(s) \), and the closed-loop transfer function becomes

\[ T(s) = \frac{K}{s(s+2) + K} = \frac{K}{s^2 + 2s + K}. \]

The characteristic polynomial is thus

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

with roots

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

For \( K > 1 \), the roots form a complex-conjugate pair:

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

Note that the real part is constant \( \sigma = -1 \), so the root locus in this case is a vertical line in the s-plane. The natural frequency and damping ratio are

\[ \omega_n(K) = \sqrt{1 + (K-1)} = \sqrt{K}, \qquad \zeta(K) = \frac{1}{\sqrt{K}}. \]

The percent overshoot (for \( K > 1 \)) is

\[ M_p(K) \approx 100 \exp\!\left( -\frac{\pi \zeta(K)}{\sqrt{1-\zeta(K)^2}} \right) = 100 \exp\!\left( -\frac{\pi}{\sqrt{K-1}} \right). \]

Meanwhile, the 2&percnt; settling time approximation is

\[ T_s^{(2\%)}(K) \approx \frac{4}{\zeta(K)\omega_n(K)} = \frac{4}{(1/\sqrt{K})\sqrt{K}} = 4 \,\text{s}, \]

independent of \( K \). This is a useful example: the gain can trade overshoot against damping while leaving settling time essentially fixed.

Suppose we desire \( M_p \le 10\% \). We need

\[ 100 \exp\!\left( -\frac{\pi}{\sqrt{K-1}} \right) \le 10 \quad \Rightarrow \quad \exp\!\left( -\frac{\pi}{\sqrt{K-1}} \right) \le 0.1. \]

Taking natural logarithms and solving:

\[ -\frac{\pi}{\sqrt{K-1}} \le \ln(0.1) = -\ln(10) \quad \Rightarrow \quad \sqrt{K-1} \ge \frac{\pi}{\ln(10)}. \]

\[ K \ge 1 + \left(\frac{\pi}{\ln(10)}\right)^2 \approx 2.86. \]

Any gain \( K \gtrsim 2.9 \) yields less than ten percent overshoot with a settling time of about four seconds. This analytic calculation coincides with the gain read off from the root locus at the intersection with the \( \zeta \approx 0.6 \) line.

For a general plant with real poles and zeros

\[ G(s) = \frac{\displaystyle\prod_{i=1}^{m} (s - z_i)}{ \displaystyle\prod_{j=1}^{n} (s - p_j)}, \]

the root locus of \( L(s) = K G(s) \) is the set of all points \( s \) satisfying the angle condition

\[ \sum_{j=1}^{n} \arg(s - p_j) - \sum_{i=1}^{m} \arg(s - z_i) = (2\ell+1)\pi,\quad \ell \in \mathbb{Z}. \]

If a candidate point \( s_d \) lies on the root locus, then the required gain follows from the magnitude condition

\[ |K G(s_d)| = 1 \quad \Rightarrow \quad K = \frac{1}{|G(s_d)|} = \frac{\displaystyle\prod_{j=1}^{n} |s_d - p_j|}{ \displaystyle\prod_{i=1}^{m} |s_d - z_i|}. \]

This formula is the computational backbone of gain selection using root locus: once \( s_d \) is fixed by performance requirements and locus geometry, \( K \) is obtained algebraically using pole-zero distances.

We now implement gain selection for the plant \( G(s) = 1/(s(s+2)) \) using Python and the python-control library (widely used in robotics and mechatronics together with packages such as roboticstoolbox for manipulator modeling).

import numpy as np
import control  # python-control package
import matplotlib.pyplot as plt

# DC-motor-like plant G(s) = 1 / (s (s + 2))
num = [1.0]
den = [1.0, 2.0, 0.0]
G = control.TransferFunction(num, den)

# 1) Visualize the root locus
plt.figure()
control.root_locus(G)  # internally varies K >= 0
plt.title("Root locus of G(s) = 1 / (s (s + 2))")
plt.xlabel("Real axis")
plt.ylabel("Imag axis")
plt.grid(True)

# 2) Given the analytic relation, overshoot depends on K as:
#    Mp(K) = 100 * exp(-pi / sqrt(K - 1)),  K > 1.
def overshoot_from_K(K):
    if K <= 1.0:
        return 0.0  # no oscillation, purely overdamped
    return 100.0 * np.exp(-np.pi / np.sqrt(K - 1.0))

Mp_max = 10.0  # 10 percent
K_grid = np.linspace(1.01, 20.0, 2000)
Mp_vals = np.array([overshoot_from_K(K) for K in K_grid])

# 3) Find the smallest K satisfying Mp(K) <= Mp_max
K_candidates = K_grid[Mp_vals <= Mp_max]
K_star = K_candidates[0] if len(K_candidates) > 0 else None
print(f"Selected gain K* ≈ {K_star:.3f}")

# 4) Construct the closed-loop system and inspect poles
if K_star is not None:
    T = control.feedback(K_star * G, 1)  # unity feedback
    print("Closed-loop poles:", control.pole(T))

    # Step response
    t = np.linspace(0, 10, 1000)
    t, y = control.step_response(T, T=t)

    plt.figure()
    plt.plot(t, y)
    plt.title(f"Step response with K ≈ {K_star:.3f}")
    plt.xlabel("Time [s]")
    plt.ylabel("Output")
    plt.grid(True)

plt.show()
      

For more complex robotic joints, the same structure applies: obtain a linearized joint transfer function from a toolbox (e.g. roboticstoolbox or custom modeling), plot the root locus, overlay damping/settling-time constraints, and search numerically over \( K \) to satisfy them.

We implement the analytic calculation of the minimum gain \( K_{\min} \) required to satisfy a bound on overshoot for the same plant in C++. This pattern appears in embedded robotic controllers (e.g., low-level joint P-controllers compiled into firmware).

#include <iostream>
#include <cmath>

// Overshoot for G(s) = 1 / (s (s + 2)) with P gain K > 1
// Mp(K) = 100 * exp(-pi / sqrt(K - 1))
double overshootFromK(double K) {
    if (K <= 1.0) {
        return 0.0; // overdamped, no oscillatory overshoot
    }
    return 100.0 * std::exp(-M_PI / std::sqrt(K - 1.0));
}

// Solve by simple line search for a K satisfying Mp(K) <= Mp_max
double selectGain(double Mp_max, double K_min, double K_max, double dK) {
    double bestK = -1.0;
    for (double K = K_min; K <= K_max; K += dK) {
        double Mp = overshootFromK(K);
        if (Mp <= Mp_max) {
            bestK = K;
            break;
        }
    }
    return bestK;
}

int main() {
    double Mp_max = 10.0;       // 10 percent overshoot
    double K_min  = 1.01;       // avoid K <= 1 (no complex poles)
    double K_max  = 20.0;
    double dK     = 0.001;

    double K_star = selectGain(Mp_max, K_min, K_max, dK);

    if (K_star > 0.0) {
        std::cout << "Selected gain K* ≈ " << K_star << std::endl;

        // Closed-loop poles are s = -1 ± j sqrt(K - 1)
        double sigma = -1.0;
        double wd    = std::sqrt(K_star - 1.0);
        double zeta  = 1.0 / std::sqrt(K_star);
        double Ts    = 4.0; // 2% settling time ≈ 4 s for this plant

        std::cout << "Dominant poles: s = " << sigma
                  << " ± j " << wd << std::endl;
        std::cout << "Damping ratio zeta ≈ " << zeta << std::endl;
        std::cout << "Approximate Ts(2%) ≈ " << Ts << " s" << std::endl;
    } else {
        std::cout << "No gain in the search range satisfies the overshoot bound."
                  << std::endl;
    }

    return 0;
}
      

In a robotic joint controller, the torque command could be \( \tau = K \, e \), where \( e \) is position error. Once \( K \) is selected, this constant can be compiled into firmware or declared as a tunable parameter via a middleware such as ROS control.

For more general plants (for example, transfer functions extracted from Java-based robotic simulations), roots must be computed numerically. For a second-order closed-loop polynomial \( s^2 + a_1(K)s + a_0(K) \), the poles are obtained from the quadratic formula. Below is a simple Java class that searches for a gain satisfying a desired damping ratio.

public class RootLocusGainSelector {

    // For G(s) = 1 / (s (s + 2)), closed-loop polynomial is
    // s^2 + 2 s + K = 0. Poles: s = -1 ± sqrt(1 - K) or -1 ± j sqrt(K - 1).
    // We compute zeta(K) = 1 / sqrt(K) for K > 1 and search for zeta >= zetaMin.

    public static double dampingRatioFromK(double K) {
        if (K <= 1.0) {
            return 1.0; // overdamped (zeta >= 1)
        }
        return 1.0 / Math.sqrt(K);
    }

    public static double selectGainForZeta(double zetaMin,
                                           double Kmin,
                                           double Kmax,
                                           double dK) {
        double bestK = -1.0;
        for (double K = Kmin; K <= Kmax; K += dK) {
            double zeta = dampingRatioFromK(K);
            if (zeta >= zetaMin && K > 1.0) {
                bestK = K;
                break;
            }
        }
        return bestK;
    }

    public static void main(String[] args) {
        double zetaMin = 0.6;  // e.g., ≈ 10% overshoot requirement
        double Kmin    = 1.01;
        double Kmax    = 20.0;
        double dK      = 0.001;

        double Kstar = selectGainForZeta(zetaMin, Kmin, Kmax, dK);
        if (Kstar > 0.0) {
            System.out.println("Selected gain K* ≈ " + Kstar);
            double zeta = dampingRatioFromK(Kstar);
            double Ts   = 4.0; // as before
            System.out.println("Damping ratio zeta ≈ " + zeta);
            System.out.println("Approximate Ts(2%) ≈ " + Ts + " s");
        } else {
            System.out.println("No suitable gain found in the search interval.");
        }
    }
}
      

Java-based robotic frameworks (e.g., those used in educational robots or FIRST Robotics libraries) can embed such logic for offline gain tuning based on root-locus-informed criteria.

MATLAB's Control System Toolbox provides direct root-locus plotting and gain selection, which can be linked to Simulink models of robotic joints (e.g., via Robotics System Toolbox). For the plant \( G(s) = 1/(s(s+2)) \):

% Define plant
s = tf('s');
G = 1 / (s * (s + 2));

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

% Overlay a damping ratio line, e.g., zeta ≈ 0.6
zeta_target = 0.6;
wn_dummy = 1;  % sgrid draws rays independent of wn value
sgrid(zeta_target, wn_dummy);

% Option 1: Interactively pick a point on the locus to obtain K
% [K_star, poles_star] = rlocfind(G);

% Option 2: Programmatic search for gain that achieves desired zeta
K_vec = linspace(1.01, 20, 2000);
bestK = NaN;
for k = K_vec
    T = feedback(k * G, 1);
    p = pole(T);
    % dominant pole: largest real part
    [~, idx] = max(real(p));
    p_dom = p(idx);
    sigma = real(p_dom);
    wd    = imag(p_dom);
    wn    = sqrt(sigma^2 + wd^2);
    zeta  = -sigma / wn;
    if zeta >= zeta_target
        bestK = k;
        break;
    end
end

fprintf('Selected K* ≈ %.3f\n', bestK);

% Simulink: this K* can be used as the gain of a P-controller block
      

In Simulink, the same gain \( K^\star \) can be applied to a “Gain” block in a feedback loop around a joint or link model. The root locus displayed by rlocus corresponds directly to the closed-loop poles of the Simulink diagram.

Wolfram Mathematica has built-in functionality for control systems and symbolic manipulation, enabling exact algebraic computation of root-locus-based gains for moderate-order plants.

(* Define the transfer function G(s) = 1 / (s (s + 2)) *)
Clear[s, k];
G = TransferFunctionModel[1/(s (s + 2)), s];

(* Root locus plot for k >= 0 *)
RootLocusPlot[k G, {k, 0, 20},
  PlotRange -> All,
  Frame -> True,
  PlotLabel -> "Root locus of G(s) = 1 / (s (s + 2))"
]

(* Symbolic closed-loop poles for generic k *)
T = FeedbackConnect[k G, 1];   (* unity feedback *)
poles = TransferFunctionPoles[T] // Simplify

(* Extract the second-order polynomial and solve explicitly *)
(* Characteristic polynomial is s^2 + 2 s + k = 0 *)
poly = s^2 + 2 s + k;
sol = Solve[poly == 0, s]

(* Damping ratio and natural frequency as functions of k > 1 *)
sigma[k_] := -1;
wd[k_] := Sqrt[k - 1];
wn[k_] := Sqrt[sigma[k]^2 + wd[k]^2];
zeta[k_] := -sigma[k]/wn[k];

(* Solve for k such that Mp(k) = 10% *)
Mp[k_] := 100 Exp[-Pi zeta[k]/Sqrt[1 - zeta[k]^2]];
kStar = FindRoot[Mp[k] == 10, {k, 3}]
      

The symbolic representation is particularly useful when studying how root-locus-based gains scale with physical parameters (e.g., inertia, damping, gear ratio) in robotic actuators.

Problem 1 (Gain from Overshoot Constraint for a Second-Order Plant). For the plant \( G(s) = 1/(s(s+2)) \) with proportional gain \( K \) in unity feedback, derive the minimum gain \( K_{\min} \) required so that the step-response overshoot is less than or equal to 10&percnt;.

Solution:

From Section 4, the closed-loop characteristic polynomial is \( s^2 + 2s + K = 0 \), giving poles \( s = -1 \pm j\sqrt{K-1} \) for \( K > 1 \). Hence,

\[ \omega_n(K) = \sqrt{K}, \qquad \zeta(K) = \frac{1}{\sqrt{K}}. \]

The overshoot is

\[ M_p(K) \approx 100 \exp\!\left( -\frac{\pi \zeta(K)}{\sqrt{1-\zeta(K)^2}} \right) = 100 \exp\!\left( -\frac{\pi}{\sqrt{K-1}} \right). \]

We require \( M_p(K) \le 10 \), so

\[ 100 \exp\!\left(-\frac{\pi}{\sqrt{K-1}}\right) \le 10 \quad \Rightarrow \quad \exp\!\left(-\frac{\pi}{\sqrt{K-1}}\right) \le 0.1. \]

Taking logarithms,

\[ -\frac{\pi}{\sqrt{K-1}} \le \ln(0.1) = -\ln(10) \quad \Rightarrow \quad \sqrt{K-1} \ge \frac{\pi}{\ln(10)}. \]

Squaring and adding 1,

\[ K \ge 1 + \left(\frac{\pi}{\ln(10)}\right)^2 \approx 2.86. \]

Thus \( K_{\min} \approx 2.86 \). On the root locus, this corresponds to the intersection of the vertical line \( \Re\{s\} = -1 \) with the \( \zeta \approx 0.6 \) ray.

Problem 2 (Gain from a Specified Dominant Pole for a Third-Order Plant). Consider an open-loop plant \( G(s) = \dfrac{1}{s(s+2)(s+5)} \) with unity feedback and loop gain \( K \). We desire a dominant pole at \( s_d = -2 + j2 \). Assuming this point lies approximately on the root locus, compute the corresponding gain \( K \) from the magnitude condition.

Solution:

The poles of \( G(s) \) are \( p_1 = 0 \), \( p_2 = -2 \), \( p_3 = -5 \), with no finite zeros. For \( L(s) = K G(s) \), the magnitude condition at \( s_d \) is

\[ |K G(s_d)| = 1 \quad \Rightarrow \quad K = \frac{1}{|G(s_d)|} = \prod_{j=1}^{3} |s_d - p_j|. \]

Compute the pole distances:

\[ |s_d - p_1| = |-2 + j2 - 0| = \sqrt{(-2)^2 + 2^2} = \sqrt{8}, \]

\[ |s_d - p_2| = |-2 + j2 + 2| = |j2| = 2, \]

\[ |s_d - p_3| = |-2 + j2 + 5| = |3 + j2| = \sqrt{3^2 + 2^2} = \sqrt{13}. \]

Therefore

\[ K = \sqrt{8} \cdot 2 \cdot \sqrt{13} = 2\sqrt{8\cdot 13} = 2\sqrt{104} \approx 2 \cdot 10.198 \approx 20.4. \]

A gain \( K \approx 20.4 \) places a closed-loop pole near \( s_d \). The angle condition should also be checked to ensure that \( s_d \) lies on the root locus; in practice, the point is adjusted slightly to lie exactly on the locus while remaining within the admissible region.

Problem 3 (Dominant Pole Approximation with an Additional Fast Pole). A robotic joint actuator is modeled by \( G(s) = \dfrac{1}{s(s+2)(0.1s+1)} \), representing a structural resonance at \( -10 \) in addition to the basic plant used earlier. With proportional gain \( K \), argue under which conditions the gain can be selected using only the reduced model \( \tilde{G}(s) = 1/(s(s+2)) \), and explain how the root locus supports this approximation.

Solution:

The additional pole at \( s = -10 \) is much faster than the dominant pair for moderate values of \( K \) (the real parts of the dominant poles remain near \( -1 \)). On the root locus of the full plant, one branch originates at \( s = -10 \) and quickly remains far to the left as \( K \) varies over the range where the other branches sweep near the imaginary axis.

In the time domain, the mode associated with \( s = -10 \) decays with time constant \( 0.1 \,\text{s} \), which is significantly faster than the approximate settling time of \( 4 \,\text{s} \) determined by the slower poles. Thus,

• The fast mode contributes only a short-lived transient, negligible in the overall step response shape.
• Dominant pole approximation is valid: design \( K \) as if the plant were \( \tilde{G}(s) \), using the root locus and damping/settling constraints, then verify that the actual closed-loop poles of the full system still lie in the desired region.

Root locus plots confirm this: the branch associated with the fast pole remains far in the left half-plane and does not approach the imaginary axis over the range of \( K \) used to meet the specifications. Hence, \( \tilde{G}(s) \) can be used for gain selection as a good approximation.

In this lesson, we connected the scalar gain \( K \) of a unity-feedback loop to closed-loop pole locations via the characteristic equation \( 1 + K G(s) = 0 \) and the root locus. Time-domain specifications were expressed as geometric constraints in the s-plane, and we showed how to select a desired dominant pole \( s_d \) on the locus and compute \( K = 1/|G(s_d)| \) using distances to poles and zeros.

For a simple second-order plant \( 1/(s(s+2)) \), we derived closed-form expressions relating \( K \) to damping ratio, overshoot, and settling time, and obtained the minimum gain required to satisfy a 10&percnt; overshoot bound. Numerical implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica illustrated how root-locus-based gain selection enters practical robotic control design and simulation workflows.