T04: Embedded software, robotics, feedback, and state estimation

A. Prerequisites and observable goals#

Level: Advanced-entry track. Simulated plants only; no real vehicle, robot, aircraft, or medical-device control.

B. The central question: can software act correctly at the required time?#

Embedded software interacts with limited memory, power, sensors, actuators, and timing constraints. A correct value arriving after its deadline may be useless. A hard real-time requirement treats missing a deadline as an unacceptable system failure under its specification; a soft real-time system tolerates some misses with degraded quality. Neither label follows from using C++ or an operating system marketed for real-time work.

Worst-case execution time, interrupt handling, scheduling, blocking, and communication all affect response bounds. An average loop time or a million successful runs does not prove a deadline is always met. Dynamic allocation, locks, page faults, and unbounded input can complicate timing analysis. Prioritize bounded behavior and an explicit fault response before micro-optimizing arithmetic.

A sensor measurement is not the state itself. It may contain noise, bias, delay, quantization, dropped samples, or an incorrect coordinate frame. Units and timestamps belong in the interface contract. A distance in centimeters interpreted as meters can produce a much larger error than an ordinary numerical integration approximation.

C. Coordinates and a small kinematic model#

A planar rotation by angle $\theta$ maps a body-frame vector into a world-frame vector using

For a robot moving forward at speed $v$ with heading $\theta$ and angular speed $\omega$, a basic kinematic model is

This model omits slip, dynamics, actuator limits, and many physical details. For a differential-drive idealization with wheel linear speeds $v_R,v_L$ and track width $b>0$, $v=(v_R+v_L)/2$ and $\omega=(v_R-v_L)/b$. The units check: speed divided by length gives inverse seconds, consistent with angular rate in radians per second.

A transformation’s direction matters. A matrix mapping body coordinates to world coordinates cannot be used unchanged for the reverse map; for a pure rotation, the inverse is its transpose. State-estimation and control failures often originate in such representation errors rather than in sophisticated algorithms.

D. Feedback compares a target with a measurement#

For target $r$, measured output $y_m$, and error $e=r-y_m$, a continuous PID form is

Proportional action responds to current error. Integral action accumulates persistent error. Derivative action responds to change and is sensitive to measurement noise. Gains have units determined by the plant and signal definitions; arbitrary copied gains are not universally meaningful.

Our plant is the nondimensional first-order system $\dot y=-y+u$, with target $1$ and actuator range $[-2,2]$. For constant $u$, its exact solution is $y(t)=u+(y(0)-u)e^{-t}$, giving an analytic check independent of the controller. The simulator uses forward Euler:

With constant $u$, the deviation from equilibrium is multiplied by $1-\Delta t$, so numerical decay is stable only when $|1-\Delta t|<1$, or $0<\Delta t<2$. Closed-loop dynamics introduce additional conditions; a stable open-loop discretization does not automatically make arbitrary PID gains stable.

At each sample, the reference computes error from the latest measurement, forms a raw control using the previously accumulated integral, clamps the control, conditionally updates the integral, and advances the plant. This ordering is part of its discrete controller definition. Other discretizations can be reasonable but are not identical implementations of one universal formula.

E. Saturation, faults, and estimation#

Integral windup occurs when the integral continues growing while the actuator cannot provide the requested effort. After the error changes, the accumulated term may keep the actuator saturated in an unhelpful direction. The lab uses conditional integration: do not accumulate farther into saturation, but allow accumulation that helps leave it. This is one simple anti-windup strategy, not a universal controller design.

A dropped measurement is simulated by holding the last measurement. That makes the controller act on stale information. The policy is visible and testable but is not necessarily safe for a real plant. A real system needs freshness limits, fault detection, and a defined safe state. Noise is simulated by seeded Gaussian samples; real sensors may have non-Gaussian errors, bias, correlated drift, or adversarial interference.

For a scalar prior estimate $\hat x$ with error variance $P$ and independent unbiased measurement $z=x+\nu$ with variance $R>0$, consider

