Consider a standard unity-feedback loop with plant \( G(s) \), controller \( C(s) \), reference \( r(t) \), output \( y(t) \), and measurement noise \( n(t) \). In the Laplace domain (assuming zero initial conditions) we write signals \( r(s), y(s), n(s) \).

Two common ways to insert a linear filter \( F(s) \) are:

• Measurement-path filter: the measured output is filtered before feedback subtraction. The controller sees \( e(s) = r(s) - F(s)\big(y(s)+n(s)\big) \).
• Controller-path filter: the error is filtered before entering the controller, or a filtered sub-block of the controller is used. The control signal is \( u(s) = C(s)F(s)\big(r(s)-y(s)-n(s)\big) \).

In both cases the plant dynamics are described by

\[ y(s) = G(s)\,u(s). \]

We assume negative feedback and that measurement noise is additive at the sensor. The following diagram summarizes the two configurations at a conceptual level.

flowchart TD
  R["r(s)"] --> ESUM["error sum"]
  YPLANT["y(s)"] --> MNOISE["add noise n(s)"]
  MNOISE --> FMEAS["measurement filter F(s)"]
  FMEAS --> ESUM
  ESUM --> FCON["controller-path filter F(s)"]
  FCON --> CBLK["controller C(s)"]
  CBLK --> GBLK["plant G(s)"]
  GBLK --> YPLANT
        

In practice, we do not use both filters with the same symbol simultaneously; the diagram only shows both positions to compare their roles.

Before inserting filters, recall the standard unity-feedback loop with measurement noise \( n(s) \):

• Error: \( e(s) = r(s) - y(s) - n(s) \).
• Control: \( u(s) = C(s)e(s) \).
• Plant: \( y(s) = G(s)u(s) \).

Eliminating \( e(s), u(s) \), we obtain

\[ y(s) = G(s)C(s)\,\big(r(s)-y(s)-n(s)\big). \]

Solving for \( y(s) \):

\[ \big(1+G(s)C(s)\big)\,y(s) = G(s)C(s)\,r(s) - G(s)C(s)\,n(s). \]

Define the loop transfer function \( L(s) = G(s)C(s) \). Then

\[ y(s) = \frac{L(s)}{1+L(s)}\,r(s) - \frac{L(s)}{1+L(s)}\,n(s). \]

Using the standard sensitivity and complementary sensitivity functions \( S(s) = \frac{1}{1+L(s)} \) and \( T(s) = \frac{L(s)}{1+L(s)} \), we can write

\[ y(s) = T(s)\,r(s) - T(s)\,n(s). \]

Thus, in a pure unity-feedback loop, measurement noise is shaped by the same complementary sensitivity function that shapes reference tracking. This coupling motivates careful placement of filters.

Now insert a filter \( F_m(s) \) in the measurement path: the controller sees the filtered measurement \( F_m(s)\big(y(s)+n(s)\big) \).

The relations become:

• \( e(s) = r(s) - F_m(s)\big(y(s)+n(s)\big) \),
• \( u(s) = C(s)e(s) = C(s)\big[r(s)-F_m(s)(y(s)+n(s))\big] \),
• \( y(s) = G(s)u(s) \).

Substituting,

\[ y(s) = G(s)C(s)\,\Big(r(s) - F_m(s)\big(y(s)+n(s)\big)\Big). \]

Expand and rearrange terms in \( y(s) \):

\[ y(s) = G(s)C(s)r(s) - G(s)C(s)F_m(s)y(s) - G(s)C(s)F_m(s)n(s), \]

\[ \big(1+G(s)C(s)F_m(s)\big)y(s) = G(s)C(s)r(s) - G(s)C(s)F_m(s)n(s). \]

Define the effective loop including the measurement filter: \( L_m(s) = G(s)C(s)F_m(s) \). Then

\[ y(s) = \frac{G(s)C(s)}{1+L_m(s)}\,r(s) - \frac{G(s)C(s)F_m(s)}{1+L_m(s)}\,n(s). \]

We identify the reference and noise transfer functions:

