Consider a unity-feedback control loop with plant transfer function \( G(s) \) and controller \( C(s) \). For a reference input \( r(t) \), output \( y(t) \), error \( e(t) = r(t) - y(t) \), and control signal \( u(t) \), the design goals can be grouped as:

• Accuracy: small steady-state error for relevant inputs.
• Speed: short rise time and settling time, acceptable overshoot.
• Effort: control signal compatible with actuator limits and energy constraints.

In many linear control designs, increasing loop gain improves both accuracy (reduces steady-state error) and speed (moves closed-loop poles to the left in the complex plane), but simultaneously increases demanded actuator effort and may worsen overshoot. The purpose of this lesson is to quantify these competing effects for simple system types.

flowchart TD
  R["Performance requirements"] --> ACC["Accuracy \n(small steady-state error)"]
  R --> SPD["Speed \n(short settling time)"]
  R --> EFF["Effort \n(bounded actuator signal)"]
  ACC --> KACC["Tend to increase gain K"]
  SPD --> KSPD["Tend to increase gain K"]
  EFF --> KEFF["Tend to decrease gain K"]
  KACC --> D["Choose controller structure and gain"]
  KSPD --> D
  KEFF --> D
  D --> CHECK["Analyze or simulate closed-loop response"]
        

We introduce precise measures used to quantify each corner of the trade-off triangle. Assume a unity-feedback loop whose closed-loop transfer function from reference to output is \( T(s) \) and whose error transfer function is \( E(s) \), with Laplace transforms \( R(s), Y(s), E(s) \).

2.1 Accuracy: Steady-State Error

For a standard test input (step, ramp, parabolic), the steady-state error is defined as:

\[ e_{\mathrm{ss}} = \lim_{t \to \infty} e(t), \quad e(t) = r(t) - y(t). \]

Using the Final Value Theorem, for inputs with Laplace transform \( R(s) \) and unity feedback,

\[ e_{\mathrm{ss}} = \lim_{s \to 0} s E(s) = \lim_{s \to 0} s \frac{R(s)}{1 + C(s) G(s)}. \]

In previous lessons we introduced static error constants and system type, which summarize \( e_{\mathrm{ss}} \) for step, ramp, and parabolic inputs.

2.2 Speed: Time-Domain Transient Indices

For second-order dominant closed-loop dynamics with transfer function

\[ T(s) = \frac{\omega_n^2}{s^2 + 2 \zeta \omega_n s + \omega_n^2}, \]

standard transient measures for a unit step input include:

\[ \begin{aligned} t_{\mathrm{s}} &\approx \frac{4}{\zeta \omega_n} && \text{(settling time, about two percent band)},\\[4pt] M_{\mathrm{p}} &= \exp\!\Bigg( -\frac{\pi \zeta}{\sqrt{1 - \zeta^2}} \Bigg) && \text{(maximum overshoot, as a fraction)},\\[4pt] t_{\mathrm{p}} &= \frac{\pi}{\omega_n \sqrt{1 - \zeta^2}} && \text{(peak time)}. \end{aligned} \]

Speed improves as the closed-loop poles move leftward (larger real part in magnitude, higher \( \omega_n \)), but overshoot generally increases when the damping ratio \( \zeta \) becomes small.

2.3 Effort: Actuator Limits and Control Energy

Let the control or actuator signal be \( u(t) \). A realistic actuator can supply at most some magnitude \( u_{\max} \), so we define:

\[ u_{\max} = \sup_{t \ge 0} \lvert u(t) \rvert, \]

and we often consider a transient effort measure such as

\[ J_{u,\mathrm{tr}} = \int_{0}^{\infty} \bigl(u(t) - u_{\mathrm{ss}}\bigr)^2 \,\mathrm{d}t, \quad u_{\mathrm{ss}} = \lim_{t \to \infty} u(t). \]

Both \( u_{\max} \) and \( J_{u,\mathrm{tr}} \) tend to increase with feedback gain, even as performance metrics like \( e_{\mathrm{ss}} \) and \( t_{\mathrm{s}} \) improve.

