In previous chapters we have seen how feedback attenuates disturbances based on the observed output. Feedback reacts after the disturbance has affected the output, and its performance is fundamentally limited by loop bandwidth and robustness constraints. If a disturbance is measurable before or as it enters the plant, we can add a feedforward path that proactively cancels its effect using a model of the plant and disturbance path.

Consider a SISO plant with control input \( u(t) \), measurable disturbance \( w(t) \), and output \( y(t) \). In the Laplace domain we model the process as

\[ Y(s) = G(s)U(s) + G_d(s)W(s), \]

where \( G(s) \) is the transfer function from the control input to the output and \( G_d(s) \) is the transfer function from the measurable disturbance to the output. We decompose the control input as

\[ U(s) = U_{\mathrm{fb}}(s) + U_{\mathrm{ff}}(s), \]

with feedback control \( U_{\mathrm{fb}}(s) = C(s)\big(R(s)-Y(s)\big) \) and disturbance feedforward \( U_{\mathrm{ff}}(s) = F(s)W(s) \). Here \( C(s) \) is the feedback compensator and \( F(s) \) is the disturbance feedforward compensator to be designed.

Substituting gives

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

Rearranging,

\[ \big(1 + G(s)C(s)\big)Y(s) = G(s)C(s)R(s) + \big(G(s)F(s) + G_d(s)\big)W(s). \]

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

\[ \boxed{ T_{yr}(s) = \frac{Y(s)}{R(s)}\Bigg|_{W=0} = \frac{G(s)C(s)}{1 + G(s)C(s)}, \quad T_{yw}(s) = \frac{Y(s)}{W(s)}\Bigg|_{R=0} = \frac{G(s)F(s) + G_d(s)}{1 + G(s)C(s)}.} \]

The feedforward affects only the numerator of the disturbance transfer \( T_{yw}(s) \). In particular, the reference transfer \( T_{yr}(s) \) is independent of \( F(s) \), so in principle we can design feedback and disturbance feedforward separately.

flowchart TD
  R["reference r"] --> SUMe["sum r - y"]
  SUMe --> Cblk["feedback controller C(s)"]
  Cblk --> Ufb["u_fb"]
  W["measured disturbance w"] --> Fblk["feedforward F(s)"]
  Fblk --> Uff["u_ff"]
  Ufb --> SUMu["sum u_fb + u_ff"]
  Uff --> SUMu
  SUMu --> PLANT["plant G(s)"]
  W -->|"through Gd(s)"| PLANT
  PLANT --> Y["output y"]
  Y -->|"feedback"| SUMe
  

For disturbance rejection we focus on \( T_{yw}(s) \). From the previous derivation,

\[ T_{yw}(s) = \frac{G(s)F(s) + G_d(s)}{1 + G(s)C(s)}. \]

An ideal disturbance feedforward eliminates the effect of the measurable disturbance on the output, i.e., it enforces \( T_{yw}(s) = 0 \). This requires

\[ G(s)F_{\mathrm{ideal}}(s) + G_d(s) = 0 \quad \Longrightarrow \quad \boxed{F_{\mathrm{ideal}}(s) = -\,G^{-1}(s)\,G_d(s).} \]

With this choice the closed-loop disturbance transfer is identically zero:

\[ T_{yw}(s) = \frac{G(s)F_{\mathrm{ideal}}(s) + G_d(s)}{1 + G(s)C(s)} = \frac{-G(s)G^{-1}(s)G_d(s) + G_d(s)}{1 + G(s)C(s)} = 0. \]

The reference transfer remains \( T_{yr}(s) = G(s)C(s)/(1+G(s)C(s)) \), exactly as in the pure-feedback system. Thus, in the ideal case:

• the feedback loop shapes reference tracking and robustness as before;
• the feedforward loop completely cancels the effect of the measured disturbance;
• feedback and feedforward can be designed separately at the transfer-function level.