\[ T_{r,m}(s) = \frac{G(s)C(s)}{1+G(s)C(s)F_m(s)}, \quad T_{n,m}(s) = -\,\frac{G(s)C(s)F_m(s)}{1+G(s)C(s)F_m(s)}. \]

Note that both numerator and denominator of \( T_{n,m}(s) \) contain \( F_m(s) \), whereas \( T_{r,m}(s) \) has \( F_m(s) \) only in the denominator. Consequences:

• For frequencies where \( |F_m(j\omega)| \approx 1 \), the loop behaves similarly to the unfiltered case: tracking and noise rejection are mostly unchanged.
• For high frequencies where \( |F_m(j\omega)| \ll 1 \), the loop gain \( L_m(j\omega) \) is reduced, improving robustness but also limiting high-frequency disturbance rejection.
• Measurement noise is always multiplied by \( F_m(s) \), so a low-pass \( F_m(s) \) attenuates high-frequency noise entering the controller.

Next, insert the same filter \( F_c(s) \) in the controller path. For example, we may filter the error before it enters the controller:

• Error: \( e(s) = r(s) - y(s) - n(s) \).
• Filtered error: \( \tilde{e}(s) = F_c(s)e(s) \).
• Control: \( u(s) = C(s)\tilde{e}(s) = C(s)F_c(s)(r(s)-y(s)-n(s)) \).
• Plant: \( y(s) = G(s)u(s) \).

Substituting,

\[ y(s) = G(s)C(s)F_c(s)\,\big(r(s)-y(s)-n(s)\big). \]

Rearranging,

\[ y(s) = G(s)C(s)F_c(s)r(s) - G(s)C(s)F_c(s)y(s) - G(s)C(s)F_c(s)n(s), \]

\[ \big(1+G(s)C(s)F_c(s)\big)y(s) = G(s)C(s)F_c(s)r(s) - G(s)C(s)F_c(s)n(s). \]

Let \( L_c(s)=G(s)C(s)F_c(s) \). Then

\[ y(s) = \frac{G(s)C(s)F_c(s)}{1+L_c(s)}\,r(s) - \frac{G(s)C(s)F_c(s)}{1+L_c(s)}\,n(s). \]

That is,

\[ T_{r,c}(s) = \frac{G(s)C(s)F_c(s)}{1+G(s)C(s)F_c(s)},\quad T_{n,c}(s) = -\,\frac{G(s)C(s)F_c(s)}{1+G(s)C(s)F_c(s)}. \]

Comparing \( T_{r,c}(s) \) with \( T_{r,m}(s) \) shows that a controller-path filter attenuates high-frequency components of the reference more strongly than a measurement-path filter, because \( F_c(s) \) appears in its numerator.

For measurement noise, both configurations give the same structure for \( T_n(s) \) if we choose \( F_m(s)=F_c(s) \). However, the resulting closed-loop dynamics and the controller input signals differ, which affects implementation constraints (e.g. actuator saturation, internal signal magnitudes).

For low-pass filters of the form

\[ F(s) = \frac{\omega_f}{s+\omega_f}, \]

we can approximate the effect on the loop. Suppose the original controller \( C_0(s) \) was designed to give desired \( S_0(s), T_0(s) \) with loop \( L_0(s)=G(s)C_0(s) \).

• Measurement-path filter: the loop becomes \( L_m(s)=L_0(s)F(s) \). At frequencies where \( |F(j\omega)|\approx 1 \), \( S(s) \) and \( T(s) \) are close to their original shapes; around and above the filter corner \( \omega_f \), loop gain and phase margin change.
• Controller-path filter: we can view the combined controller as \( C(s)=C_0(s)F(s) \), so again the loop is \( L_c(s)=L_0(s)F(s) \). However, the mapping from reference to control input and internal signals is different, and the reference transfer function \( T_{r,c} \) is more strongly shaped by \( F(s) \).

A useful rule-of-thumb is:

• Use measurement-path filtering when the primary goal is to reduce sensor noise entering the controller without heavily shaping the reference trajectory, and choose \( \omega_f \) well above the desired closed-loop bandwidth to avoid excessive phase lag near crossover.
• Use controller-path filtering (e.g. derivative filtering in PID) when high-frequency amplification of noise by the controller itself is problematic; here, filtering naturally limits the controller's gain at high frequencies.

The next diagram summarizes a qualitative design flow.

flowchart TD
  START["Start: given G(s), C(s), noise level"] --> SPEC["Specify bandwidth and noise limits"]
  SPEC --> CHOICE["Is sensor noise dominant at high freq?"]
  CHOICE -->|yes| MEASFILT["Add measurement-path \nlow-pass F(s)"]
  CHOICE -->|no| CTRLNOISE["Is controller high-gain at high freq?"]
  CTRLNOISE -->|yes| CTRLFILT["Add controller-path filter \n(e.g. derivative filter)"]
  CTRLNOISE -->|no| NOFILT["No additional \nfilter needed"]
  MEASFILT --> CHECK["Check margins S(jw), T(jw) and time response"]
  CTRLFILT --> CHECK
  CHECK --> TUNE["Retune filter corner and controller gains if needed"]
        

We illustrate measurement-path vs controller-path filtering for a second-order plant representing, for instance, a robot joint: \( G(s) = \frac{1}{Ms^2+Bs+K} \). We use the python-control library, which is commonly used alongside robotics frameworks (e.g., ROS controllers) for analysis.

import numpy as np
import control as ct
import matplotlib.pyplot as plt

# Plant parameters (e.g. joint dynamics)
M, B, K = 1.0, 2.0, 20.0
G = ct.TransferFunction([1.0], [M, B, K])

# Baseline PD controller
Kp, Kd = 40.0, 8.0
C0 = ct.TransferFunction([Kd, Kp], [1.0, 0.0])  # Kd s + Kp

# First-order low-pass filter F(s) = wf / (s + wf)
wf = 50.0
F = ct.TransferFunction([wf], [1.0, wf])

# Case 1: measurement-path filter F_m(s)
# Loop: Lm(s) = G(s) * C0(s) * F(s) in the feedback branch
# We explicitly build the closed-loop with noise input
Lm = G * C0 * F
Tm_ref_meas = ct.feedback(G * C0, F)   # y/r with F in feedback
Tm_ref_ctrl = ct.feedback(G * C0 * F)  # y/r with F in controller path

# Frequency response comparison
w = np.logspace(-1, 3, 400)
mag_meas, phase_meas, _ = ct.bode(Tm_ref_meas, w, Plot=False)
mag_ctrl, phase_ctrl, _ = ct.bode(Tm_ref_ctrl, w, Plot=False)

plt.figure()
plt.loglog(w, mag_meas, label="y/r with measurement-path F")
plt.loglog(w, mag_ctrl, label="y/r with controller-path F", linestyle="--")
plt.xlabel("Frequency [rad/s]")
plt.ylabel("Magnitude")
plt.legend()
plt.grid(True, which="both")
plt.show()
      

In a robotics context, the same analysis can guide whether to filter the joint encoder signal (measurement-path) or to filter only the derivative term within a PID implemented in a ROS controller node (controller-path).

In C++-based robotic controllers (e.g., using ros_control and Eigen), it is common to implement a first-order discrete low-pass filter on encoder measurements. For sampling time \( T_s \) and continuous-time corner \( \omega_f \), one simple discretization is

\[ y_f[k] = \alpha\,y_f[k-1] + (1-\alpha)\,y[k],\quad \alpha = e^{-\omega_f T_s}, \]

where \( y[k] \) is the raw measurement and \( y_f[k] \) the filtered measurement.

#include <Eigen/Dense>
#include <cmath>

class FirstOrderLPF {
public:
  FirstOrderLPF(double wf, double Ts)
    : alpha_(std::exp(-wf * Ts)), y_f_(0.0) {}

  double update(double y_meas) {
    y_f_ = alpha_ * y_f_ + (1.0 - alpha_) * y_meas;
    return y_f_;
  }

private:
  double alpha_;
  double y_f_;
};