Consider a simple first-order plant with unity time constant, \( G(s) = \frac{1}{s + 1} \), and a proportional controller \( C(s) = K \) in a unity-feedback loop. The closed-loop transfer function from step reference to output is

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

For a unit step reference \( r(t) = 1 \), the time-domain response is obtained by inverse Laplace transform:

\[ y(t) = \frac{K}{1 + K} \bigl(1 - \mathrm{e}^{-(1+K)t}\bigr), \qquad t \ge 0. \]

3.1 Steady-State Error and Speed

The steady-state output is \( y_{\mathrm{ss}} = \frac{K}{1+K} \), so the steady-state error to a unit step is

\[ e_{\mathrm{ss}} = 1 - y_{\mathrm{ss}} = \frac{1}{1 + K}. \]

As \( K \) increases, \( e_{\mathrm{ss}} \) decreases monotonically:

\[ \frac{\mathrm{d} e_{\mathrm{ss}}}{\mathrm{d} K} = -\frac{1}{(1 + K)^2} < 0 \quad \text{for } K > 0. \]

The closed-loop pole is at \( s = -(1+K) \). This is a first-order system with time constant \( \tau_{\mathrm{cl}} = \frac{1}{1+K} \), and a standard approximation for the two-percent settling time is

\[ t_{\mathrm{s}} \approx 4 \tau_{\mathrm{cl}} = \frac{4}{1 + K}. \]

Differentiating,

\[ \frac{\mathrm{d} t_{\mathrm{s}}}{\mathrm{d} K} = -\frac{4}{(1 + K)^2} < 0, \]

so increasing \( K \) simultaneously improves steady-state accuracy (smaller \( e_{\mathrm{ss}} \)) and speed (smaller \( t_{\mathrm{s}} \)).

3.2 Actuator Effort

The control signal is \( u(t) = K e(t) = K (1 - y(t)) \). In the Laplace domain:

\[ u(s) = \frac{K}{1 + K G(s)} R(s) = K \frac{s + 1}{s \bigl(s + 1 + K\bigr)}, \qquad R(s) = \frac{1}{s}. \]

Partial fraction expansion yields

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

Hence,

\[ u(t) = \frac{K}{1 + K} + \frac{K^2}{1 + K} \mathrm{e}^{-(1+K)t}, \qquad t \ge 0. \]

At the instant just after the step, \( u(0^{+}) = \frac{K}{1+K} + \frac{K^2}{1+K} = K \). The maximum control magnitude is therefore \( u_{\max} = K \), and if the actuator has a hard limit \( u_{\max,\mathrm{act}} \) then we must choose \( K \) such that

\[ K \le u_{\max,\mathrm{act}}. \]

3.3 Transient Control Energy

To avoid divergence from the steady-state control level, we consider the transient control signal \( u_{\mathrm{tr}}(t) = u(t) - u_{\mathrm{ss}} \) with \( u_{\mathrm{ss}} = \frac{K}{1+K} \). From the expression above,

\[ u_{\mathrm{tr}}(t) = \frac{K^2}{1 + K} \mathrm{e}^{-(1+K)t}. \]

A simple effort measure is

\[ J_{u,\mathrm{tr}} = \int_{0}^{\infty} u_{\mathrm{tr}}^2(t)\,\mathrm{d}t = \frac{K^4}{2 (1 + K)^3}, \]

which increases monotonically with \( K \) for \( K > 0 \). Thus, while accuracy and speed both improve with higher gain, the transient energy demanded from the actuator grows.

Consider a plant with one pole at the origin and one real pole at \(-1\),

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

controlled by a proportional gain \( C(s) = K \) in unity feedback. The open-loop transfer function is \( L(s) = \frac{K}{s (s + 1)} \).

4.1 Closed-Loop Poles and Transient Behavior

The closed-loop characteristic polynomial is

\[ 1 + L(s) = 0 \quad \Rightarrow \quad s^2 + s + K = 0. \]

Comparing with the standard form \( s^2 + 2 \zeta \omega_n s + \omega_n^2 = 0 \), we obtain

\[ \omega_n^2 = K, \qquad 2 \zeta \omega_n = 1 \quad \Rightarrow \quad \omega_n = \sqrt{K}, \quad \zeta = \frac{1}{2 \sqrt{K}}. \]