The posterior error variance is $(1-K)^2P+K^2R$ under the independence assumptions. Differentiate with respect to $K$ and set the result to zero:

A noisy measurement gets less weight. A dynamic Kalman filter also predicts state and uncertainty through a model, often adding process noise $Q$ before measurement update. The lab implements only this scalar measurement update; it is not a complete robotics state estimator.

F. Worked simulation and its limits#

With $K_P=2$, $K_I=1$, $K_D=0$, $\Delta t=0.01$, and 1000 steps, the reference run ended at time $10$ with $y\approx0.9939814$ and $u\approx0.9962661$. A second run with noise standard deviation $0.05$, seed $17$, and every seventh measurement dropped ended at $y\approx0.9957102$. The slightly closer final value in the noisy run does not prove noise improves the controller; a single final sample is not a complete performance metric.

Inspect the whole trajectory, maximum error, settling behavior, saturation duration, and response under multiple fault patterns. Compare time-step refinements and analytic cases. A controller can look smooth while using the wrong units or hiding a delayed instability. None of these simulated tests establishes a real actuator’s safe operating envelope, worst-case timing, sensor calibration, or regulatory qualification.

G. Independent practice#

F foundation C standard course work T transfer S optional stretch L runnable lab or project. Attempt the complete set before opening its solutions.

H. Complete solutions: T04#

Compare the first step where your work differs. A corrected answer is not yet an independent success.

Open every solution

"""T04.05: simulated PID on y'=-y+u; no real actuator connections."""
import math
import random

def simulate(kp=2.0, ki=1.0, kd=0.0, dt=0.01, steps=1000,
             noise=0.0, seed=17, drop_every=0):
    if type(steps) is not int or steps < 1 or dt <= 0 or noise < 0:
        raise ValueError("invalid simulation settings")
    if any(not math.isfinite(x) for x in (kp, ki, kd, dt, noise)):
        raise ValueError("finite settings required")
    if type(drop_every) is not int or drop_every < 0:
        raise ValueError("nonnegative fault interval required")
    rng = random.Random(seed)
    y = integral = last_measurement = 0.0
    previous_error = 1.0
    data = []
    for k in range(steps):
        if not drop_every or (k + 1) % drop_every:
            last_measurement = y + rng.gauss(0.0, noise)
        error = 1.0 - last_measurement
        derivative = (error - previous_error) / dt
        raw = kp * error + ki * integral + kd * derivative
        u = max(-2.0, min(2.0, raw))
        # Conditional integration: do not accumulate farther into saturation.
        if abs(raw) <= 2.0 or (raw > 2.0 and error < 0) or (raw < -2.0 and error > 0):
            integral += error * dt
        y += dt * (-y + u)
        if any(not math.isfinite(x) for x in (y, integral, u)):
            raise ArithmeticError("nonfinite simulated state")
        previous_error = error
        data.append(((k + 1) * dt, y, u))
    return data

def scalar_update(mean, variance, measurement, noise_variance):
    if any(not math.isfinite(x) for x in (mean, variance, measurement, noise_variance)):
        raise ValueError("finite measurement and state required")
    if variance < 0 or noise_variance <= 0:
        raise ValueError("valid positive measurement noise required")
    gain = variance / (variance + noise_variance)
    return (mean + gain * (measurement - mean), (1 - gain) * variance)

if __name__ == "__main__":
    print("final (time, state, control):", simulate()[-1])
    print("posterior (mean, variance):", scalar_update(0., 1., 2., 1.))

I. Retention and readiness#

Retrieve coordinate transformations, Euler stability, and conditional probability assumptions. Readiness requires identifying units, timing boundaries, saturation, and stale-state behavior in a new control problem. Continue with signals and systems, differential equations, linear control, embedded hardware interfaces, real-time scheduling, and supervised hardware-in-the-loop validation before controlling physical equipment.