Throughout earlier chapters we have used the standard 1-DOF unity-feedback loop, where a single compensator acts on the error signal \( e(t) = r(t) - y(t) \). In the Laplace domain, with plant transfer function \( G(s) \) and controller \( C(s) \), this structure fixes both:

• the closed-loop response to reference changes \( r(t) \), and
• the closed-loop response to disturbances and measurement noise,

through one transfer function \( C(s) \). As a result, tracking performance, disturbance rejection, noise attenuation and robustness are tightly coupled: improving one often degrades another.

A 2-DOF controller generalizes this by letting the control input depend on two filtered signals:

• a reference path, handled by a transfer function \( C_r(s) \), and
• a feedback path, handled by a (possibly different) transfer function \( C_y(s) \).

The control law has the generic linear time-invariant (LTI) form

\[ U(s) = C_r(s) R(s) - C_y(s) Y(s), \]

which reduces to the classical 1-DOF structure when \( C_r(s) = C_y(s) = C(s) \). In robotics and motion control, 2-DOF structures are particularly attractive because:

• the feedback path \( C_y(s) \) can be tuned for stability, robustness, and disturbance rejection, while
• the reference path \( C_r(s) \) can be tuned for desired transient tracking (e.g., overshoot, rise time) without compromising robustness.

flowchart LR
  subgraph OneDOF["1-DOF feedback"]
    R1["r"] --> E1["sum: e = r - y"]
    E1 --> C1["C(s)"]
    C1 --> G1["G(s)"]
    G1 --> Y1["y"]
    Y1 -->|"feedback"| E1
  end

  subgraph TwoDOF["2-DOF feedback"]
    R2["r"] --> CR["Cr(s)"]
    CR --> SUM2["sum: u = Cr(s) r - Cy(s) y"]
    Y2["y"] -->|"via Cy(s)"| SUM2
    SUM2 --> G2["G(s)"]
    G2 --> Y2
  end
        

In the rest of this lesson we formalize these ideas mathematically and show how 1-DOF and 2-DOF structures differ at the level of closed-loop transfer functions.

Consider a single-input single-output (SISO) plant with transfer function \( G(s) \) and a controller \( C(s) \) in the unity-feedback configuration. We place an additive disturbance \( d(t) \) at the plant output to model unmeasured loads, such as torque disturbances on a robot joint. In the Laplace domain:

\[ G(s) = \frac{Y(s)}{U(s)} . \]

The 1-DOF control law is

\[ U(s) = C(s)\big(R(s) - Y(s)\big). \]

The plant output with an additive disturbance at the output is

\[ Y(s) = G(s) U(s) + D(s). \]

Eliminating \( U(s) \), we obtain:

\[ \begin{aligned} Y(s) &= G(s) C(s)\big(R(s) - Y(s)\big) + D(s) \\ &= G(s) C(s) R(s) - G(s) C(s) Y(s) + D(s). \end{aligned} \]

Collecting terms in \( Y(s) \) gives the closed-loop relation

\[ \big(1 + G(s) C(s)\big) Y(s) = G(s) C(s) R(s) + D(s). \]

Hence the closed-loop transfer functions from reference and disturbance to output are:

\[ \frac{Y(s)}{R(s)} = \frac{G(s) C(s)}{1 + G(s) C(s)}, \qquad \frac{Y(s)}{D(s)} = \frac{1}{1 + G(s) C(s)}. \]

The denominator \( 1 + G(s) C(s) \) is the characteristic polynomial of the closed-loop system and determines:

• stability (pole locations),
• transient speed and damping,
• and, indirectly, sensitivity to disturbances and model errors.

In the 1-DOF structure, both the reference response \( Y(s)/R(s) \) and the disturbance response \( Y(s)/D(s) \) are fixed once we choose \( C(s) \). This is the limitation that 2-DOF structures aim to overcome.