As \( K \) increases, the natural frequency \( \omega_n \) increases but the damping ratio \( \zeta \) decreases. Using the overshoot formula,

\[ M_{\mathrm{p}}(K) = \exp\!\Bigg( -\frac{\pi \zeta}{\sqrt{1 - \zeta^2}} \Bigg) = \exp\!\Bigg( -\frac{\pi}{\sqrt{4 K - 1}} \Bigg), \quad K > \tfrac{1}{4}, \]

we see that \( M_{\mathrm{p}}(K) \) increases with \( K \): better speed and higher loop gain lead to less damping and larger overshoot for this plant.

4.2 Ramp Accuracy

Because there is one pole at the origin, the loop is type 1. The velocity error constant is

\[ K_{\mathrm{v}} = \lim_{s \to 0} s L(s) = \lim_{s \to 0} \frac{K}{s + 1} = K. \]

For a unit ramp input \( r(t) = t \), the steady-state error is

\[ e_{\mathrm{ss, ramp}} = \frac{1}{K_{\mathrm{v}}} = \frac{1}{K}. \]

Thus, reducing ramp steady-state error requires increasing \( K \), which in this example also increases overshoot and actuator demand. For example, \( K = 10 \) yields \( e_{\mathrm{ss, ramp}} = 0.1 \), but the corresponding damping ratio \( \zeta = \frac{1}{2 \sqrt{10}} \) is small and \( M_{\mathrm{p}} \) exceeds fifty percent.

Suppose we impose three scalar constraints on the first-order system of Section 3:

• Accuracy: \( e_{\mathrm{ss}} = \frac{1}{1 + K} \le \varepsilon_{\max} \).
• Speed: \( t_{\mathrm{s}} = \frac{4}{1 + K} \le T_{\max} \).
• Actuator limit: \( u_{\max} = K \le u_{\max,\mathrm{act}} \).

These yield inequalities on \( K \):

\[ \begin{aligned} \frac{1}{1 + K} \le \varepsilon_{\max} &\quad \Rightarrow \quad K \ge \frac{1}{\varepsilon_{\max}} - 1, \\[4pt] \frac{4}{1 + K} \le T_{\max} &\quad \ Rightarrow \quad K \ge \frac{4}{T_{\max}} - 1, \\[4pt] K \le u_{\max,\mathrm{act}}. \end{aligned} \]

The admissible gains form an interval \( K_{\min} \le K \le K_{\max} \) where

\[ K_{\min} = \max\!\Bigl( \frac{1}{\varepsilon_{\max}} - 1,\, \frac{4}{T_{\max}} - 1 \Bigr), \quad K_{\max} = u_{\max,\mathrm{act}}. \]

If \( K_{\min} \le K_{\max} \), then a feasible gain exists. If \( K_{\min} > K_{\max} \), it is impossible to satisfy all three constraints simultaneously with a simple proportional controller, signaling the need to relax specifications or modify the controller structure (for example, adding integral action or using pre-filters).

flowchart TD
  S["Specify bounds on error, \nsettling time, and actuator limit"] --> A["Convert each bound to an interval for K"]
  A --> A1["Interval from accuracy"]
  A --> A2["Interval from speed"]
  A --> A3["Interval from effort"]
  A1 --> I["Intersect intervals for K"]
  A2 --> I
  A3 --> I
  I --> FEAS["Intersection non-empty: \nchoose K in feasible range"]
  I --> INFEAS["Intersection empty: \nrelax specs or change controller"]
        

A more systematic viewpoint is to encode several objectives into a scalar cost function and choose the gain that minimizes it. For the first-order system of Section 3, let

\[ e_{\mathrm{ss}}(K) = \frac{1}{1 + K}, \quad t_{\mathrm{s}}(K) = \frac{4}{1 + K}, \quad J_{u,\mathrm{tr}}(K) = \frac{K^4}{2 (1 + K)^3}. \]

For nonnegative weights \( \alpha, \beta, \gamma \), consider the cost

\[ J(K) = \alpha \, e_{\mathrm{ss}}(K)^2 + \beta \, t_{\mathrm{s}}(K)^2 + \gamma \, J_{u,\mathrm{tr}}(K). \]

