When designing feedback controllers via root locus, we typically start from time-domain requirements on the unit-step response of the closed-loop system, such as

• Maximum overshoot \( M_p \) (often in percent),
• Settling time \( T_s \) (e.g. 2% or 5% criterion),
• Rise time \( T_r \) and/or peak time \( T_p \).

These specifications constrain the location of the closed-loop poles \( s_i \). For second-order dominated dynamics, the dominant complex conjugate poles \( s_{1,2} \) can be parametrized by damping ratio \( \zeta \) and natural frequency \( \omega_n \):

\[ s_{1,2} = -\zeta \omega_n \pm j \omega_n \sqrt{1-\zeta^2}, \quad 0 < \zeta < 1,\ \omega_n > 0. \]

Our goal is to convert statements like “overshoot less than 10% and settling time less than 2 s” into inequalities on \( \zeta \) and \( \omega_n \), and then further into geometric regions in the \( s \)-plane that guide root-locus design.

flowchart TD
  A["Given specs: Mp, Ts, Tr, Tp"] --> B["Convert to zeta, omega_n constraints"]
  B --> C["Map to pole coordinates: s = sigma + j*omega_d"]
  C --> D["Geometric constraints: half-planes, rays, circles"]
  D --> E["Overlay on root locus to choose gain/compensator"]
        

We recall the standard second-order closed-loop transfer function introduced earlier:

\[ G_{cl}(s) = \frac{Y(s)}{U(s)} = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \]

with corresponding time-domain differential equation (for a unit-step input \( u(t) = 1(t) \)):

\[ \ddot{y}(t) + 2\zeta \omega_n \dot{y}(t) + \omega_n^2 y(t) = \omega_n^2. \]

For the underdamped case \( 0 < \zeta < 1 \), the homogeneous solution is oscillatory with exponentially decaying envelope. Defining the damped natural frequency \( \omega_d \) as

\[ \omega_d = \omega_n \sqrt{1-\zeta^2}, \]

and using standard solution methods (Chapter 6), the unit-step response can be written as

\[ y(t) = 1 - \frac{1}{\sqrt{1-\zeta^2}}\, e^{-\zeta\omega_n t}\, \sin\!\big(\omega_d t + \phi\big), \]

where \( \phi = \arctan\!\left(\frac{\sqrt{1-\zeta^2}}{\zeta}\right) \). From this expression, closed-form formulas for overshoot, peak time, and approximate settling time can be derived.

The (normalized) maximum overshoot \( M_p \) to a unit-step input is defined as

\[ M_p = \max_{t\geq 0} \big( y(t) - 1 \big), \]

usually expressed in percent as \( M_p^{\%} = 100\,M_p \). The peak occurs at the first time derivative zero-crossing, which is the first peak of the sinusoidal factor:

\[ T_p = \frac{\pi}{\omega_d} = \frac{\pi}{\omega_n \sqrt{1-\zeta^2}}. \]

Evaluating \( y(t) \) at \( T_p \), the sine term becomes \( \sin(\omega_d T_p + \phi) = \sin(\pi + \phi) = -\sin(\phi) \), so

\[ \begin{aligned} y(T_p) &= 1 - \frac{1}{\sqrt{1-\zeta^2}}\, e^{-\zeta\omega_n T_p}\, \sin(\omega_d T_p + \phi) \\ &= 1 + \frac{1}{\sqrt{1-\zeta^2}}\, e^{-\zeta\omega_n T_p}\, \sin(\phi). \end{aligned} \]

Using \( \tan(\phi) = \frac{\sqrt{1-\zeta^2}}{\zeta} \), a short trigonometric calculation gives \( \sin(\phi) = \sqrt{1-\zeta^2} \), so

\[ y(T_p) = 1 + e^{-\zeta\omega_n T_p}, \quad\Rightarrow\quad M_p = y(T_p)-1 = e^{-\zeta\omega_n T_p}. \]

Substituting \( T_p = \frac{\pi}{\omega_d} \) and \( \omega_d = \omega_n \sqrt{1-\zeta^2} \) yields the well-known formula

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

In design, we usually know \( M_p \) (from specification) and need \( \zeta \). Inverting the expression:

\[ \ln(M_p) = \frac{-\pi \zeta}{\sqrt{1-\zeta^2}} \quad\Rightarrow\quad \zeta = \frac{-\ln(M_p)}{\sqrt{\pi^2 + \big(\ln(M_p)\big)^2}}. \]