class JointPDController {
public:
  JointPDController(double Kp, double Kd, double wf, double Ts)
    : Kp_(Kp), Kd_(Kd), lpf_(wf, Ts), prev_pos_(0.0) {}

  double compute(double r, double y_meas, double Ts) {
    // Measurement-path filter: filter the measured position
    double y_f = lpf_.update(y_meas);

    // PD on filtered measurement
    double e = r - y_f;
    double vel_est = (y_f - prev_pos_) / Ts;
    prev_pos_ = y_f;

    double u = Kp_ * e - Kd_ * vel_est;
    return u;
  }

private:
  double Kp_, Kd_;
  FirstOrderLPF lpf_;
  double prev_pos_;
};
      

To switch to a controller-path filter, one can instead filter the error signal e or the derivative term vel_est before applying Kd, leaving the raw measurement y_meas unfiltered in the feedback path.

In Java-based robotics (e.g., FRC robots using WPILib), the LinearFilter class can implement moving-average or single-pole low-pass filters. The following code filters wheel encoder measurements (measurement-path filtering) before a PID controller:

import edu.wpi.first.math.controller.PIDController;
import edu.wpi.first.math.filter.LinearFilter;

public class VelocityController {
  private final PIDController pid;
  private final LinearFilter measFilter;

  public VelocityController(double kp, double ki, double kd, double cutoffHz, double dt) {
    pid = new PIDController(kp, ki, kd);
    // Simple single-pole IIR low-pass design expressed as a 1-tap FIR here
    double alpha = Math.exp(-2.0 * Math.PI * cutoffHz * dt);
    // Equivalent first-order IIR: y[k] = alpha * y[k-1] + (1-alpha) * u[k]
    // WPILib LinearFilter.singlePoleIIR(a, dt) can also be used.
    measFilter = LinearFilter.singlePoleIIR(cutoffHz, dt);
  }

  public double calculate(double setpoint, double encoderRate) {
    double filteredRate = measFilter.calculate(encoderRate); // measurement-path
    return pid.calculate(filteredRate, setpoint);
  }
}
      

Alternatively, to realize a controller-path filter, one can filter the PID error setpoint - encoderRate before passing it to the controller, which will modify the effective shape of the reference transfer function more strongly.

MATLAB with Control System Toolbox and Robotics System Toolbox is widely used for control design in robotic manipulators and mobile robots. The script below constructs continuous-time models for both filter placements:

% Plant: G(s) = 1 / (M s^2 + B s + K)
M = 1; B = 2; K = 20;
G = tf(1, [M B K]);

% Baseline PD controller
Kp = 40; Kd = 8;
C0 = tf([Kd Kp], [1 0]);

% First-order low-pass filter F(s) = wf / (s + wf)
wf = 50;
F = tf(wf, [1 wf]);

% Case 1: measurement-path filter
% Closed-loop from r to y with F in feedback path:
T_meas = feedback(G*C0, F);   % y/r

% Case 2: controller-path filter
% Closed-loop from r to y with F cascaded with C0:
T_ctrl = feedback(G*C0*F, 1); % y/r

figure;
bodemag(T_meas, T_ctrl)
legend('Measurement-path filter','Controller-path filter')
grid on

% Simulink note:
% In Simulink, build two subsystems:
% - One where the encoder signal passes through a Transfer Fcn block F(s) before feedback.
% - One where F(s) is in series with the controller block.
% Then compare step responses and noise response using "Band-Limited White Noise" blocks.
      

In a Simulink model of a robot joint, you can connect the encoder output to a Transfer Fcn (measurement filter) or place an identical transfer function before the controller block (controller-path filter) and compare their impact on overshoot, noise amplification, and actuator effort.

Wolfram Mathematica can manipulate transfer functions symbolically using TransferFunctionModel and FeedbackConnect. The following code derives symbolic expressions for \( T_{r,m}(s) \) and \( T_{r,c}(s) \).