In practice, exact model knowledge and exact invertibility of \( G(s) \) and \( G_d(s) \) are rarely available. This leads to realizability and robustness questions that we now analyze.

Assume \( G(s) \) and \( G_d(s) \) are rational, proper, and stable:

\[ G(s) = \frac{B(s)}{A(s)}, \quad G_d(s) = \frac{B_d(s)}{A_d(s)}, \]

with monic denominators and \( \deg A \ge \deg B \), \( \deg A_d \ge \deg B_d \). Then

\[ F_{\mathrm{ideal}}(s) = -\,G^{-1}(s)\,G_d(s) = -\,\frac{A(s)}{B(s)}\cdot\frac{B_d(s)}{A_d(s)} = -\,\frac{A(s)B_d(s)}{B(s)A_d(s)}. \]

Let \( n_A = \deg A \), \( n_B = \deg B \), \( n_{A_d} = \deg A_d \), \( n_{B_d} = \deg B_d \). Then

\[ \deg_{\mathrm{num}}F_{\mathrm{ideal}} = n_A + n_{B_d}, \quad \deg_{\mathrm{den}}F_{\mathrm{ideal}} = n_B + n_{A_d}. \]

For \( F_{\mathrm{ideal}}(s) \) to be proper (physically implementable as a causal LTI system), we need

\[ n_B + n_{A_d} \ge n_A + n_{B_d}. \]

If this inequality fails, the ideal feedforward has higher numerator degree than denominator degree and is non-causal (requires future values of \( w(t) \)). In that case one usually designs a proper approximation \( F_{\mathrm{approx}}(s) \) that matches \( F_{\mathrm{ideal}}(s) \) over the dominant frequency range of the disturbance.

Even when proper, the ideal feedforward may be unstable because the inverse \( G^{-1}(s) \) cancels right-half-plane zeros or unstable poles of \( G(s) \). If \( G(s) \) has a zero with positive real part, the ideal inverse has an unstable pole and cannot be implemented in a stable manner. In such cases we:

• avoid cancelling non-minimum-phase zeros;
• approximate the inverse by a stable, proper filter;
• let feedback handle the residual disturbance that feedforward cannot cancel.

Therefore, practical feedforward design is typically:

1. Compute the ideal \( F_{\mathrm{ideal}}(s) = -G^{-1}(s)G_d(s) \).
2. Check properness and stability of \( F_{\mathrm{ideal}}(s) \).
3. Approximate by a stable, proper transfer function \( F_{\mathrm{approx}}(s) \) that matches \( F_{\mathrm{ideal}}(s) \) where the disturbance has significant energy.
4. Retune the feedback \( C(s) \) if necessary to account for the extra feedforward path.

An important special case in electromechanical and robotic systems is a disturbance that enters at the plant input and is measured directly. For example, a load torque acting on a motor shaft, measured by a torque sensor, acts at the same point as the control torque.

Suppose the plant is modeled as

\[ Y(s) = G(s)\big(U(s) + W(s)\big), \]

and we choose \( U(s) = C(s)\big(R(s)-Y(s)\big) + F(s)W(s) \). For disturbance rejection we set \( R(s) = 0 \) and obtain

\[ \begin{aligned} Y(s) &= G(s)\Big(C(s)(-Y(s)) + F(s)W(s) + W(s)\Big) \\ &= -G(s)C(s)Y(s) + G(s)\big(F(s)+1\big)W(s). \end{aligned} \]

Thus,

\[ \big(1 + G(s)C(s)\big)Y(s) = G(s)\big(F(s)+1\big)W(s), \quad T_{yw}(s) = \frac{G(s)\big(F(s)+1\big)}{1+G(s)C(s)}. \]

Exact disturbance cancellation requires \( F(s) + 1 = 0 \), giving the remarkably simple and robust result

\[ \boxed{F_{\mathrm{ideal}}(s) = -1 \quad \Rightarrow \quad U_{\mathrm{ff}}(s) = -W(s).} \]