Thus, a maximum overshoot requirement \( M_p^{\%} \leq M_{p,\max}^{\%} \) translates to a lower bound on the damping ratio:

\[ \zeta \geq \zeta_{\min} = \frac{-\ln\!\left(M_{p,\max}^{\%}/100\right)}% {\sqrt{\pi^2 + \big(\ln\!\left(M_{p,\max}^{\%}/100\right)\big)^2}}. \]

This inequality will appear as a conical region (between two rays) in the \( s \)-plane, as discussed below.

The approximate 2% settling time \( T_s \) is defined as the time after which the response remains within 2% of the final value:

\[ \lvert y(t) - 1 \rvert \leq 0.02, \quad \forall t \geq T_s. \]

For second-order underdamped systems, the oscillatory part is modulated by the envelope \( e^{\sigma t} \), where \( \sigma = \Re(s_{1,2}) = -\zeta\omega_n < 0 \). Ignoring the sinusoidal variation, a simple envelope approximation is

\[ \lvert y(t) - 1 \rvert \approx K e^{\sigma t}, \]

for some constant \( K \) of order one. Requiring \( \lvert y(T_s) - 1 \rvert \approx 0.02 \) and taking \( K \approx 1 \) leads to

\[ 0.02 \approx e^{\sigma T_s} \quad\Rightarrow\quad \sigma \approx \frac{\ln(0.02)}{T_s} = \frac{-\lvert \ln(0.02)\rvert}{T_s}. \]

Since \( \lvert \ln(0.02)\rvert \approx 3.9 \), a widely used approximation is

\[ T_s \approx \frac{4}{\lvert \sigma \rvert} = \frac{4}{\zeta \omega_n}. \]

Thus, a requirement \( T_s \leq T_{s,\max} \) implies

\[ \zeta \omega_n \geq \frac{4}{T_{s,\max}}. \]

From the pole representation \( s = \sigma + j\omega_d \), the envelope decay rate is \( \sigma = \Re(s) \), so we can also express the settling-time constraint as a vertical line in the \( s \)-plane:

\[ \Re(s) \leq \sigma_{\max}, \quad \sigma_{\max} = \frac{\ln(0.02)}{T_{s,\max}}, \]

or, with the simpler approximation \( \sigma_{\max} \approx -\frac{4}{T_{s,\max}} \). All acceptable dominant poles must lie to the left of this vertical line.

The peak time has already been derived as \( T_p = \frac{\pi}{\omega_d} \). The rise time \( T_r \) (e.g., time between 10% and 90% of the final value) does not admit such a compact exact expression, but for typical damping ratios \( 0.4 \leq \zeta \leq 0.8 \), one can derive a good approximation:

\[ T_r \approx \frac{\pi - \theta}{\omega_d}, \quad \theta = \arctan\!\left(\frac{\sqrt{1-\zeta^2}}{\zeta}\right), \]

where \( \theta \) is the phase angle of the pole (measured from the negative real axis). In practice, design is typically driven by overshoot \( M_p \) and settling time \( T_s \); then \( T_r \) and \( T_p \) follow automatically.

To obtain geometric constraints, note that for a complex pole \( s = \sigma + j\omega_d \) we have

\[ \omega_n = \lvert s \rvert = \sqrt{\sigma^2 + \omega_d^2}, \quad \zeta = \frac{-\sigma}{\omega_n} = \frac{-\sigma}{\sqrt{\sigma^2 + \omega_d^2}}. \]

Therefore:

• Constant damping ratio \( \zeta = \zeta_0 \) corresponds to a straight line (ray) from the origin in the left half-plane. Indeed, \( \zeta_0 = \frac{-\sigma}{\sqrt{\sigma^2 + \omega_d^2}} \) implies a constant angle between the line from the origin to \( s \) and the negative real axis.
• Constant natural frequency \( \omega_n = \omega_{n0} \) corresponds to the circle \( \sigma^2 + \omega_d^2 = \omega_{n0}^2 \).
• Settling time constraint gives a vertical line \( \Re(s) = \sigma_{\max} \); acceptable poles lie to the left.

Combining these, a specification such as \( M_p^{\%} \leq 10\% \) and \( T_s \leq 2 \text{ s} \) defines an acceptable region as:

1. All poles with \( \zeta \geq \zeta_{\min} \) for 10% overshoot.
2. All poles with \( \Re(s) \leq \sigma_{\max} \approx -2 \) (since \( T_s \approx 4/2 = 2 \)).