A 2-DOF controller uses two linear elements: one in the reference path and one in the feedback path. Let \( C_r(s) \) and \( C_y(s) \) be proper transfer functions. The control law is

\[ U(s) = C_r(s) R(s) - C_y(s) Y(s). \]

The plant output with an additive disturbance at the output is still

\[ Y(s) = G(s) U(s) + D(s). \]

Substituting the control law,

\[ \begin{aligned} Y(s) &= G(s)\big(C_r(s) R(s) - C_y(s) Y(s)\big) + D(s) \\ &= G(s) C_r(s) R(s) - G(s) C_y(s) Y(s) + D(s). \end{aligned} \]

Collecting terms in \( Y(s) \) yields

\[ \big(1 + G(s) C_y(s)\big) Y(s) = G(s) C_r(s) R(s) + D(s). \]

The closed-loop transfer functions are therefore

\[ \frac{Y(s)}{R(s)} = \frac{G(s) C_r(s)}{1 + G(s) C_y(s)}, \qquad \frac{Y(s)}{D(s)} = \frac{1}{1 + G(s) C_y(s)}. \]

We immediately see two crucial facts:

1. The closed-loop denominator \( 1 + G(s) C_y(s) \) depends only on the feedback transfer function \( C_y(s) \). Thus, stability and disturbance response are governed by \( C_y(s) \).
2. The numerator of \( Y(s)/R(s) \) includes \( C_r(s) \), so we can shape the reference response by choosing \( C_r(s) \) without changing the denominator (and hence without affecting closed-loop poles).

The classical 1-DOF controller is obtained as the special case \( C_r(s) = C_y(s) = C(s) \), in which case the formulas reduce to those in Section 2.

The degree of freedom of a control structure can be interpreted as the number of closed-loop transfer functions that can be adjusted independently. Here we compare the possibilities for 1-DOF and 2-DOF structures.

4.1. 1-DOF: Single Compromise Controller

In the 1-DOF case, once \( C(s) \) has been chosen:

• the reference response is fixed: \( Y(s)/R(s) = G(s) C(s) / (1 + G(s) C(s)) \), and
• the disturbance response is fixed: \( Y(s)/D(s) = 1 / (1 + G(s) C(s)) \).

Any attempt to improve, for example, step response overshoot by changing \( C(s) \) will automatically change disturbance rejection and robustness, because all closed-loop transfer functions share the same denominator and strongly related numerators.

4.2. 2-DOF: Separation of Roles

In contrast, the 2-DOF structure separates responsibilities:

• Feedback path \( C_y(s) \): determines the denominator \( 1 + G(s) C_y(s) \), hence closed-loop poles, stability margins, and disturbance attenuation.
• Reference path \( C_r(s) \): affects only the numerator of \( Y(s)/R(s) \), allowing us to shape transients for set-point changes (e.g., reduce overshoot) while leaving poles unchanged.

A typical servo-design workflow (for example, in robot joint control) is:

1. Design \( C_y(s) \) as a robust stabilizing regulator for disturbance rejection and noise attenuation.
2. With \( C_y(s) \) fixed, choose \( C_r(s) \) (often a prefilter or a weighted version of \( C_y(s) \)) to obtain the desired reference response.

flowchart TD
  A["Plant model G(s)"] --> B["Design Cy(s) for stability and disturbance rejection"]
  B --> C["Check closed-loop poles and margins"]
  C --> D["Design Cr(s) for desired reference response"]
  D --> E["Simulate step and disturbance responses"]
  E --> F["Implement in robot or motion controller"]
        

This separation of tasks is the main conceptual advantage of 2-DOF controllers and motivates the more detailed designs in later lessons (set-point weighting, explicit prefilters, and separation of tracking and disturbance-rejection objectives).

Consider a standard second-order plant representing, for example, a lightly damped robot joint or a servo axis:

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

with natural frequency \( \omega_n > 0 \) and damping ratio \( \zeta \in (0,1) \). For simplicity, take a proportional controller \( C(s) = K_p \).