Then

\[ J(K) = \frac{\alpha + 16 \beta}{(1 + K)^2} + \gamma \frac{K^4}{2 (1 + K)^3}. \]

For \( K \to 0^{+} \), the first term dominates and \( J(K) \) is large because error and settling time are large. For \( K \to \infty \), the last term dominates and \( J(K) \) grows due to control effort. Therefore, there exists a finite gain \( K^{\ast} \) that minimizes \( J(K) \), illustrating that the combined objectives yield an optimal compromise between accuracy, speed, and effort.

We simulate the first-order system \( G(s) = \frac{1}{s+1} \) with unity feedback and proportional gain \( K \), using explicit time-domain integration. This kind of simulation is a building block for robotics control stacks (for example in Python using the python-control library together with robotic middleware such as ROS, though here we use only basic numerical integration).

import numpy as np

def simulate_first_order(K, t_final=10.0, dt=1e-3):
    """
    Plant: xdot = -x + u, y = x
    Controller: u = K * (r - y), with unit step reference r(t) = 1.
    Unity feedback.
    """
    n_steps = int(t_final / dt)
    t = np.linspace(0.0, t_final, n_steps + 1)
    x = 0.0
    y = np.zeros_like(t)
    u = np.zeros_like(t)
    r = 1.0

    for k in range(n_steps + 1):
        e = r - x   # x is current output
        u[k] = K * e
        y[k] = x
        # Euler integration of xdot = -x + u
        xdot = -x + u[k]
        x = x + dt * xdot

    y_ss = y[-1]
    ess = r - y_ss
    # approximate two percent settling time
    tol = 0.02 * abs(y_ss)
    ts = t[-1]
    for k in range(len(t)):
        if np.all(np.abs(y[k:] - y_ss) <= tol):
            ts = t[k]
            break
    umax = np.max(np.abs(u))
    return t, y, u, ess, ts, umax

if __name__ == "__main__":
    for K in [1.0, 2.0, 5.0, 10.0]:
        t, y, u, ess, ts, umax = simulate_first_order(K)
        print(f"K = {K:4.1f} | ess = {ess:.4f}, ts = {ts:.3f}, umax = {umax:.3f}")
      

Running this code for increasing \( K \) will show decreasing steady-state error and settling time, but growing peak control \( u_{\max} \), in accordance with the analytical formulas derived earlier.

The same first-order loop can be simulated in C++, which is common in embedded and robotics control (for example in firmware of servo drives or in ROS nodes using matrix libraries such as Eigen). Below is a minimal implementation using Euler integration.

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

struct Metrics {
    double ess;
    double ts;
    double umax;
};

Metrics simulateFirstOrder(double K, double tFinal = 10.0, double dt = 1e-3) {
    int nSteps = static_cast<int>(tFinal / dt);
    std::vector<double> y(nSteps + 1), u(nSteps + 1), t(nSteps + 1);

    double x = 0.0;
    double r = 1.0;
    for (int k = 0; k <= nSteps; ++k) {
        t[k] = k * dt;
        double e = r - x;
        u[k] = K * e;
        y[k] = x;
        double xdot = -x + u[k];
        x += dt * xdot;
    }

    double yss = y.back();
    double ess = r - yss;
    double tol = 0.02 * std::fabs(yss);
    double ts = tFinal;
    for (int k = 0; k <= nSteps; ++k) {
        bool ok = true;
        for (int j = k; j <= nSteps; ++j) {
            if (std::fabs(y[j] - yss) > tol) {
                ok = false;
                break;
            }
        }
        if (ok) {
            ts = t[k];
            break;
        }
    }

    double umax = 0.0;
    for (int k = 0; k <= nSteps; ++k) {
        umax = std::max(umax, std::fabs(u[k]));
    }
    return {ess, ts, umax};
}

int main() {
    double gains[] = {1.0, 2.0, 5.0, 10.0};
    for (double K : gains) {
        Metrics m = simulateFirstOrder(K);
        std::cout << "K = " << K
                  << " | ess = " << m.ess
                  << ", ts = " << m.ts
                  << ", umax = " << m.umax
                  << std::endl;
    }
    return 0;
}
      

