IMU failure and saturation modes

"The accelerometer reported the crash was exactly sixteen g, because sixteen g was the largest number it owned."

A Clipped AI Agent

This section assumes you know what the three inertial sensors physically measure and their full-scale ranges from Section 23.1, and that calibration in Section 23.4 has already removed nominal bias, scale, and misalignment. Failure and saturation are what remains after calibration: they are not errors you fit away with a constant, they are regimes where the measurement model \(x = h(s) + \eta\) from Chapter 2 breaks entirely, because \(h(\cdot)\) is no longer invertible. Here we answer only how an IMU fails and how you notice. What to do with a flagged gap during fusion belongs to Section 23.7 and to the orientation estimators of Chapter 24.

Saturation: when the sensor runs out of range

A microelectromechanical (MEMS) accelerometer measures proper acceleration by how far a tiny proof mass deflects; a gyroscope measures angular rate through a Coriolis-driven vibration. Both have a configured full-scale range (FSR), for example \(\pm 16\,g\) for a consumer accelerometer or \(\pm 2000\,^\circ/\text{s}\) for its gyroscope. Inside that range the response is close to linear. Push past it and the analog-to-digital converter simply cannot represent a larger number, so the output clips to the rail:

The moment true acceleration \(a\) exceeds \(a_{\max}\), every excess sample reads exactly \(a_{\max}\). This is why saturation is so treacherous: the value is not garbage, it is a plausible maximum, and a threshold-based magnitude feature will read it as a strong, clean event rather than a truncated one. Clipping also destroys information asymmetrically. The peak of an impact is exactly the part you most want to measure, and it is exactly the part that is erased. Two impacts of very different severity, one at \(20\,g\) and one at \(60\,g\), produce identical clipped waveforms once both exceed \(16\,g\), so the true magnitude is unrecoverable from the record alone.

A taxonomy of IMU failure signatures

Clipping is the loudest failure, but a deployed IMU stream carries a whole family of corruptions, each with a recognizable fingerprint in the raw trace. Naming them is the first step to detecting them, because each has a distinct test.

• Saturation / clipping. One or more axes pinned at, or within a hair of, the configured FSR for a run of consecutive samples. Signature: the value equals \(a_{\max}\) repeatedly while a real signal would wander.
• Stuck / frozen samples. A register or bus fault repeats the last valid reading. Signature: exactly zero change across many samples on a sensor that is never truly silent because of its own noise floor.
• Dropouts and gaps. Lost packets over a wireless link (a Bluetooth wrist band) or a starved buffer. Signature: timestamps jump, the effective rate falls, samples are missing rather than wrong. This is where the timing discipline of Chapter 3 earns its keep.
• Spikes and bit flips. A single wildly out-of-family sample from a transmission glitch. Signature: one point far outside the local distribution, gone by the next sample.
• Bias jumps. A mechanical shock or thermal transient shifts the zero-rate offset abruptly. Signature: a step in the running mean of a gyroscope axis with no matching physical motion, the change-point problem of Chapter 12.
• Vibration rectification and aliasing. High-frequency vibration above the Nyquist rate folds down into a false low-frequency bias, and nonlinearities rectify it into a constant offset. Signature: a phantom tilt or drift that appears only under vibration.
• Magnetometer interference. Nearby ferrous metal (hard-iron) or currents (soft-iron) distort the field so heading becomes meaningless. Signature: measured field magnitude departs from the local geomagnetic norm.

Detecting corruption in the stream

Each signature above maps to a cheap, causal test you can run on a sliding window before any feature extraction. The routine below tags four of the most common failures on a triaxial accelerometer window: near-rail saturation, frozen runs, per-sample spikes, and timing gaps. It returns a boolean mask per sample so a downstream model receives a validity channel alongside the data, exactly the missing-data convention that Section 23.7 feeds into an orientation-aware network.

import numpy as np

def flag_imu_faults(acc, t, fsr=16.0, sat_frac=0.99,
                    freeze_run=5, spike_k=8.0, gap_factor=1.5):
    """Return a per-sample fault mask for a triaxial accelerometer window.
    acc: (N, 3) in g; t: (N,) timestamps in seconds. True = suspect sample."""
    N = acc.shape[0]
    mask = np.zeros(N, dtype=bool)

    # 1. Saturation: any axis within sat_frac of the full-scale rail.
    sat = np.any(np.abs(acc) >= sat_frac * fsr, axis=1)

    # 2. Frozen: exact repeats across a run (real MEMS output never sits still).
    same_as_prev = np.all(np.diff(acc, axis=0) == 0.0, axis=1)
    frozen = np.zeros(N, dtype=bool)
    run = 0
    for i in range(1, N):
        run = run + 1 if same_as_prev[i - 1] else 0
        if run >= freeze_run - 1:
            frozen[i - run:i + 1] = True

    # 3. Spikes: robust z-score of the sample-to-sample jump magnitude.
    jump = np.linalg.norm(np.diff(acc, axis=0, prepend=acc[:1]), axis=1)
    med = np.median(jump)
    mad = np.median(np.abs(jump - med)) + 1e-9
    spike = jump > med + spike_k * 1.4826 * mad

    # 4. Timing gaps: an inter-sample interval far above the nominal period.
    dt = np.diff(t, prepend=t[0] - np.median(np.diff(t)))
    gap = dt > gap_factor * np.median(np.diff(t))

    mask = sat | frozen | spike | gap
    return mask, {"saturated": sat.sum(), "frozen": frozen.sum(),
                  "spikes": spike.sum(), "gaps": gap.sum()}

Notice the design choices. The saturation test compares against a fraction of the rail rather than exact equality, because calibration scaling in Section 23.4 nudges the pinned value slightly off the nominal \(a_{\max}\). The spike test uses the median and median absolute deviation, not the mean and standard deviation, so a single \(50\,g\) glitch does not inflate its own threshold. The freeze test insists on exact equality across several samples, which a genuinely noisy MEMS device essentially never produces, so false positives are rare. Every test is causal and cheap, so the whole mask runs in real time on a microcontroller, the deployment target of Chapter 61.

import pandas as pd, numpy as np
df = pd.DataFrame(acc, columns=list("xyz"))
# Frozen runs: rolling range of zero over any axis.
frozen = (df.rolling(5).apply(lambda w: w.max() - w.min()) == 0).any(axis=1)
saturated = (df.abs() >= 0.99 * 16.0).any(axis=1)

Living with failure: what a robust pipeline does next

Detection is only half the job. Once a span is flagged, three responses cover most systems. Mask and impute. Mark the samples invalid and let a gap-aware model or a filter propagate through them on its motion prior rather than trusting the corrupt value; short gaps of a few samples are often safely interpolated, long ones are not. Downweight in fusion. A Bayesian filter (the Kalman family of Chapter 9) can inflate the measurement noise \(R\) for a flagged sample toward infinity, which cleanly tells the estimator to ignore it and coast on prediction, the same missing-modality robustness pattern as Chapter 50. Fail over. When a redundant IMU or a wider-range channel exists, switch to it. Above all, the validity mask must travel downstream: a model that never learns which samples were faked will learn the fakes as if they were motion, and leakage-safe evaluation demands that saturated segments be labeled truthfully in both training and test splits.

What's Next

In Section 23.7, we turn the validity mask built here into a first-class input feature and assemble the full preprocessing pipeline for orientation-aware models: resampling to a common clock, gravity-aware normalization, windowing, and the encoding of gaps and saturation flags so a network learns motion from the trustworthy samples and knows to distrust the rest.