5.1. 1-DOF Proportional Control

In 1-DOF form,

\[ U(s) = K_p \big(R(s) - Y(s)\big). \]

Using the general formula from Section 2,

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

Substituting \( G(s) \) yields

\[ \frac{Y(s)}{R(s)} = \frac{K_p \omega_n^2}{s^2 + 2 \zeta \omega_n s + \omega_n^2 + K_p \omega_n^2}. \]

The closed-loop poles are the roots of \( s^2 + 2 \zeta \omega_n s + \omega_n^2 + K_p \omega_n^2 = 0 \). Increasing \( K_p \) moves the poles and changes both tracking and disturbance response simultaneously.

5.2. 2-DOF Proportional Control with Reference Prefilter

Now keep the feedback part as \( C_y(s) = K_p \) but introduce a first-order reference prefilter in the reference path:

\[ C_r(s) = K_p F(s), \qquad F(s) = \frac{1}{T_f s + 1}, \quad T_f > 0. \]

The feedback control law is

\[ U(s) = C_r(s) R(s) - C_y(s) Y(s) = K_p F(s) R(s) - K_p Y(s). \]

From Section 3,

\[ \frac{Y(s)}{R(s)} = \frac{G(s) C_r(s)}{1 + G(s) C_y(s)} = \frac{G(s) K_p F(s)}{1 + G(s) K_p}, \qquad \frac{Y(s)}{D(s)} = \frac{1}{1 + G(s) K_p}. \]

Note the denominator is identical to the 1-DOF case, because it depends only on \( C_y(s) = K_p \). Thus:

• the location of closed-loop poles, and therefore disturbance response and robustness, are unchanged,
• while the reference response gets an extra shaping factor \( F(s) \), which can be used to reduce overshoot or smooth commands (important, for example, in robot manipulators to avoid exciting structural modes).

This simple example already illustrates the central idea: in a 2-DOF structure, the reference and feedback roles can be tuned separately.

We now simulate the second-order plant with a 1-DOF proportional controller and a 2-DOF controller with a first-order reference prefilter. We use simple forward Euler integration. In robotics, similar code can be embedded in higher-level frameworks such as python-control for analysis and ROS-based controllers for real-time implementation.

import numpy as np

# Second-order plant parameters (e.g. robot joint)
zeta = 0.3
omega_n = 4.0
k_plant = 1.0  # input gain

def plant_step(x, u):
    """
    x = [position; velocity]
    x_dot = [v; -2 zeta omega_n v - omega_n^2 y + k_plant u]
    """
    y = x[0]
    v = x[1]
    dy = v
    dv = -2.0 * zeta * omega_n * v - (omega_n ** 2) * y + k_plant * u
    return np.array([dy, dv])

# 1-DOF proportional controller
Kp_1dof = 20.0

# 2-DOF controller: same feedback gain, plus first-order prefilter
Ky_2dof = 20.0
Kr_2dof = 20.0
T_f = 0.2  # reference filter time constant

dt = 1e-3
T_end = 2.0
steps = int(T_end / dt)

r = 1.0  # step reference

x_1 = np.zeros(2)  # state for 1-DOF
x_2 = np.zeros(2)  # state for 2-DOF
r_f = 0.0          # filtered reference for 2-DOF

y_hist_1 = np.zeros(steps)
y_hist_2 = np.zeros(steps)

for k_step in range(steps):
    # Current outputs
    y1 = x_1[0]
    y2 = x_2[0]

    # 1-DOF control: u = Kp (r - y)
    u1 = Kp_1dof * (r - y1)

    # 2-DOF control:
    # reference prefilter r_f_dot = (r - r_f) / T_f
    r_f += dt * (r - r_f) / T_f
    # u = Kr r_f - Ky y
    u2 = Kr_2dof * r_f - Ky_2dof * y2

    # Integrate plant dynamics for both loops
    x_1 = x_1 + dt * plant_step(x_1, u1)
    x_2 = x_2 + dt * plant_step(x_2, u2)

    y_hist_1[k_step] = x_1[0]
    y_hist_2[k_step] = x_2[0]