(* Define symbols *)
Clear[s, Gs, Cs, Fs];
Gs = 1/(s^2 + 2 s + 20);         (* example plant *)
Cs = 8 s + 40;                   (* PD controller without explicit 1/s term *)
Fs = 50/(s + 50);                (* low-pass filter *)

G = TransferFunctionModel[Gs, s];
C0 = TransferFunctionModel[Cs, s];
F = TransferFunctionModel[Fs, s];

(* Measurement-path filter: feedback(G*C0, F) *)
Tm = FeedbackConnect[SeriesConnect[G, C0], F];

(* Controller-path filter: feedback(G*C0*F, 1) *)
Tc = FeedbackConnect[SeriesConnect[G, C0, F], 1];

FullSimplify[TransferFunctionExpand[Tm]]
FullSimplify[TransferFunctionExpand[Tc]]

(* Bode magnitude comparison *)
BodePlot[{Tm, Tc}, {0.1, 100},
 PlotLegends -> {"T_r, measurement-path", "T_r, controller-path"}]
      

Symbolic expressions help verify algebraic derivations and study asymptotic behavior as filter parameters change, without numerical discretization.

Problem 1 (Derivation of Closed-Loop with Measurement Filter): Consider a unity-feedback loop with plant \( G(s) \) and controller \( C(s) \). A measurement-path filter \( F_m(s) \) is inserted such that \( e(s)=r(s)-F_m(s)\big(y(s)+n(s)\big) \). Derive the closed-loop transfer functions \( T_{r,m}(s)=\frac{y(s)}{r(s)}\Big|\_{n=0} \) and \( T_{n,m}(s)=\frac{y(s)}{n(s)}\Big|\_{r=0} \).

Solution:

From the definitions, \( u(s) = C(s)e(s) = C(s)\big[r(s)-F_m(s)(y(s)+n(s))\big] \) and \( y(s)=G(s)u(s) \). Substituting:

\[ y(s) = G(s)C(s)\Big(r(s)-F_m(s)y(s)-F_m(s)n(s)\Big). \]

Rearranging terms in \( y(s) \):

\[ \big(1+G(s)C(s)F_m(s)\big)\,y(s) = G(s)C(s)r(s) - G(s)C(s)F_m(s)n(s). \]

Thus

\[ T_{r,m}(s) = \frac{G(s)C(s)}{1+G(s)C(s)F_m(s)},\quad T_{n,m}(s) = -\,\frac{G(s)C(s)F_m(s)}{1+G(s)C(s)F_m(s)}. \]

These match the expressions in Section 3.

Problem 2 (Derivation of Closed-Loop with Controller-Path Filter): For the controller-path filter configuration in Section 4, verify the expressions for \( T_{r,c}(s) \) and \( T_{n,c}(s) \).

Solution:

With \( e(s) = r(s)-y(s)-n(s) \), \( u(s)=C(s)F_c(s)e(s) \) and \( y(s)=G(s)u(s) \),

\[ y(s) = G(s)C(s)F_c(s)\big(r(s)-y(s)-n(s)\big). \]

Rearranging:

\[ \big(1+G(s)C(s)F_c(s)\big)\,y(s) = G(s)C(s)F_c(s)r(s) - G(s)C(s)F_c(s)n(s). \]

Therefore,

\[ T_{r,c}(s) = \frac{G(s)C(s)F_c(s)}{1+G(s)C(s)F_c(s)},\quad T_{n,c}(s) = -\,\frac{G(s)C(s)F_c(s)}{1+G(s)C(s)F_c(s)}. \]

Both reference and noise transfer functions contain \( F_c(s) \) in the numerator.

Problem 3 (High-Frequency Asymptotics): Assume \( F(s)=\frac{\omega_f}{s+\omega_f} \) and that \( |G(j\omega)C(j\omega)| \) decays no faster than \( 1/\omega \) as \( \omega \to \infty \). Compare the high-frequency behavior of \( T_{r,m}(j\omega) \) and \( T_{r,c}(j\omega) \) for \( \omega \gg \omega_f \).