The intersection of these sets is a wedge-shaped region in the left half-plane. During root locus design, we choose controller parameters so that the dominant closed-loop poles lie in this region.

flowchart TD
  S["Compute zeta_min from Mp_max"] --> L1["Draw constant-zeta rays in s-plane"]
  S2["Compute sigma_max from Ts_max"] --> L2["Draw vertical line sigma = sigma_max"]
  L1 --> R["Acceptable region = intersection"]
  L2 --> R
  R --> D["Choose gain/compensator so dominant poles lie in region"]
        

In robotics and mechatronics, these mappings are implemented in software to automatically check whether candidate closed-loop poles (for example along a root locus) satisfy time-domain specifications. Below we provide implementations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.

6.1 Python (with python-control for robotics)

We first implement helper functions to convert overshoot and settling time to \( \zeta \) and \( \omega_n \), then illustrate their use on a simple robotic joint model using the control toolbox (often used in robotics for DC motor and servo modeling).

import numpy as np

def zeta_from_Mp(Mp_percent: float) -> float:
    """
    Compute damping ratio zeta from percent overshoot Mp_percent (e.g. 10 for 10%).
    Valid for 0 < Mp_percent < 100.
    """
    Mp = Mp_percent / 100.0
    if Mp <= 0.0 or Mp >= 1.0:
        raise ValueError("Mp_percent must be between 0 and 100.")
    lnMp = np.log(Mp)
    zeta = -lnMp / np.sqrt(np.pi**2 + lnMp**2)
    return zeta

def sigma_from_Ts(Ts: float, perc: float = 2.0) -> float:
    """
    Compute approximate real-part bound sigma_max from settling time Ts.
    For perc = 2, use Ts ≈ 4/|sigma|; for perc = 5, Ts ≈ 3/|sigma|.
    """
    if Ts <= 0.0:
        raise ValueError("Ts must be positive.")
    if perc == 2.0:
        return -4.0 / Ts
    elif perc == 5.0:
        return -3.0 / Ts
    else:
        # Generic exponential bound from perc%
        eps = perc / 100.0
        return np.log(eps) / Ts  # negative

def check_pole_constraints(s: complex, Mp_percent: float, Ts: float) -> bool:
    """
    Check if a given pole s satisfies Mp ≤ Mp_percent and Ts ≤ Ts.
    """
    sigma = s.real
    omega_d = abs(s.imag)
    if sigma >= 0.0:
        return False  # unstable or marginal

    # compute zeta from s
    omega_n = np.sqrt(sigma**2 + omega_d**2)
    zeta = -sigma / omega_n

    # required zeta from Mp
    zeta_min = zeta_from_Mp(Mp_percent)
    # required sigma from Ts (2% criterion)
    sigma_max = sigma_from_Ts(Ts, perc=2.0)

    return (zeta >= zeta_min) and (sigma <= sigma_max)

# Example: simple DC motor position loop model for a robotic joint
try:
    import control as ctl  # python-control library
except ImportError:
    ctl = None

if ctl is not None:
    # Plant: G(s) = K_m / (J s^2 + b s)
    J = 0.01   # kg m^2
    b = 0.1    # N m s
    K_m = 0.5  # N m / A (simplified)
    num = [K_m]
    den = [J, b, 0.0]
    G = ctl.tf(num, den)

    # Unity feedback with proportional gain Kp
    Kp = 50.0
    L = Kp * G
    T = ctl.feedback(L, 1)

    poles = ctl.pole(T)
    Mp_spec = 10.0  # 10% overshoot
    Ts_spec = 2.0   # 2 s settling time

    print("Closed-loop poles:", poles)
    for p in poles:
        ok = check_pole_constraints(p, Mp_spec, Ts_spec)
        print(f"Pole {p}: meets specs? {ok}")
else:
    print("python-control not installed; skipping plant example.")
      

6.2 C++ (for use in ROS/robotics control nodes)

The following C++ code provides the same analytic mapping, suitable for integration inside a ROS controller or any robotics control loop:

#include <cmath>
#include <iostream>

double zeta_from_Mp(double Mp_percent) {
    double Mp = Mp_percent / 100.0;
    if (Mp <= 0.0 || Mp >= 1.0) {
        throw std::runtime_error("Mp_percent must be between 0 and 100.");
    }
    double lnMp = std::log(Mp);
    double zeta = -lnMp / std::sqrt(M_PI * M_PI + lnMp * lnMp);
    return zeta;
}