# Compare final values (both should approach 1.0)
print("Final 1-DOF position:", y_hist_1[-1])
print("Final 2-DOF position:", y_hist_2[-1])

# For visualization, plot using matplotlib (not shown here):
# import matplotlib.pyplot as plt
# t = np.arange(steps) * dt
# plt.plot(t, y_hist_1, label="1-DOF")
# plt.plot(t, y_hist_2, label="2-DOF")
# plt.legend(); plt.xlabel("time"); plt.ylabel("y"); plt.show()
      

The 2-DOF response typically has less overshoot to a reference step while preserving similar disturbance rejection properties, since both loops share the same feedback gain Ky_2dof.

In embedded robotic controllers (for instance, in ROS-based joint controllers), control loops are often written in C++ with fixed sampling times. The following code shows a minimal simulation loop for 1-DOF and 2-DOF controllers. In practice you would typically use linear algebra libraries such as Eigen for multi-axis robots and integrate with middleware such as ros_control.

#include <iostream>

int main() {
    const double zeta = 0.3;
    const double omega_n = 4.0;
    const double k_plant = 1.0;

    const double Kp_1dof = 20.0;

    const double Ky_2dof = 20.0;
    const double Kr_2dof = 20.0;
    const double Tf = 0.2;

    const double dt = 1e-3;
    const double T_end = 2.0;
    const int steps = static_cast<int>(T_end / dt);

    // States: [position, velocity]
    double x1_pos = 0.0, x1_vel = 0.0;
    double x2_pos = 0.0, x2_vel = 0.0;
    double r = 1.0;
    double rf = 0.0;

    for (int k_step = 0; k_step != steps; ++k_step) {
        // Outputs
        double y1 = x1_pos;
        double y2 = x2_pos;

        // 1-DOF control
        double u1 = Kp_1dof * (r - y1);

        // 2-DOF reference filter
        rf += dt * (r - rf) / Tf;
        double u2 = Kr_2dof * rf - Ky_2dof * y2;

        // Plant dynamics for 1-DOF
        double dx1_pos = x1_vel;
        double dx1_vel = -2.0 * zeta * omega_n * x1_vel
                         - omega_n * omega_n * x1_pos
                         + k_plant * u1;
        x1_pos += dt * dx1_pos;
        x1_vel += dt * dx1_vel;

        // Plant dynamics for 2-DOF
        double dx2_pos = x2_vel;
        double dx2_vel = -2.0 * zeta * omega_n * x2_vel
                         - omega_n * omega_n * x2_pos
                         + k_plant * u2;
        x2_pos += dt * dx2_pos;
        x2_vel += dt * dx2_vel;
    }

    std::cout << "Final 1-DOF position: " << x1_pos << std::endl;
    std::cout << "Final 2-DOF position: " << x2_pos << std::endl;

    return 0;
}
      

This skeleton can be adapted into a real-time control loop by replacing the integration and print statements with sampling from sensors and sending commands to actuators at a fixed period.

Java is less common for low-level robot control but is useful for educational tools and higher-level simulation environments. Libraries such as EJML or Apache Commons Math can support matrix computations; here we keep the example scalar to focus on the control structure.