Solution:

For \( \omega \gg \omega_f \), \( F(j\omega)\approx \omega_f/(j\omega) \), so \( |F(j\omega)|\approx \omega_f/\omega \ll 1 \).

• Measurement-path: \( T_{r,m}(s)=\frac{G(s)C(s)}{1+G(s)C(s)F(s)} \). For small \( F \), the denominator tends to 1, hence \( T_{r,m}(j\omega)\approx G(j\omega)C(j\omega) \).
• Controller-path: \( T_{r,c}(s)=\frac{G(s)C(s)F(s)}{1+G(s)C(s)F(s)} \). For the same regime, \( G(j\omega)C(j\omega)F(j\omega) \) becomes small, so \( T_{r,c}(j\omega)\approx G(j\omega)C(j\omega)F(j\omega) \), which decays as \( \sim 1/\omega \) times \( G(j\omega)C(j\omega) \).

Thus a controller-path low-pass filter attenuates high-frequency reference content more aggressively than a measurement-path filter with the same corner frequency.

Problem 4 (Filter Design Constraint from Phase Margin): Suppose a controller \( C_0(s) \) has been tuned so that the loop \( L_0(s)=G(s)C_0(s) \) has phase margin \( \phi_m \) at crossover frequency \( \omega_c \). You want to add a measurement-path filter \( F(s) \) such that the additional phase lag at \( \omega_c \) is at most \( \Delta\phi > 0 \). For \( F(s)=\frac{\omega_f}{s+\omega_f} \), derive an inequality relating \( \omega_f \) and \( \Delta\phi \).

Solution:

The phase of \( F(j\omega) \) is \( \angle F(j\omega) = -\arctan\left(\frac{\omega}{\omega_f}\right) \). The additional phase lag at crossover is therefore

\[ \Delta\phi_F(\omega_c) = \arctan\left(\frac{\omega_c}{\omega_f}\right). \]

Requiring \( \Delta\phi_F(\omega_c) \le \Delta\phi \) gives

\[ \arctan\left(\frac{\omega_c}{\omega_f}\right) \le \Delta\phi \quad \Rightarrow \quad \frac{\omega_c}{\omega_f} \le \tan(\Delta\phi). \]

Hence the filter corner must satisfy

\[ \omega_f \ge \frac{\omega_c}{\tan(\Delta\phi)}. \]

This inequality expresses that the filter corner must be sufficiently above crossover to limit phase degradation.

Problem 5 (Qualitative Design Decision): For a robot arm joint, the encoder signal is noisy at high frequencies, and the controller includes a strong derivative term. Explain qualitatively why one might choose a combination of measurement-path filtering and derivative filtering (controller-path) instead of only one of them.

Solution:

Measurement-path low-pass filtering attenuates high-frequency encoder noise before it enters the feedback loop, protecting both proportional and integral terms from noise. However, the derivative action inherently amplifies high-frequency components of its input; even slightly filtered measurements can still contain significant noise in the derivative band.

Adding a derivative filter (controller-path filter) restricts the frequency range where the derivative term has large gain, reducing amplification of the remaining noise and unmodeled high-frequency dynamics. The combination allows:

• Measurement-path filter: moderate noise reduction with limited phase lag.
• Controller-path derivative filter: targeted attenuation of very high-frequency content.

Together, they can yield a more robust design than either alone, provided the resulting loop is checked for adequate stability margins and performance.

In this lesson, we derived how placing a linear filter in the measurement path versus the controller path alters the closed-loop transfer functions for reference and measurement noise. Measurement-path filters primarily reduce sensor noise and modify loop gain through the feedback branch, while controller-path filters directly shape the effective controller and more strongly attenuate high-frequency reference components. We studied these effects via algebraic derivations, asymptotic analysis, and implementation examples in Python, C++, Java, MATLAB/Simulink, and Mathematica, with particular emphasis on robotic control loops. The key design message is to place filters where they address the dominant high-frequency problem (noise vs. aggressive controller gain) while respecting stability margins and desired bandwidth.