In the time domain, we simply subtract the measured disturbance from the control input. Notice that \( F_{\mathrm{ideal}}(s) = -1 \) is a constant gain: it is always proper and stable, and it does not depend on the details of \( G(s) \). This case occurs when the disturbance is physically applied at the same point as the control input (e.g., load torque on a motor shaft or load force on a linear actuator).

The feedback controller \( C(s) \) is still required for robustness against model errors, unmeasured disturbances, and noise; the feedforward merely cancels the part of the disturbance that is measured and aligned with the actuator input.

In a cascade controller, an inner loop regulates a fast variable (e.g. motor current or torque), while an outer loop regulates a slower variable (e.g. speed or position). A measurable disturbance can often be injected naturally into the inner loop as a feedforward term.

Let the inner loop from commanded inner variable \( u_c \) to measured inner variable \( y_{\mathrm{in}} \) have closed-loop transfer function \( G_{\mathrm{in}}(s) \). The outer loop sees an effective plant \( G_{\mathrm{eff}}(s) \) from outer-loop control signal to outer output. If a disturbance \( w(t) \) is measured and its effect on the outer output is modeled by \( G_{d,\mathrm{eff}}(s) \), then the outer-loop disturbance feedforward is, ideally,

\[ F_{\mathrm{outer}}(s) = -\,G_{\mathrm{eff}}^{-1}(s)G_{d,\mathrm{eff}}(s), \]

while the inner loop may already include its own feedforward terms (e.g. current or torque feedforward for known loads). In robotics, such combinations arise in gravity compensation: the disturbance is gravitational torque (known from joint angles), and the inner current/torque loop plus outer position loop can be augmented by a gravity-torque feedforward path.

The key design principle is to:

• design and close the inner loop first (fast dynamics);
• model the effective disturbance path at the level of the outer loop;
• design feedforward at the outer loop using the effective plant model;
• verify that inner-loop saturation and rate limits do not invalidate the feedforward assumptions.

We illustrate disturbance feedforward design in Python using python-control for transfer-function operations. A robotics-oriented workflow could combine this with roboticstoolbox-python for modeling joint dynamics, but here we focus on a SISO example.

Suppose \( G(s) = \dfrac{1}{0.5s + 1} \) and \( G_d(s) = \dfrac{0.2}{0.2s + 1} \), representing a first-order plant and a slightly slower disturbance channel. We choose a PI feedback \( C(s) = k_p + \dfrac{k_i}{s} \) and compute the ideal \( F_{\mathrm{ideal}}(s) = -G^{-1}(s)G_d(s) \), then make it proper by adding a high-frequency roll-off factor.

import numpy as np
import control as ctrl

# Optional robotics toolbox import (for real robot models)
# import roboticstoolbox as rtb

# Laplace variable not needed explicitly in python-control
# Plant and disturbance path
G = ctrl.tf([1.0], [0.5, 1.0])       # G(s) = 1 / (0.5 s + 1)
Gd = ctrl.tf([0.2], [0.2, 1.0])      # G_d(s) = 0.2 / (0.2 s + 1)

# PI feedback controller C(s) = kp + ki/s
kp, ki = 8.0, 4.0
C = ctrl.tf([kp, ki], [1.0, 0.0])

# Ideal disturbance feedforward (may be improper)
F_ideal = -Gd / G
print("F_ideal(s) =", F_ideal)

# Check properness and stabilize with a first-order roll-off if needed
if not ctrl.isproper(F_ideal):
    # Add extra pole for realizability: alpha sets roll-off frequency
    alpha = 20.0
    rolloff = ctrl.tf([1.0], [1.0/alpha, 1.0])  # 1 / (s/alpha + 1)
    F = ctrl.minreal(F_ideal * rolloff, verbose=False)
else:
    F = ctrl.minreal(F_ideal, verbose=False)

print("Implementable F(s) =", F)

# Closed-loop transfer from disturbance to output with feedforward
Tyw = (G*F + Gd) / (1 + G*C)
print("T_yw(s) =", ctrl.minreal(Tyw, verbose=False))