In a robotics controller, the loop above would typically be executed in real time at a fixed sampling period, with u converted to a motor torque or voltage command subject to saturation limits.

Java is often used in higher-level robotics and automation frameworks. Libraries such as EJML or Apache Commons Math can provide matrix and ODE capabilities; here we implement a minimal scalar simulation.

public class FirstOrderTradeOff {

    public static class Metrics {
        public double ess;
        public double ts;
        public double umax;
    }

    public static Metrics simulate(double K, double tFinal, double dt) {
        int nSteps = (int) (tFinal / dt);
        double[] y = new double[nSteps + 1];
        double[] u = new double[nSteps + 1];
        double[] t = new double[nSteps + 1];

        double x = 0.0;
        double r = 1.0;

        for (int k = 0; k <= nSteps; ++k) {
            t[k] = k * dt;
            double e = r - x;
            u[k] = K * e;
            y[k] = x;
            double xdot = -x + u[k];
            x += dt * xdot;
        }

        double yss = y[nSteps];
        double ess = r - yss;
        double tol = 0.02 * Math.abs(yss);
        double ts = tFinal;
        outer:
        for (int k = 0; k <= nSteps; ++k) {
            boolean ok = true;
            for (int j = k; j <= nSteps; ++j) {
                if (Math.abs(y[j] - yss) > tol) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                ts = t[k];
                break outer;
            }
        }

        double umax = 0.0;
        for (int k = 0; k <= nSteps; ++k) {
            umax = Math.max(umax, Math.abs(u[k]));
        }

        Metrics m = new Metrics();
        m.ess = ess;
        m.ts = ts;
        m.umax = umax;
        return m;
    }

    public static void main(String[] args) {
        double[] gains = {1.0, 2.0, 5.0, 10.0};
        for (double K : gains) {
            Metrics m = simulate(K, 10.0, 1e-3);
            System.out.printf("K = %.1f | ess = %.4f, ts = %.3f, umax = %.3f%n",
                              K, m.ess, m.ts, m.umax);
        }
    }
}
      

The structure mirrors that in Python and C++. In a larger Java-based robotics platform, the signal u would interface with motion controllers and sensor feedback loops.

MATLAB and Simulink are standard tools in control and robotics. The code below uses the Control System Toolbox to analyze the trade-offs for \( G(s) = \frac{1}{s+1} \).

% First-order plant and unity feedback with proportional gain
s = tf('s');
G = 1/(s + 1);

gains = [1 2 5 10];
for K = gains
    C = K;
    T = feedback(C*G, 1);   % closed-loop from r to y
    S = feedback(1, C*G);   % sensitivity (from r to e)

    % Step response metrics
    info = stepinfo(T);
    ess = abs(1 - dcgain(T));         % steady-state error to unit step

    % Control signal for unit step: u = C * e
    [y, t] = step(T);
    e = 1 - y;
    u = K * e;
    umax = max(abs(u));

    fprintf('K = %4.1f | ess = %.4f, ts = %.3f, umax = %.3f\n', ...
            K, ess, info.SettlingTime, umax);
end

% In Simulink, the same loop can be built using:
%  - Sum block for e = r - y
%  - Gain block for C = K
%  - Transfer Fcn block for G(s) = 1/(s+1)
%  - Saturation block to model actuator limits
% and the Scope block to visualize y(t), e(t), and u(t).
      

In a robotics context, the Simulink model can be extended with actuator saturation blocks, friction models, and motor dynamics to study how speed and accuracy requirements interact with realistic actuator limits.

Mathematica offers symbolic and numerical tools for analyzing the same trade-offs. The snippet below illustrates basic computations for the first-order loop.

(* First-order plant and proportional controller *)
ClearAll["Global`*"];
s = LaplaceTransformVariable;
Kval = 5; (* example gain *)

G = TransferFunctionModel[1/(s + 1), s];
C = Kval;

T = SystemsModelFeedbackConnect[C G, 1]; (* closed-loop from r to y *)