double sigma_from_Ts(double Ts, double perc = 2.0) {
    if (Ts <= 0.0) throw std::runtime_error("Ts must be positive.");
    if (std::fabs(perc - 2.0) < 1e-6) {
        return -4.0 / Ts;
    } else if (std::fabs(perc - 5.0) < 1e-6) {
        return -3.0 / Ts;
    } else {
        double eps = perc / 100.0;
        return std::log(eps) / Ts; // negative
    }
}

bool check_pole_constraints(double sigma, double omega_d,
                            double Mp_percent, double Ts) {
    if (sigma >= 0.0) return false; // unstable

    double omega_n = std::sqrt(sigma * sigma + omega_d * omega_d);
    double zeta = -sigma / omega_n;

    double zeta_min = zeta_from_Mp(Mp_percent);
    double sigma_max = sigma_from_Ts(Ts, 2.0);

    return (zeta >= zeta_min) && (sigma <= sigma_max);
}

int main() {
    double sigma = -2.0;
    double omega_d = 3.0;
    double Mp_spec = 10.0;
    double Ts_spec = 2.0;

    bool ok = check_pole_constraints(sigma, omega_d, Mp_spec, Ts_spec);
    std::cout << "Pole s = " << sigma << " + j" << omega_d
              << " satisfies specs? " << (ok ? "yes" : "no") 
              << std::endl;
    return 0;
}
      

6.3 Java (e.g., inside WPILib-based robot code)

Java is common in mobile robotics and competition robotics (e.g. WPILib). The same functions can be implemented as:

public final class TimeSpecUtils {

    public static double zetaFromMp(double MpPercent) {
        double Mp = MpPercent / 100.0;
        if (Mp <= 0.0 || Mp >= 1.0) {
            throw new IllegalArgumentException("MpPercent must be between 0 and 100.");
        }
        double lnMp = Math.log(Mp);
        return -lnMp / Math.sqrt(Math.PI * Math.PI + lnMp * lnMp);
    }

    public static double sigmaFromTs(double Ts, double perc) {
        if (Ts <= 0.0) {
            throw new IllegalArgumentException("Ts must be positive.");
        }
        if (Math.abs(perc - 2.0) < 1e-6) {
            return -4.0 / Ts;
        } else if (Math.abs(perc - 5.0) < 1e-6) {
            return -3.0 / Ts;
        } else {
            double eps = perc / 100.0;
            return Math.log(eps) / Ts; // negative
        }
    }

    public static boolean checkPole(double sigma, double omegaD,
                                    double MpPercent, double Ts) {
        if (sigma >= 0.0) return false;

        double omegaN = Math.sqrt(sigma * sigma + omegaD * omegaD);
        double zeta = -sigma / omegaN;

        double zetaMin = zetaFromMp(MpPercent);
        double sigmaMax = sigmaFromTs(Ts, 2.0);

        return (zeta >= zetaMin) && (sigma <= sigmaMax);
    }

    public static void main(String[] args) {
        double sigma = -3.0;
        double omegaD = 4.0;
        boolean ok = checkPole(sigma, omegaD, 10.0, 1.5);
        System.out.println("Pole satisfies specs? " + ok);
    }
}
      

6.4 MATLAB/Simulink (with Robotics/System Toolboxes)

MATLAB is widely used for robotic arm, mobile robot, and UAV control design. The following script computes \( \zeta_{\min} \) and the vertical line for \( T_s \), then overlays them on a root locus for a plant (for example, a DC motor model from Robotics System Toolbox or a custom transfer function):

function translate_specs_example()
    Mp_percent = 10;   % 10% overshoot
    Ts_max = 2.0;      % 2 s settling time

    zeta_min = zeta_from_Mp(Mp_percent);
    sigma_max = -4 / Ts_max;   % approx 2% criterion

    % Example plant: DC motor-like
    J = 0.01; b = 0.1; K = 0.5;
    num = K;
    den = [J b 0];
    G = tf(num, den);

    figure; rlocus(G);
    hold on;
    % Constant-zeta rays
    % "sgrid" can draw constant zeta and wn lines
    sgrid(zeta_min, []);
    % Vertical line for sigma_max
    x = [sigma_max sigma_max];
    y = ylim;
    plot(x, y, 'r--', 'LineWidth', 1.5);
    title('Root locus with time-domain constraint region');
    hold off;
end

function zeta = zeta_from_Mp(Mp_percent)
    Mp = Mp_percent / 100;
    lnMp = log(Mp);
    zeta = -lnMp / sqrt(pi^2 + lnMp^2);