# Simulate step disturbance
T = np.linspace(0, 10, 1000)
t, y = ctrl.step_response(Tyw, T)
# Plotting omitted; in practice, compare with Tyw_no_ff = Gd/(1+G*C)
      

In a robotic application, G and Gd could be obtained by linearizing a joint dynamics model from roboticstoolbox, and the resulting F implemented in a low-level torque or current controller to cancel measured load disturbances.

In C++ robotic control (e.g. ROS with ros_control and control_toolbox), disturbance feedforward appears as an additional term in the control law. For the special case \( F_{\mathrm{ideal}}(s) = -1 \) (input disturbance with direct measurement) the implementation is especially simple:

#include <ros/ros.h>
#include <control_toolbox/pid.h>

class JointController {
public:
  JointController()
  : pid_(/*kp=*/8.0, /*ki=*/4.0, /*kd=*/0.0, /*i_max=*/10.0, /*i_min=*/-10.0)
  {}

  double update(double ref_pos,
                double measured_pos,
                double measured_disturbance,
                double dt)
  {
    // Feedback term on position error
    double error = ref_pos - measured_pos;
    double u_fb = pid_.computeCommand(error, ros::Duration(dt));

    // Disturbance feedforward: F(s) = -1
    double u_ff = -measured_disturbance;

    // Total control input (e.g., desired torque or current)
    double u = u_fb + u_ff;
    return u;
  }

private:
  control_toolbox::Pid pid_;
};
      

More general \( F(s) \) can be implemented as a digital filter using standard discrete-time realizations (e.g. biquad sections). The coefficients are obtained by discretizing the continuous-time feedforward transfer function designed at the transfer-function level.

In Java, robot control is often implemented using WPILib (for example in mobile robots and manipulators). WPILib provides classes for PID control and model-based feedforward. The feedforward term can be interpreted as compensating known disturbances such as gravity or friction, which are functions of measurable joint states.

import edu.wpi.first.math.controller.PIDController;
import edu.wpi.first.math.controller.ArmFeedforward;

public class JointControl {
    private final PIDController pid;
    private final ArmFeedforward ff;

    public JointControl(double kp, double ki, double kd,
                        double ks, double kg, double kv, double ka) {
        pid = new PIDController(kp, ki, kd);
        // ks: static friction, kg: gravity term, kv: velocity, ka: acceleration
        ff  = new ArmFeedforward(ks, kg, kv, ka);
    }

    public double update(double refAngle,
                         double refVelocity,
                         double refAcceleration,
                         double measuredAngle,
                         double dt) {
        // Feedback term on joint angle error
        double u_fb = pid.calculate(measuredAngle, refAngle);

        // Feedforward term based on known disturbance model (e.g., gravity torque)
        double u_ff = ff.calculate(refAngle, refVelocity, refAcceleration);

        // Total applied voltage or torque command
        return u_fb + u_ff;
    }
}
      

When the disturbance model is interpreted as a measurable or computed signal (e.g., gravity disturbance as a function of the measured angle), this pattern realizes a form of disturbance feedforward in combination with feedback.

In MATLAB, disturbance feedforward can be designed using transfer functions from the Control System Toolbox and implemented graphically in Simulink. We again use the example \( G(s) = 1/(0.5s + 1) \), \( G_d(s) = 0.2/(0.2s + 1) \).

% MATLAB script
s = tf('s');

G  = 1 / (0.5*s + 1);      % Plant
Gd = 0.2 / (0.2*s + 1);    % Disturbance path

% PI feedback controller
kp = 8; ki = 4;
C  = kp + ki/s;

% Ideal disturbance feedforward and implementable approximation
F_ideal = -Gd / G;         % May be improper
F_ideal = minreal(F_ideal);

% Add roll-off pole if needed for realizability
if ~isproper(F_ideal)
    alpha = 20;
    rolloff = 1 / (s/alpha + 1);
    F = minreal(F_ideal * rolloff);