(* Step response and steady-state error *)
y[t_] = OutputResponse[T, UnitStep[t], {t, 0, 10}];
yss = Limit[y[t], t -> Infinity];
ess = 1 - yss // Simplify

(* Control signal u(t) = K * (r(t) - y(t)) *)
u[t_] := Kval (1 - y[t]);
umax = N@Maximize[{u[t], t >= 0}, t][[1]];

Print["For K = ", Kval, " we have ess = ", ess, " and umax ≈ ", umax, "."]
      

Symbolic manipulation in Mathematica can be used to derive expressions such as \( J_{u,\mathrm{tr}}(K) \) and to verify analytic results from earlier sections.

Problem 1 (Infeasible Specifications for Proportional Control). Consider the first-order plant \( G(s) = \frac{1}{s+1} \) with unity feedback and proportional control \( C(s) = K \). For a unit step input, suppose the specifications are \( e_{\mathrm{ss}} \le 0.02 \) and actuator limit \( u_{\max,\mathrm{act}} = 5 \), where \( u(t) = K e(t) \).

(a) Derive the inequalities on \( K \) implied by these two constraints.
(b) Show that there is no value of \( K \) satisfying both constraints simultaneously.

Solution.

From Section 3 we have \( e_{\mathrm{ss}} = \frac{1}{1+K} \), so \( \frac{1}{1+K} \le 0.02 \) implies

\[ 1 + K \ge \frac{1}{0.02} = 50 \quad \Rightarrow \quad K \ge 49. \]

For the actuator, \( u_{\max} = K \) at \( t = 0^{+} \). The limit \( u_{\max,\mathrm{act}} = 5 \) therefore implies

\[ K \le 5. \]

Combining, the feasible set would be \( 49 \le K \le 5 \), which is empty. Thus, these specifications cannot be met using only a proportional gain; one must either relax the requirements or change the controller structure or actuator hardware.

Problem 2 (Ramp Accuracy vs Overshoot for a Type-1 Loop). For the plant \( G(s) = \frac{1}{s (s + 1)} \) with proportional control \( C(s) = K \) in unity feedback:

(a) Show that the steady-state error to a unit ramp is \( e_{\mathrm{ss, ramp}} = \frac{1}{K} \).
(b) Using the mapping \( \omega_n = \sqrt{K} \), \( \zeta = \frac{1}{2 \sqrt{K}} \), derive an expression for the overshoot \( M_{\mathrm{p}}(K) \).
(c) Argue that it is impossible to satisfy simultaneously \( e_{\mathrm{ss, ramp}} \le 0.1 \) and \( M_{\mathrm{p}} \le 0.2 \) with this proportional controller.

Solution.

(a) The loop is type 1 with open-loop \( L(s) = \frac{K}{s (s+1)} \). The velocity error constant is

\[ K_{\mathrm{v}} = \lim_{s \to 0} s L(s) = \lim_{s \to 0} \frac{K}{s + 1} = K, \]

and for a unit ramp, \( e_{\mathrm{ss, ramp}} = \frac{1}{K_{\mathrm{v}}} = \frac{1}{K} \).

(b) From Section 4, the characteristic equation is \( s^2 + s + K = 0 \), so \( \omega_n^2 = K \) and \( 2 \zeta \omega_n = 1 \), giving \( \omega_n = \sqrt{K} \) and \( \zeta = \frac{1}{2 \sqrt{K}} \). For a unit step input, the overshoot is

\[ M_{\mathrm{p}}(K) = \exp\!\Bigg( -\frac{\pi \zeta}{\sqrt{1 - \zeta^2}} \Bigg) = \exp\!\Bigg( -\frac{\pi}{\sqrt{4 K - 1}} \Bigg), \quad K > \tfrac{1}{4}. \]

(c) The ramp accuracy requirement \( e_{\mathrm{ss, ramp}} \le 0.1 \) implies \( K \ge 10 \). For \( K \ge 10 \) we have small damping \( \zeta = \frac{1}{2 \sqrt{10}} \) and thus large overshoot \( M_{\mathrm{p}} \) (numerically, more than fifty percent). Conversely, to obtain \( M_{\mathrm{p}} \le 0.2 \), one requires a relatively large damping ratio, which corresponds to small \( K \), implying a large ramp error. Therefore the two inequalities on \( K \) are incompatible, and the specifications cannot be met using only proportional control.