public class TwoDofDemo {
    public static void main(String[] args) {
        double zeta = 0.3;
        double omegaN = 4.0;
        double kPlant = 1.0;

        double Kp1 = 20.0;
        double Ky2 = 20.0;
        double Kr2 = 20.0;
        double Tf = 0.2;

        double dt = 1e-3;
        double tEnd = 2.0;
        int steps = (int) (tEnd / dt);

        double x1Pos = 0.0, x1Vel = 0.0;
        double x2Pos = 0.0, x2Vel = 0.0;
        double r = 1.0;
        double rf = 0.0;

        for (int kStep = 0; kStep != steps; ++kStep) {
            double y1 = x1Pos;
            double y2 = x2Pos;

            double u1 = Kp1 * (r - y1);

            rf += dt * (r - rf) / Tf;
            double u2 = Kr2 * rf - Ky2 * y2;

            double dx1Pos = x1Vel;
            double dx1Vel = -2.0 * zeta * omegaN * x1Vel
                          - omegaN * omegaN * x1Pos
                          + kPlant * u1;
            x1Pos += dt * dx1Pos;
            x1Vel += dt * dx1Vel;

            double dx2Pos = x2Vel;
            double dx2Vel = -2.0 * zeta * omegaN * x2Vel
                          - omegaN * omegaN * x2Pos
                          + kPlant * u2;
            x2Pos += dt * dx2Pos;
            x2Vel += dt * dx2Vel;
        }

        System.out.println("Final 1-DOF position = " + x1Pos);
        System.out.println("Final 2-DOF position = " + x2Pos);
    }
}
      

Such a Java simulation can be embedded into graphical tools for teaching control concepts, including the differences between 1-DOF and 2-DOF structures.

MATLAB and Simulink are widely used in control and robotics. The Control System Toolbox and Robotics System Toolbox provide convenient functions for transfer functions, feedback interconnections, and simulation. Below is a time-domain simulation, followed by an indication of how to realize the 2-DOF structure with transfer functions.

% Second-order plant parameters
zeta = 0.3;
omega_n = 4.0;
k_plant = 1.0;

Kp1 = 20.0;
Ky2 = 20.0;
Kr2 = 20.0;
Tf = 0.2;

dt = 1e-3;
T_end = 2.0;
steps = round(T_end / dt);

x1_pos = 0.0; x1_vel = 0.0;
x2_pos = 0.0; x2_vel = 0.0;
r = 1.0;
rf = 0.0;

y1 = zeros(steps,1);
y2 = zeros(steps,1);
t = (0:steps-1)' * dt;

for kStep = 1:steps
    y1(kStep) = x1_pos;
    y2(kStep) = x2_pos;

    u1 = Kp1 * (r - x1_pos);

    rf = rf + dt * (r - rf) / Tf;
    u2 = Kr2 * rf - Ky2 * x2_pos;

    dx1_pos = x1_vel;
    dx1_vel = -2*zeta*omega_n*x1_vel ...
              - omega_n^2 * x1_pos + k_plant * u1;
    x1_pos = x1_pos + dt * dx1_pos;
    x1_vel = x1_vel + dt * dx1_vel;

    dx2_pos = x2_vel;
    dx2_vel = -2*zeta*omega_n*x2_vel ...
              - omega_n^2 * x2_pos + k_plant * u2;
    x2_pos = x2_pos + dt * dx2_pos;
    x2_vel = x2_vel + dt * dx2_vel;
end

plot(t, y1, t, y2);
legend('1-DOF','2-DOF');
xlabel('Time (s)');
ylabel('Position');
title('Step response: 1-DOF vs 2-DOF');

% Transfer function representation (Control System Toolbox)
s = tf('s');
G = omega_n^2 / (s^2 + 2*zeta*omega_n*s + omega_n^2);
Cy = Kp1;
F = 1 / (Tf*s + 1);
Cr = Kp1 * F;

T_1dof = feedback(G*Cy, 1);        % Y/R for 1-DOF
T_2dof = (G*Cr) / (1 + G*Cy);      % Y/R for 2-DOF (explicit formula)
      

In Simulink, the 2-DOF structure appears directly via the PID Controller (2DOF) block, where the proportional and derivative actions may use weighted versions of the reference signal. That block realizes the same structural ideas derived in this lesson.

Mathematica is useful for symbolic manipulation of closed-loop transfer functions and step responses. The code below constructs the 1-DOF and 2-DOF step responses symbolically for the second-order example with proportional control and a first-order reference prefilter.