else
    F = F_ideal;
end

Tyw = minreal((G*F + Gd) / (1 + G*C)); % Disturbance->output transfer
step(Tyw);
grid on;
title('Step Response from Disturbance w to Output y with Feedforward');
      

In Simulink, we implement \( C(s) \) as a controller block, the plant \( G(s) \) and disturbance path \( G_d(s) \) as Transfer Fcn blocks, and \( F(s) \) as another Transfer Fcn block driven by the disturbance input. A Sum block forms u = u_fb + u_ff, and another Sum block adds the disturbance to the plant input if needed. MATLAB's Robotics System Toolbox can be used to obtain linearized models of robot manipulators for \( G(s) \) and \( G_d(s) \).

For analytic insight, we can use Wolfram Mathematica to derive the disturbance feedforward symbolically. The example below computes \( F_{\mathrm{ideal}}(s) = -G^{-1}(s)G_d(s) \) for general plant and disturbance models.

(* Define symbolic Laplace variable *)
Clear[s];
(* Generic plant and disturbance path *)
G[s_]  := (b0 + b1 s)/(a0 + a1 s + a2 s^2);
Gd[s_] := (d0 + d1 s)/(c0 + c1 s);

(* Ideal feedforward transfer function *)
Fideal[s_] := -Gd[s]/G[s] // Simplify;

(* Display numerator and denominator polynomials *)
numF = Numerator[Together[Fideal[s]]];
denF = Denominator[Together[Fideal[s]]];

{numF, denF}

(* Check relative degree (for realizability) *)
degNum = Exponent[numF, s];
degDen = Exponent[denF, s];
relativeDegree = degDen - degNum

(* For a specific numeric example *)
Gspec[s_]  := 1/(0.5 s + 1);
Gdspec[s_] := 0.2/(0.2 s + 1);

FidealSpec[s_] = -Gdspec[s]/Gspec[s] // Apart // Simplify
      

Mathematica can further be used to perform partial fraction expansions, inverse Laplace transforms, and exact time-domain analysis of the resulting feedforward and closed-loop response.

Problem 1 (Derivation of Closed-Loop Maps with Feedforward). Consider the general structure \( Y(s) = G(s)U(s) + G_d(s)W(s) \) with \( U(s) = C(s)\big(R(s)-Y(s)\big) + F(s)W(s) \). Derive the closed-loop transfer functions \( T_{yr}(s) \) and \( T_{yw}(s) \).

Solution. Substitute the control law:

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

Grouping terms in \( Y(s) \) gives

\[ \big(1 + G(s)C(s)\big)Y(s) = G(s)C(s)R(s) + \big(G(s)F(s) + G_d(s)\big)W(s). \]

Therefore,

\[ T_{yr}(s) = \frac{Y(s)}{R(s)}\Bigg|_{W=0} = \frac{G(s)C(s)}{1 + G(s)C(s)}, \quad T_{yw}(s) = \frac{Y(s)}{W(s)}\Bigg|_{R=0} = \frac{G(s)F(s) + G_d(s)}{1 + G(s)C(s)}. \]

Problem 2 (Ideal Disturbance Feedforward). For the same system, find \( F_{\mathrm{ideal}}(s) \) such that \( T_{yw}(s) = 0 \). Under what conditions is this feedforward implementable as a causal, stable LTI system?

Solution. Setting \( T_{yw}(s) = 0 \) gives \( G(s)F(s) + G_d(s) = 0 \), hence

\[ F_{\mathrm{ideal}}(s) = -\,G^{-1}(s)G_d(s). \]

If \( G(s) = B(s)/A(s) \) and \( G_d(s) = B_d(s)/A_d(s) \), then \( F_{\mathrm{ideal}}(s) = -A(s)B_d(s)/(B(s)A_d(s)) \). This is causal and implementable if:

• The denominator degree is at least the numerator degree: \( n_B + n_{A_d} \ge n_A + n_{B_d} \), ensuring properness.
• All poles of \( F_{\mathrm{ideal}}(s) \) lie in the left half-plane, ensuring internal stability.