end
      

In Simulink, the same plant and controller can be modeled using transfer function blocks and PID Controller blocks. The numerical values of \( \zeta_{\min} \) and \( \sigma_{\max} \) guide the placement of closed-loop poles (e.g., via the “Pole-Zero Map” tool or the Control System Tuner app).

6.5 Wolfram Mathematica

Mathematica provides symbolic manipulation and root-locus plotting suitable for theoretical analysis and robotic system modeling:

zetaFromMp[mpPercent_] := Module[{mp, lnmp},
  mp = mpPercent/100.0;
  If[mp <= 0.0 || mp >= 1.0, 
    Return[$Failed]
  ];
  lnmp = Log[mp];
  -lnmp / Sqrt[Pi^2 + lnmp^2]
];

sigmaFromTs[ts_, perc_: 2.0] := Module[{eps},
  If[ts <= 0.0, Return[$Failed]];
  Which[
    Abs[perc - 2.0] < 10^-6, -4.0/ts,
    Abs[perc - 5.0] < 10^-6, -3.0/ts,
    True, (Log[perc/100.0])/ts
  ]
];

checkPole[{sigma_, omegaD_}, mpPercent_, ts_] := Module[
  {omegaN, zeta, zetaMin, sigmaMax},
  If[sigma >= 0.0, Return[False]];
  omegaN = Sqrt[sigma^2 + omegaD^2];
  zeta = -sigma/omegaN;
  zetaMin = zetaFromMp[mpPercent];
  sigmaMax = sigmaFromTs[ts, 2.0];
  zeta >= zetaMin && sigma <= sigmaMax
];

(* Example plant and root locus *)
J = 0.01; b = 0.1; km = 0.5;
G[s_] := km/(J s^2 + b s);

(* Open-loop L(s) = K G(s); use Manipulate for gain K *)
Manipulate[
  Module[{L, T, poles},
    L = K G[s];
    T = L/(1 + L);
    poles = Solve[Denominator[T] == 0, s];
    Print["Closed-loop poles: ", s /. poles];
    RootLocusPlot[G[s], {K, 0, 200}]
  ],
  { {K, 50}, 0, 200 }
]
      

The functions zetaFromMp and sigmaFromTs can be used to compute constraint lines, which can then be superimposed over the root locus using additional graphics primitives.

Problem 1 (Compute ζ from Overshoot). A robotic joint position controller must exhibit less than 10% overshoot to a unit-step command. Assuming the closed-loop dynamics are dominated by a second-order pair, compute the minimum damping ratio \( \zeta_{\min} \).

Solution:

We set \( M_p^{\%} = 10 \), so \( M_p = 0.1 \). Using

\[ \zeta_{\min} = \frac{-\ln(M_p)}{\sqrt{\pi^2 + \big(\ln(M_p)\big)^2}}, \]

with \( M_p = 0.1 \) we compute \( \ln(0.1) = -2.3026 \). Then

\[ \begin{aligned} \zeta_{\min} &= \frac{-(-2.3026)}{\sqrt{\pi^2 + (-2.3026)^2}} \\ &\approx \frac{2.3026}{\sqrt{9.8696 + 5.3019}} = \frac{2.3026}{\sqrt{15.1715}} \approx \frac{2.3026}{3.895} \approx 0.592. \end{aligned} \]

Thus, we require \( \zeta \geq 0.59 \) to satisfy the 10% overshoot requirement.

Problem 2 (Settling Time and Real-Part Bound). For the same joint controller, the 2% settling time must satisfy \( T_s \leq 1.5 \text{ s} \). Estimate the corresponding maximum real part \( \sigma_{\max} \) of the dominant poles using the envelope approximation.

Solution:

Using the rule \( T_s \approx \frac{4}{\lvert \sigma \rvert} \) for the 2% criterion, we obtain

\[ \lvert \sigma \rvert \approx \frac{4}{T_s} \geq \frac{4}{1.5} \approx 2.667, \]

so the real part must satisfy \( \sigma \leq -2.667 \). Hence \( \sigma_{\max} \approx -2.667 \), and the acceptable dominant poles must lie to the left of the vertical line \( \Re(s) = -2.667 \).

Problem 3 (Check a Candidate Pole). A candidate design yields dominant poles at \( s = -3 \pm j\,4 \). Determine whether this design satisfies the specifications \( M_p^{\%} \leq 10\% \) and \( T_s \leq 1.5 \text{ s} \).