Problem 3 (Monotonicity of Transient Control Energy). For the first-order loop of Section 3, the transient control energy was shown to be \( J_{u,\mathrm{tr}}(K) = \frac{K^4}{2 (1 + K)^3} \). Prove that \( J_{u,\mathrm{tr}}(K) \) is strictly increasing for \( K > 0 \).

Solution.

Differentiating with respect to \( K \),

\[ \frac{\mathrm{d} J_{u,\mathrm{tr}}}{\mathrm{d} K} = \frac{K^3 (K + 4)}{2 (1 + K)^4}. \]

For \( K > 0 \), all factors in the numerator and denominator are positive, so the derivative is strictly positive. Therefore \( J_{u,\mathrm{tr}}(K) \) increases monotonically with \( K \), confirming that higher gains demand more transient control energy.

Problem 4 (Choosing a Gain from Bounds). For the first-order loop with \( G(s) = \frac{1}{s+1} \), suppose the specifications are:

• Step steady-state error \( e_{\mathrm{ss}} \le 0.1 \).
• Settling time \( t_{\mathrm{s}} \le 3 \) seconds.
• Actuator limit \( u_{\max,\mathrm{act}} = 6 \).

(a) Compute the corresponding bounds on \( K \).
(b) Determine the feasible interval for \( K \).
(c) Suggest a specific value of \( K \) and briefly justify your choice.

Solution.

Using the formulas \( e_{\mathrm{ss}} = \frac{1}{1+K} \), \( t_{\mathrm{s}} = \frac{4}{1+K} \), and \( u_{\max} = K \):

\[ \begin{aligned} \frac{1}{1 + K} \le 0.1 &\quad \Rightarrow \quad K \ge 9, \\[4pt] \frac{4}{1 + K} \le 3 &\quad \Rightarrow \quad 1 + K \ge \frac{4}{3} \quad \Rightarrow \quad K \ge \frac{1}{3}, \\[4pt] K \le 6. \end{aligned} \]

The accuracy bound dominates the lower bound, so \( K_{\min} = 9 \), while the effort bound gives \( K_{\max} = 6 \). Hence \( K_{\min} > K_{\max} \), and there is no feasible \( K \). The specifications are inconsistent, and one must relax accuracy or actuator limits, or redesign the controller with additional structure (such as integral action or pre-filtering).

Problem 5 (Effect of Reference Shaping on Effort). For the first-order loop of Section 3 with fixed gain \( K \), compare the actuator effort required for a unit step input \( r(t) = 1 \) and a slower ramp input \( r(t) = \frac{t}{T_{\mathrm{r}}} \) that reaches 1 at \( t = T_{\mathrm{r}} \). Explain qualitatively why shaping the reference input can reduce peak actuator effort without changing the steady-state error.

Solution.

For a step input, the error \( e(t) \) has a large jump at \( t = 0 \), producing \( u(0^{+}) = K \), the maximum possible for that gain. For a ramp input with slope \( 1 / T_{\mathrm{r}} \), the initial error rate is smaller and the resulting control \( u(t) = K e(t) \) grows more gradually, leading to a lower peak \( u_{\max} \). Because the steady-state gain from reference to output is unchanged, the steady-state error is determined by the system type and static error constants, not by the exact transient profile of \( r(t) \). Thus reference shaping can reduce actuator demand while preserving steady-state accuracy, at the cost of slower command trajectories.

In this lesson we quantified how steady-state accuracy, transient speed, and actuator effort interact in simple linear feedback systems. For a first-order plant with proportional control, higher gain simultaneously improves steady-state error and settling time but increases peak control demand and transient control energy. For a type 1 second-order loop, improving ramp accuracy by increasing gain also increases overshoot and actuator burden. By casting constraints on error, speed, and effort as inequalities on the gain, we obtained feasible regions and demonstrated that some specification sets are fundamentally incompatible with simple proportional control. These ideas prepare the ground for the more systematic design techniques of subsequent chapters, such as root locus and frequency-domain loop shaping.