If these conditions fail, one must approximate \( F_{\mathrm{ideal}}(s) \) by a stable, proper \( F_{\mathrm{approx}}(s) \).

Problem 3 (Input Disturbance Cancellation). Consider the input-disturbance case \( Y(s) = G(s)\big(U(s) + W(s)\big) \) with control \( U(s) = C(s)\big(R(s)-Y(s)\big) + F(s)W(s) \). Show that choosing \( F(s) = -1 \) cancels the disturbance independently of \( G(s) \).

Solution. As in Section 4, for \( R(s) = 0 \) we obtain

\[ \big(1 + G(s)C(s)\big)Y(s) = G(s)\big(F(s)+1\big)W(s). \]

Setting \( F(s) = -1 \) makes the right-hand side identically zero: \( F(s)+1 = 0 \), so \( \big(1 + G(s)C(s)\big)Y(s) = 0 \). For a stable closed loop (\( 1+G(s)C(s) \neq 0 \) as a transfer function), this implies \( Y(s) = 0 \) for any \( W(s) \), independent of the detailed form of \( G(s) \).

Problem 4 (Numerical Feedforward Design). Let \( G(s) = \dfrac{2}{s + 1} \) and \( G_d(s) = \dfrac{0.5}{0.2s + 1} \). Compute \( F_{\mathrm{ideal}}(s) \) and check whether it is proper.

Solution. We have \( G(s) = 2/(s+1) \) and \( G_d(s) = 0.5/(0.2s+1) \), so

\[ \begin{aligned} F_{\mathrm{ideal}}(s) &= -\,G^{-1}(s)G_d(s) = -\,\frac{s+1}{2}\cdot\frac{0.5}{0.2s+1} \\ &= -\,\frac{0.25(s+1)}{0.2s+1}. \end{aligned} \]

The numerator and denominator are both first-order polynomials, so \( F_{\mathrm{ideal}}(s) \) is proper (relative degree zero) and can be implemented as a causal LTI system (e.g., as a first-order digital filter after discretization).

Problem 5 (Design Procedure for Approximate Feedforward). Outline a systematic design procedure for obtaining an implementable \( F_{\mathrm{approx}}(s) \) when \( F_{\mathrm{ideal}}(s) \) is non-proper or unstable.

Solution. A typical workflow is:

flowchart TD
  A["Identify G(s) and G_d(s)"] --> B["Compute F_ideal(s) = -G^{-1}(s) G_d(s)"]
  B --> C["Check properness and stability of F_ideal(s)"]
  C -->|non-proper or unstable| D["Approximate by F_approx(s): \nadd roll-off, avoid \nnon-minimum-phase cancellation"]
  C -->|proper and stable| E["Use F_ideal(s) directly"]
  D --> F["Implement F_approx(s) as digital filter"]
  E --> F
  F --> G["Validate closed-loop via simulation and experiments"]
        

The approximation step can be implemented by:

• adding stable poles (e.g. low-pass roll-off) to enforce properness;
• removing factors that would cancel non-minimum-phase zeros;
• matching \( F_{\mathrm{ideal}}(j\omega) \) over the frequency band where the disturbance has significant power.

In this lesson we introduced disturbance feedforward for measurable disturbances in SISO systems. Starting from the general model \( Y(s) = G(s)U(s) + G_d(s)W(s) \), we derived the ideal disturbance feedforward \( F_{\mathrm{ideal}}(s) = -G^{-1}(s)G_d(s) \) that cancels the disturbance effect, and showed that reference tracking remains governed by the feedback loop alone. We analyzed realizability conditions (properness and stability) and discussed how non-minimum-phase zeros and model uncertainty motivate approximate feedforward designs. We also placed disturbance feedforward within the multiloop and cascade control context and demonstrated software implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica, including links to robotic control libraries. The next lesson will build on these ideas in industrial multiloop examples.