(* Parameters *)
zeta = 0.3;
omegaN = 4.0;
kPlant = 1.0;

(* Second-order plant G(s) *)
G[s_] := (omegaN^2)/(s^2 + 2 zeta omegaN s + omegaN^2);

(* 1-DOF controller *)
Kp1 = 20.0;
C1[s_] := Kp1;

(* 2-DOF controller: same feedback, filtered reference *)
Ky2 = 20.0;
Kr2 = 20.0;
Tf = 0.2;

Cy[s_] := Ky2;
Cr[s_] := Kr2/(Tf s + 1);

(* Closed-loop transfer functions for step responses *)
T1[s_] := (C1[s] G[s])/(1 + C1[s] G[s]);
T2[s_] := (Cr[s] G[s])/(1 + Cy[s] G[s]);

(* Unit-step Laplace transform is 1/s *)
y1[t_] := InverseLaplaceTransform[T1[s]/s, s, t];
y2[t_] := InverseLaplaceTransform[T2[s]/s, s, t];

Plot[{y1[t], y2[t]}, {t, 0, 5},
  PlotLegends -> {"1-DOF", "2-DOF"},
  AxesLabel -> {"t", "y(t)"},
  PlotLabel -> "Step responses: 1-DOF vs 2-DOF"
]
      

Symbolic tools like this are valuable for verifying algebraic properties, such as the equality of closed-loop denominators between 1-DOF and 2-DOF implementations sharing the same feedback path.

Problem 1 (Closed-loop transfer functions for 1-DOF): Consider a SISO plant with transfer function \( G(s) \) controlled by a 1-DOF controller \( C(s) \) in unity feedback. A disturbance \( D(s) \) is added at the plant output. Derive the closed-loop transfer functions \( Y(s)/R(s) \) and \( Y(s)/D(s) \).

Solution: The relations are

\[ U(s) = C(s)\big(R(s) - Y(s)\big), \qquad Y(s) = G(s) U(s) + D(s). \]

Substituting \( U(s) \) gives

\[ Y(s) = G(s) C(s)\big(R(s) - Y(s)\big) + D(s) = G(s) C(s) R(s) - G(s) C(s) Y(s) + D(s). \]

Collecting the \( Y(s) \) terms,

\[ \big(1 + G(s) C(s)\big) Y(s) = G(s) C(s) R(s) + D(s), \]

hence

\[ \frac{Y(s)}{R(s)} = \frac{G(s) C(s)}{1 + G(s) C(s)}, \qquad \frac{Y(s)}{D(s)} = \frac{1}{1 + G(s) C(s)}. \]

Problem 2 (Closed-loop transfer functions for 2-DOF): Let the 2-DOF controller be given by \( U(s) = C_r(s) R(s) - C_y(s) Y(s) \), with the same plant equation \( Y(s) = G(s) U(s) + D(s) \). Derive \( Y(s)/R(s) \) and \( Y(s)/D(s) \).

Solution: Substitute the control law:

\[ \begin{aligned} Y(s) &= G(s)\big(C_r(s) R(s) - C_y(s) Y(s)\big) + D(s) \\ &= G(s) C_r(s) R(s) - G(s) C_y(s) Y(s) + D(s). \end{aligned} \]

Collecting \( Y(s) \),

\[ \big(1 + G(s) C_y(s)\big) Y(s) = G(s) C_r(s) R(s) + D(s). \]

Thus

\[ \frac{Y(s)}{R(s)} = \frac{G(s) C_r(s)}{1 + G(s) C_y(s)}, \qquad \frac{Y(s)}{D(s)} = \frac{1}{1 + G(s) C_y(s)}. \]

Problem 3 (1-DOF as special case of 2-DOF): Show that the 1-DOF structure is obtained as a special case of the 2-DOF structure. Specifically, identify \( C_r(s) \) and \( C_y(s) \) in terms of \( C(s) \).

Solution: Set

