State Observer

A ball and beam held by a PD controller, with three estimates of the ball's velocity side by side: the finite difference, the filtered derivative and a Luenberger observer. Choose which one feeds the controller, drag the ▲ under the beam to move the desired position r, and press start the observer in the wrong place to watch it recover.

t = 0.0 s

Controller

velocity fed to the PD

desired position r

θ = −k_p (p − r) − k_d v, |θ| ≤ 9°
k_p = rad/m, k_d = rad·s/m
finite difference, filtered derivative: p = y; observer: p̂, v̂

Sensor

sensor noise σ

Filtered derivative

cut-off ω_c

Observer

l₁ (position gain)

l₂ (velocity gain)

observer open loop (L = 0, a simulator)

Offsets the observer's state by p̂ + 8 cm, v̂ − 0.10 m/s, as in the video's “choosing the gains”.

x̂_k+1 = A_d x̂_k + B_d θ_k + L (y_k − C x̂_k)
p̂_k+1 = p̂_k + Δt v̂_k + l₁ (y_k − p̂_k)
v̂_k+1 = v̂_k + Δt b θ_k + l₂ (y_k − p̂_k)
e_k+1 = (A_d − LC) e_k, A_d − LC = [1 − l₁, Δt; −l₂, 1]
b = 5/7 g = m/s² per rad, Δt = 0.02 s

Velocity v [m/s], last 10 s: true v and finite difference filtered derivative observer v̂

Position p from the sensor [m]: true p, measured y, observer p̂, desired r

Beam angle [deg]: θ, the servo's tilt, and the PD's command (dashed: the ±9° limit)

How good is each estimate? (last 8 s, against the true ball)

estimate	v error, rms [m/s]	lag [ms]	p error, rms [mm]
finite difference
filtered derivative
observer

The lag is the delay (in whole samples) that best lines the estimate up with the true velocity; the finite difference and the filtered derivative use the measurement as their position, so their position error is the sensor's.

How it works

The rig is simulated as in the video. The true ball runs the nonlinear model (g sin θ, the centrifugal term, the servo's lag and rate limit and its linkage) at 1 kHz, and the distance sensor measures p every Δt = 20 ms with noise σ. The three velocity estimates run side by side on the same measurements; the observer uses the linear model, discretized with forward Euler. The gauge at the top of the rig shows the true velocity and the three estimates live; the plots show the last 10 s.

On a touch screen, drag the ▲ sideways to move r; a swipe anywhere else scrolls the page.

Things to try

Feed the PD with the finite difference, then the filtered derivative, then the observer, and watch the beam and the beam jitter under the table: the finite difference makes the beam shake, the filtered derivative still makes it jitter, and with the observer the motion is smooth.
Slide the cut-off ω_c from 5 to 40 rad/s and read the table: a high cut-off follows the true velocity with little lag but lets the noise through; a low one is smooth but lags (about 1/ω_c). Then double σ: the finite difference's error doubles with it (√2 σ/Δt).
Press start the observer in the wrong place with the video's L, then with 3 l₁ and l₁/3, then 3 l₂ and l₂/3. A larger l₁ snaps p̂ onto the noisy measurements; a smaller one makes both estimates oscillate. A larger l₂ overshoots and is noisier; a smaller one is smooth but slow to recover.
Feed the PD with the filtered derivative, tick observer open loop and start it in the wrong place: the simulator's error never dies out, it grows, because the ball and beam is unstable on its own (both eigenvalues of A_d sit on the circle, at 1). Untick it and the feedback pulls the estimate back.
Drag l₂ up past l₁/Δt (or l₁ towards 2.5): when an eigenvalue of A_d − LC leaves the unit circle the estimate blows up, and a PD fed by it loses the ball.