Solution:

First compute \( \omega_n \) and \( \zeta \):

\[ \omega_n = \lvert s \rvert = \sqrt{(-3)^2 + 4^2} = 5, \quad \zeta = \frac{-\sigma}{\omega_n} = \frac{3}{5} = 0.6. \]

For \( \zeta = 0.6 \), the normalized overshoot is

\[ M_p = \exp\!\left(\frac{-\pi \zeta}{\sqrt{1-\zeta^2}}\right) = \exp\!\left(\frac{-\pi \cdot 0.6}{\sqrt{1-0.36}}\right) = \exp\!\left(\frac{-1.884}{0.8}\right) = \exp(-2.355) \approx 0.0946, \]

so \( M_p^{\%} \approx 9.46\% < 10\% \), satisfying the overshoot spec. For the settling time:

\[ T_s \approx \frac{4}{\zeta \omega_n} = \frac{4}{0.6 \cdot 5} = \frac{4}{3} \approx 1.333 \text{ s}, \]

which is less than 1.5 s. Therefore, the candidate poles \( s = -3 \pm j\,4 \) meet both specifications.

Problem 4 (Geometry of Constant Damping Ratio Lines). Show that in the \( s \)-plane, the locus of points with constant damping ratio \( \zeta = \zeta_0 \), \( 0 < \zeta_0 < 1 \), is a straight line through the origin at a fixed angle to the negative real axis.

Solution:

For a point \( s = \sigma + j\omega_d \) in the left half-plane, the corresponding natural frequency and damping ratio are

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

Setting \( \zeta = \zeta_0 \) yields

\[ \zeta_0 = \frac{-\sigma}{\sqrt{\sigma^2 + \omega_d^2}} \quad\Rightarrow\quad \zeta_0^2 (\sigma^2 + \omega_d^2) = \sigma^2. \]

Rearranging,

\[ \begin{aligned} \zeta_0^2 \omega_d^2 &= \sigma^2 (1 - \zeta_0^2) \\ \Rightarrow\quad \omega_d^2 &= \sigma^2 \frac{1-\zeta_0^2}{\zeta_0^2} = \sigma^2 \tan^2(\theta_0), \end{aligned} \]

where we defined \( \tan(\theta_0) = \frac{\sqrt{1-\zeta_0^2}}{\zeta_0} \). Thus \( \omega_d = \sigma \tan(\theta_0) \), which is the equation of a straight line through the origin in the \( (\sigma,\omega_d) \) plane with slope \( \tan(\theta_0) \). Since we require \( \sigma < 0 \), only the left half-ray is relevant. This proves that constant damping ratio corresponds to a ray in the left half-plane.

Problem 5 (Decision Flow for Specifications). Suppose you are specifying a controller for a robotic arm axis and are given initial desired values for \( M_p^{\%} \), \( T_s \), and possibly \( T_r \). Describe a logical flow for converting these to \( s \)-plane constraints used in a root-locus design session.

Solution (conceptual flow):

flowchart TD
  P0["Start with Mp%, Ts, (optional Tr)"] --> P1["Compute zeta_min from Mp%"]
  P1 --> P2["Compute sigma_max from Ts"]
  P2 --> P3["Optional: translate Tr to approximate wn range"]
  P3 --> P4["Draw constant-zeta rays and sigma_max line"]
  P4 --> P5["Use region to pick acceptable dominant poles on root locus"]
        

The detailed formulas are exactly those derived in Sections 3–5, and they guide the selection of proportional gains or compensator parameters so that the dominant closed-loop poles lie in the intersection region.

In this lesson we connected classical time-domain specifications to geometric constraints in the \( s \)-plane. For second-order dominated systems, overshoot is governed by the damping ratio \( \zeta \) through a precise exponential relation, while settling time is largely determined by the real part of the dominant poles (or equivalently \( \zeta\omega_n \)). We showed that:

• Overshoot bounds translate to lower bounds on \( \zeta \), giving constant-damping-ratio rays.
• Settling-time bounds translate to constraints on the real part of poles, giving vertical lines in the left half-plane.
• Rise time and peak time follow from \( \zeta \) and \( \omega_n \), and can be approximated analytically.
• Software implementations (Python, C++, Java, MATLAB/Simulink, Mathematica) can automate the translation from time-domain specs to pole constraints, providing practical tools for robotics control design.

In the next lesson, these constraints will be used explicitly to choose feedback gain along a root locus and to begin systematic controller design.