\[ C_r(s) = C(s), \qquad C_y(s) = C(s). \]

Then the 2-DOF control law \( U(s) = C_r(s) R(s) - C_y(s) Y(s) \) becomes \( U(s) = C(s) R(s) - C(s) Y(s) = C(s)\big(R(s) - Y(s)\big) \), which is exactly the 1-DOF control law. The closed-loop transfer functions reduce to those in Problem 1, so the 1-DOF case is embedded in the 2-DOF framework.

Problem 4 (Denominator invariance in 2-DOF): Suppose that a 2-DOF controller uses a fixed feedback transfer function \( C_y(s) \) and an arbitrary stable proper reference transfer function \( C_r(s) \). Show that for a plant \( G(s) \) without hidden modes, the set of closed-loop poles is independent of \( C_r(s) \).

Solution: From Problem 2, the closed-loop relation is

\[ \big(1 + G(s) C_y(s)\big) Y(s) = G(s) C_r(s) R(s) + D(s). \]

The characteristic equation is obtained by setting \( R(s) = 0 \), \( D(s) = 0 \) and requiring nontrivial solutions \( Y(s) \neq 0 \):

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

This equation does not involve \( C_r(s) \). Hence, the closed-loop poles (the roots of the characteristic polynomial) depend only on \( G(s) \) and \( C_y(s) \), not on \( C_r(s) \). Assuming \( G(s) \) has no hidden internal dynamics, these are exactly the closed-loop poles of the overall system.

Problem 5 (Second-order example – effect of prefilter): For the second-order plant of Section 5 with proportional feedback \( C_y(s) = K_p \) and reference prefilter \( F(s) = 1/(T_f s + 1) \), derive the closed-loop transfer function \( Y(s)/R(s) \) and show that varying \( T_f \) does not change the closed-loop poles.

Solution: With \( C_r(s) = K_p F(s) \) and \( C_y(s) = K_p \), the formula in Problem 2 gives

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

Using \( G(s) = \omega_n^2 / (s^2 + 2 \zeta \omega_n s + \omega_n^2) \) and \( F(s) = 1/(T_f s + 1) \), we find

\[ \frac{Y(s)}{R(s)} = \frac{K_p \omega_n^2}{(T_f s + 1)\big(s^2 + 2 \zeta \omega_n s + \omega_n^2\big) + K_p \omega_n^2 (T_f s + 1)}. \]

The factor \( 1 + G(s) K_p \) determines the closed-loop poles, and it does not contain \( T_f \). The additional factor \( F(s) \) appears only as a multiplicative factor in the numerator and as a common factor in both numerator and denominator due to algebraic simplification, without changing the roots of \( 1 + G(s) K_p = 0 \). Therefore the prefilter shapes the numerator and hence the transient tracking shape, but does not move the closed-loop poles.

In this lesson we formalized the notion of one-degree-of-freedom versus two-degree-of-freedom feedback structures. For the classical 1-DOF unity-feedback loop, a single controller \( C(s) \) determines both reference and disturbance responses through the same characteristic polynomial \( 1 + G(s) C(s) \). In contrast, a 2-DOF controller with distinct reference and feedback paths, \( U(s) = C_r(s) R(s) - C_y(s) Y(s) \), leads to closed-loop transfer functions

\[ \frac{Y(s)}{R(s)} = \frac{G(s) C_r(s)}{1 + G(s) C_y(s)}, \qquad \frac{Y(s)}{D(s)} = \frac{1}{1 + G(s) C_y(s)}, \]

in which the closed-loop poles depend only on \( C_y(s) \) while the reference response can be shaped via \( C_r(s) \) without affecting stability. We illustrated these ideas on a second-order plant and showed numerical implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica, with comments on how similar structures appear in robotic motion control. Subsequent lessons in this chapter will specialize these ideas to set-point weighting, reference prefilters, and separation of tracking and disturbance-rejection objectives in practical 2-DOF designs.