Sensors: Physics, Noise Models, and Failure Modes
A sensor datasheet tells you what works — learning to model the noise tells you what breaks.
🎯 By the end you'll understand
How each of FollowBot's four sensor types converts physics to numbers — and exactly where that conversion introduces error. Why Gaussian noise is a useful lie that breaks down at the edges. The characteristic failure mode of each sensor and the recovery strategy it demands. How to select a noise model that actually fits the data, and what happens when you choose wrong.
KEY INSIGHTEvery sensor trades physics for a number — and charges a noise tax
You never measure the world. You measure a physical effect correlated with the world, transduced into an electrical signal, sampled by an ADC, and handed to you as a float. Each step adds error. The noise model is the accounting system for that error.
Most robotics courses teach sensors through their datasheets: range, resolution, update rate. That is necessary but insufficient. What you need as a practitioner is a noise model — a mathematical description of how measurements deviate from truth. The noise model is what the Kalman filter ingests, what the outlier rejection is tuned to, and what reveals the characteristic failure mode of each sensor. Get it wrong and your estimator will be confidently wrong, which is worse than no estimator at all.
Every sensor in robotics has two failure regimes: normal operation (the noise model applies, your filter handles it) and failure mode (the noise model breaks down, the data looks valid but is physically wrong). The failure mode is always tied to the underlying physics of the transduction. Understanding the physics tells you exactly where to look when the datasheet-compliant sensor starts lying.
HOW IT WORKSLIDAR: time-of-flight, beam divergence, and specular reflection
LIDAR (Light Detection And Ranging) emits a pulsed laser and measures how long it takes for the photon to return. At the speed of light, 1 nanosecond of round-trip time equals 15 cm of range, so sub-centimeter range resolution requires sub-67-picosecond timing — which is why LIDAR hardware is dominated by precision timing circuitry, not optics.
inf, indistinguishable from free space. Beam divergence means the footprint grows from ~5 mm at 1 m to ~52 mm at 10 m on an RPLIDAR A2 (0.3° divergence), blurring edges at long range.Range noise model
The standard noise model for a single LIDAR range measurement is Gaussian with zero mean and range-dependent variance:
z = dtrue + ε, ε ~ N(0, σ²(d))
where σ(d) ≈ σ₀ + α·d. The base noise σ₀ reflects timing jitter (~1–2 cm for the RPLIDAR A2); α captures the range-dependent growth due to beam divergence spreading the footprint across multiple depth values. At 8 m this is relevant; at 2 m it is usually negligible for indoor person-following.
Glass doors, shiny floor tiles, and retroreflective vests cause the LIDAR beam to reflect specularly — the angle of incidence equals the angle of reflection, and the return misses the receiver. The measurement is inf (out-of-range). This is structurally valid IEEE 754 data. Downstream nodes that do not gate on isinf() will silently treat the obstacle as free space. A glass wall registers as open corridor. The robot drives into it. No error is logged.
Two additional failure modes worth naming. Mixed pixels occur when the beam footprint straddles an edge (e.g., the corner of a doorframe) — the return time is an average of two surfaces, producing a phantom measurement between them. Absorptive surfaces (matte black, certain fabrics at 905 nm) attenuate the return below the receiver threshold — also inf, same problem as specular but different physics. The recovery strategy is identical: gate on return intensity (if the LIDAR provides it), reject inf and nan, and propagate the uncertainty forward through the filter rather than assuming free space.
HOW IT WORKSCameras: pinhole model, motion blur, and saturation
A camera integrates photons falling on a 2D pixel array over an exposure window. The pinhole camera model describes the projection geometry: a 3D point (X, Y, Z) in camera frame maps to a 2D pixel (u, v) via:
u = f_x · (X/Z) + c_x, v = f_y · (Y/Z) + c_y
where (f_x, f_y) are the focal lengths in pixels and (c_x, c_y) is the principal point. This model will be developed fully in Stage 5; here what matters is that the projection is depth-ambiguous — a pixel at (u, v) could correspond to any point along the ray from the camera center through that pixel. That is why RGB cameras alone cannot measure distance, and why FollowBot uses a depth (RGB-D) camera.
Motion blur
During the exposure window, if either the robot or the target moves, the image is convolved with a motion kernel — the PSF of the motion trajectory across the sensor. A person walking at 1 m/s, imaged at 30 Hz with a 20 ms exposure on a camera with 4 mm/pixel resolution, produces ~8 pixels of blur. YOLO-based person detection degrades non-linearly with blur: bounding boxes expand, confidence drops, and at sufficient blur the detection fails while still appearing to return a valid bounding box at lower confidence. This is a soft failure — no exception, no inf, just wrong geometry.
Pixel saturation
When a pixel integrates more photons than its full-well capacity, it clips to 255 (8-bit) or 4095 (12-bit). Saturation destroys local gradient information — edges in saturated regions become invisible. For person detection in a corridor with a bright window, the person against the window is often silhouetted and detectable; the person walking into the light may disappear into a saturated bloom. Exposure bracketing or HDR modes help; ignoring the risk produces confident but geometrically wrong bounding boxes in high-contrast scenes.
The Intel RealSense D435 uses structured infrared light (not time-of-flight) to generate the depth map. Its depth noise model is approximately σ_z ≈ k·z² where k ≈ 0.002–0.004 depending on surface texture and ambient IR. At 1 m, σ_z ≈ 2–4 mm; at 4 m, σ_z ≈ 32–64 mm — a 16× increase in standard deviation σ_z (and therefore a 256× increase in depth variance σ_z²). Infrared interference from sunlight, other depth cameras, or IR motion sensors causes the depth image to degrade to a noise floor, not to return inf — making it subtly harder to detect than LIDAR saturation.
HOW IT WORKSIMUs: bias, temperature drift, and integration divergence
An Inertial Measurement Unit (IMU) packages a 3-axis accelerometer and a 3-axis gyroscope on a single MEMS die. Neither measures position or angle directly; they measure derivatives — linear acceleration and angular rate. Position and angle are obtained by integration, which is where the trouble starts.
Measurement models
The gyroscope model for a single axis:
ω_meas = ω_true + b_g + η_g, η_g ~ N(0, σ_g²)
where b_g is the gyroscope bias and η_g is the noise floor. The accelerometer model:
a_meas = R·(a_true − g) + b_a + η_a, η_a ~ N(0, σ_a²)
where R is the rotation matrix (orientation must be known to subtract gravity g correctly), b_a is the accelerometer bias, and η_a is the noise floor. Both biases are not constant — they are random walks. Each is usually modelled as:
ḃ = η_b, η_b ~ N(0, σ_b²)
This bias random walk is the dominant long-term error source. A typical MEMS gyroscope (e.g., ICM-42688-P) has an in-run bias stability of ~3–7 deg/hr — which sounds small until you integrate it: at 3 deg/hr, the yaw estimate drifts 0.05° per minute. Over a 5-minute indoor navigation task, that is a 0.25° drift — approximately 8.7 cm positional error at 20 m range. Worse, vibration from the motors excites additional bias that the datasheet does not capture.
Temperature drift
MEMS structures expand with temperature. Bias changes by 1–5 deg/hr per degree Celsius on many affordable IMUs (including the MPU-6050 class, common on small robots). A motor that heats the chassis by 10°C between cold boot and steady state introduces a bias shift not captured in the static calibration. This is the primary reason IMU calibration that worked in the morning fails by afternoon in an outdoor robot — and why high-end IMUs include on-chip thermal compensation.
Integration divergence
Integrating the gyroscope gives angle: θ(t) = θ(0) + ∫ω_meas dt. Any constant bias b_g contributes a linearly growing error: e(t) = b_g · t. Integrating once more (to get position from acceleration) makes errors quadratic in time. This is why IMU-only odometry is never used for more than short intervals: position error from a 0.01 m/s² accelerometer bias grows as ½ · b_a · t² — after 10 seconds, that is 0.5 m of drift. The IMU must be fused with another sensor (wheel encoders, LIDAR odometry) to bound this growth. This is precisely what the EKF in Stage 4 accomplishes.
HOW IT WORKSWheel encoders: ticks to displacement, slip as unmodelled disturbance
A quadrature encoder produces two pulse trains (channels A and B) 90° out of phase. The quadrature arrangement gives 4× count density per physical slot: FollowBot's 1000 PPR encoder with 4× decoding yields 4000 counts per revolution. Each count corresponds to an arc length of:
Δs = (2π · r_wheel) / N_counts_per_rev
For FollowBot with r = 0.0325 m and 4000 counts/rev: Δs = 2π · 0.0325 / 4000 ≈ 0.000051 m per count — about 0.051 mm resolution. The forward kinematic model for a differential-drive robot integrates encoder ticks from both wheels to produce a displacement and heading change (covered fully in Lesson 2.1).
Slip: the unmodelled disturbance
The kinematic model assumes perfect rolling contact: every tick corresponds to exactly Δs of travel. This is true on flat, rigid, high-traction surfaces. It is not true on:
- Smooth floors (polished tile, wet concrete) — wheel slides rather than rolls; ticks accumulate without matching displacement.
- Carpet transitions — the wheel compresses into the carpet, reducing the effective radius by several percent.
- Acceleration or deceleration — inertia briefly overcomes friction, particularly at max torque during startup.
- Turning — a differential-drive robot in a sharp turn loads the inner wheel's lateral friction; if it skids, the heading model breaks.
Slip is an unmodelled disturbance: it introduces odometry error that looks like position drift in the encoder model but is actually measurement error. The encoder says 200 ticks; the actual displacement was 190 ticks worth of motion. The EKF's process noise matrix Q must be tuned large enough to absorb this — if Q is too tight, the filter will trust odometry over LIDAR and the pose estimate will drift in the direction of slip. Detecting slip explicitly (via IMU acceleration discrepancy against encoder-predicted velocity) is a research-grade enhancement; most mobile robots just increase Q and fuse aggressively with LIDAR.
SEE ITSensor noise explorer
This widget makes the noise models tangible. Select a sensor type, tune its noise parameters, and observe clean versus noisy signal traces. Then switch the noise model between Gaussian and Laplacian (heavy-tailed) and watch how the mean and variance estimators degrade when outliers appear. The worst choice you can make is setting a low outlier fraction with a heavy-tailed model — you will see why the estimators disagree exactly when the outliers hit.
Notice what happens when you raise the outlier fraction above 10% with the Laplacian model: the sample variance inflates dramatically, even though the underlying signal is unchanged. A Kalman filter that was tuned assuming Gaussian noise will interpret this variance inflation as "the sensor got noisier" and down-weight all measurements — including the valid ones. That is the practical cost of choosing the wrong noise model: the filter becomes systematically over-cautious about every measurement, not just the outliers.
CORE CONCEPTThe Gaussian noise model: a useful lie
Almost every introductory robotics text models sensor noise as zero-mean Gaussian: z = x + ε, ε ~ N(0, σ²). This model is mathematically convenient — it makes Kalman filters tractable, enables closed-form maximum likelihood estimation, and is justified by the central limit theorem when many independent errors add together. It is also, in practice, a lie. Or more charitably, an approximation that holds in the middle and fails at the tails.
The real distribution of sensor errors is almost universally heavy-tailed. Outliers — from specular LIDAR returns, saturated camera pixels, or IMU vibration spikes — occur far more often than Gaussian tails predict. A 5-sigma event should occur once per 1.7 million observations under Gaussian assumptions. In real sensor streams, such events happen multiple times per minute. This has concrete consequences:
| Noise model | Tails | Kalman filter result | When it breaks |
|---|---|---|---|
| Gaussian N(0, σ²) | Light — outliers suppressed | Optimal for Gaussian noise | Any outlier contaminates estimate; no robustness |
| Laplacian Lap(0, b) | Heavy — exp. decay | Closer to median estimator | Harder to tune; filter is not Gaussian-optimal |
| Student-t (ν DOF) | Heavy — tunable via ν | Robust Kalman variants | Computationally expensive; ν must be estimated |
| Gaussian mixture | Multi-modal | Particle filter or IMM | Requires knowing mixture proportions a priori |
In practice, most production robotics systems use Gaussian noise models with explicit outlier rejection upstream — range gating, M-estimation, or simple threshold tests. The Gaussian model is applied only to the inlier set. This hybrid approach is pragmatic: it keeps the filter tractable while acknowledging that real sensor data has heavy tails. The honest position is: use Gaussian noise inside the filter, and spend engineering effort designing the gating logic that protects it from the tail events the model cannot represent.
The central limit theorem requires that errors be independent and identically distributed. Sensor errors are neither: a specular surface will cause multiple consecutive scans to return inf (correlated across time); a bright window will saturate an entire image region (correlated across pixels). The conditions for CLT-driven Gaussianity are violated systematically. This is not a failure of statistics — it is a reminder that the Gaussian model is a model, not a measurement of nature.
FOLLOWBOTSensor integration: noise budgets for the RPLIDAR A2 and D435
FollowBot's Stage 1 milestone requires sensor topics publishing simulated data in Gazebo with accurate noise models. Setting up Gazebo plugins with physically motivated parameters requires understanding exactly which numbers to use. Here are the sensor-by-sensor noise parameters for FollowBot's configuration, with justification for each.
| Sensor | Topic | Noise model | Parameters | Primary failure mode |
|---|---|---|---|---|
| RPLIDAR A2 | /scan (LaserScan) | Gaussian range | σ = 0.020 m (σ₀); α = 0.001 m/m | Specular/absorptive → inf |
| RealSense D435 (depth) | /camera/depth/image_raw | Gaussian, range-dependent | σ = 0.003 · z² (m), z in metres | IR interference → depth noise floor |
| RealSense D435 (RGB) | /camera/color/image_raw | Additive Gaussian + saturation | σ = 2–4 DN; saturation at 255 | Motion blur, saturation in high-contrast |
| IMU (gyro) | /imu/data (Imu) | Gaussian + bias random walk | σ_g = 0.003 rad/s; σ_b = 0.0001 rad/s² | Temperature drift, vibration bias |
| IMU (accel) | /imu/data (Imu) | Gaussian + bias random walk | σ_a = 0.01 m/s²; σ_b = 0.001 m/s³ | Gravity subtraction error on slopes |
| Wheel encoders | /odom (Odometry) | Gaussian per tick + slip | σ_tick = 0.5 tick; slip modelled as Q inflation | Slip on smooth floors, carpet transitions |
In Gazebo, sensor noise is configured through the URDF plugin XML. Here is the LIDAR noise configuration for the RPLIDAR A2 in Gazebo Harmonic (which supports Humble):
<!-- RPLIDAR A2 plugin with physically motivated noise model --> <gazebo reference="laser"> <sensor name="rplidar" type="gpu_lidar"> <update_rate>10</update_rate> <ray> <scan><horizontal> <samples>360</samples> <resolution>1</resolution> <min_angle>-3.14159</min_angle> <max_angle>3.14159</max_angle> </horizontal></scan> <range> <min>0.15</min> <max>12.0</max> <resolution>0.01</resolution> </range> <noise> <type>gaussian</type> <mean>0.0</mean> <!-- 2 cm base noise — conservative for RPLIDAR A2 spec (1.5 cm) --> <stddev>0.020</stddev> </noise> </ray> <plugin name="scan" filename="libgazebo_ros_ray_sensor.so"> <ros><remapping>~/out:=/scan</remapping></ros> <output_type>sensor_msgs/LaserScan</output_type> </plugin> </sensor> </gazebo>
The critical first piece of FollowBot defensive code: a validity guard that every node consuming /scan must implement before forwarding data to the EKF or person tracker.
import math, rclpy from rclpy.node import Node from sensor_msgs.msg import LaserScan class ScanFilter(Node): """Pass-through that replaces inf/nan with range_max (unknown) and clips to [range_min, range_max]. Protects all downstream nodes from specular and absorptive LIDAR failures.""" def __init__(self): super().__init__('scan_filter') self.create_subscription(LaserScan, '/scan', self.cb, 10) self.pub = self.create_publisher(LaserScan, '/scan_filtered', 10) def cb(self, msg): cleaned = [] for r in msg.ranges: if math.isinf(r) or math.isnan(r): cleaned.append(msg.range_max) # unknown, not free space else: cleaned.append(max(msg.range_min, min(r, msg.range_max))) msg.ranges = tuple(cleaned) self.pub.publish(msg)
FollowBot's full system architecture is now defined: the URDF captures inertial parameters and sensor placements; the TF tree (map → odom → base_link → laser → camera) is complete (Lesson 1.5); Gazebo publishes simulated sensor data with physically motivated noise parameters (this lesson); the first custom ROS 2 node (ScanFilter above) is running and protecting downstream nodes from the LIDAR's primary failure mode. Every noise parameter chosen here becomes a constraint that Stage 4's EKF tuning must honour. Choosing σ_g too small now means mistuning the process noise in Stage 4 — the consequence compounds across stages.
WEAKNESSWhere sensor modelling bites
Datasheets report noise under ideal conditions: controlled temperature, recommended supply voltage, no vibration, specific surface reflectivity. In a differential-drive robot with brushed motors, the EMI from motor switching induces noise in the IMU and camera power rails that is not in any datasheet. The LIDAR noise is measured on a white lambertian target at 90° incidence — not on the off-angle, mixed-reflectivity surfaces of a real corridor. The practical rule: treat datasheet noise figures as lower bounds and measure in situ, or at minimum inflate by 2–4× and monitor filter consistency metrics (normalized estimation error squared, NEES). If NEES is consistently above 1, your noise model is too optimistic.
The single most common sensor interpretation error in student robotics projects: when the LIDAR returns inf, many implementations treat it as "no obstacle in that direction" and mark the cell as free in the costmap. The physically correct interpretation is "I don't know what is there" — the return could be free space at very long range, or a specular surface that deflected the beam, or an absorptive material. The difference between "free" and "unknown" is the difference between driving into a glass wall and stopping before it. Mark inf returns as unknown in your costmap. Always.
Many IMU drivers initialize orientation by assuming the sensor is stationary and using accelerometer readings to determine gravity direction (and hence pitch/roll), then zeroing yaw. This works if the robot boots on a level surface and remains stationary for 1–2 seconds. If the robot is picked up, placed on an inclined surface, or powered on while moving, the initial orientation is wrong — and since the EKF inherits this as its initial heading prior, the error propagates indefinitely unless the filter is re-initialized with a valid measurement from LIDAR odometry or visual landmarks. Always log the startup orientation and sanity-check it against a known reference before beginning a mission.
KEY INSIGHTHow this connects
- What Is a Robot? The Sense-Think-Act Loop (1.1) — the sensor failure modes in this lesson are the mechanistic explanation of the Sense node's characteristic failure class: sensor saturation. That lesson introduced the taxonomy; this one gives it precise physical grounding. Every "silent failure" example in 1.1 now has a named physical cause.
- Coordinate Frames and Homogeneous Transforms (1.2) — the pinhole camera model introduced here (and the depth model for D435) produces measurements in camera frame. Converting them to robot frame, then to map frame, requires the TF2 transforms covered in 1.2. The noise model specifies error in the measurement frame; frame-transform errors add additional, correlated error.
- Actuators and the Real-Time Constraint (1.7) — next up: the other side of the sense-think-act loop. Actuators also have noise models (motor torque noise, PWM quantization); their characteristic failure (saturation + integrator windup) is the Act-node mirror of the Sense-node failures in this lesson.
The noise models in this lesson are not abstract mathematical exercises — they are the literal inputs to the Extended Kalman Filter you will build in Stage 4. The sensor covariance matrices R (measurement noise) and Q (process noise, which absorbs encoder slip and IMU drift) must be populated with numbers, and those numbers come from the physics and empirical calibration introduced here. Getting them right is one of the most practically consequential skills in the entire course.
GLOSSARYKey terms introduced
- Time-of-flight (ToF)
- The measurement principle used by LIDAR: emit a photon pulse and measure the round-trip time Δt; range = c·Δt/2. Sub-nanosecond timing is required for centimeter-level range resolution.
- Beam divergence
- The angular spread of a LIDAR beam, typically 0.1–0.5° for spinning LIDARs. At long range, the beam footprint covers multiple surfaces simultaneously, producing mixed-pixel artifacts.
- Specular reflection
- Mirror-like reflection where the angle of incidence equals the angle of reflection. On smooth surfaces (glass, polished metal), the LIDAR return is redirected away from the sensor, producing
infreadings. - Bias (sensor)
- A systematic, non-zero offset in sensor measurements that is not captured by the zero-mean Gaussian noise model. In IMUs, bias is a random walk — it drifts slowly and must be estimated online by the EKF.
- Integration divergence
- The unbounded growth of position/angle error when integrating IMU measurements over time. Bias contributes linearly (from gyro) or quadratically (from accelerometer) to the integrated estimate; fusion with external sensors is required to bound this.
- Slip (odometry)
- The failure of perfect rolling contact between wheel and floor, causing encoder ticks to overcount or undercount actual displacement. An unmodelled disturbance in the kinematic model; handled by inflating the process noise matrix Q.
- Outlier fraction
- The proportion of measurements that fall outside the nominal noise distribution, typically due to physical failure modes (specular return, motion blur, vibration spike). High outlier fraction causes sample variance to diverge from the model variance, breaking Gaussian-optimal estimators.
- Measurement noise matrix R
- The covariance matrix in a Kalman filter that encodes the expected uncertainty of each sensor measurement. Populated directly from the per-sensor noise models (σ values) derived in this lesson.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1A LIDAR scan of an empty corridor returns inf for a 15° arc pointing at a glass door. What does this mean physically, and what is the correct way to handle it in the costmap?›
The glass door is causing specular reflection: the laser beam hits the glass at an angle such that the reflected beam departs away from the sensor receiver. No photons return, so the time-of-flight measurement exceeds the maximum range threshold and is reported as inf. Physically this means "unknown" — there might be a solid obstacle (the glass) at the measurement bearing, or there might be free space behind it. The correct costmap treatment is to mark those 15° of cells as unknown, not as free space. Marking them free would invite the robot to plan a path through the glass door. The fix is to treat any isinf() or isnan() return as unknown before writing to the costmap, and optionally fuse with the RGB-D camera whose structured infrared light may detect the glass surface at close range.
2FollowBot's IMU gyroscope has a datasheet bias stability of 5 deg/hr. How much heading error does this introduce over a 3-minute indoor navigation run, and why does this matter for person-following at 5 m range?›
In 3 minutes the gyroscope bias contributes: 5 deg/hr × (3/60) hr = 0.25° of heading drift (if the EKF does not observe and correct the bias). At 5 m range, a 0.25° heading error corresponds to a lateral position error of 5 × sin(0.25°) ≈ 5 × 0.0044 m ≈ 22 mm — small for person-following at 5 m. However, in real conditions the in-run bias is worse than the datasheet stability (vibration, thermal effects), and the integration is over the full trajectory rather than a single heading measurement — so cumulative error is larger. More importantly, the bias changes over the run (it is a random walk), so the error grows stochastically rather than linearly at the worst-case rate. The EKF handles this by estimating the bias online (as an augmented state variable) and using wheel encoder and LIDAR odometry to bound the heading error. Without bias estimation, IMU-only heading drift would make the robot unable to reliably locate a person at the 5-minute mark of a mission.
3Explain why increasing the outlier fraction in the noise explorer causes the sample variance to diverge from the model variance, and what this does to a Kalman filter tuned on the Gaussian model.›
Outliers are drawn from a distribution with much larger magnitude than the nominal Gaussian. Even a small fraction of outliers dramatically inflates the sample variance because variance is a squared error — a single measurement that is 10σ away contributes 100× more to the sample variance than a 1σ measurement. As the outlier fraction grows, the sample variance increasingly reflects the outlier distribution rather than the nominal noise floor. A Kalman filter tuned on the Gaussian assumption uses the measurement noise matrix R with the nominal σ². When the actual data has a higher effective variance (due to outliers), the filter treats the discrepancy as evidence that the sensor is noisier than expected and systematically down-weights all measurements from that sensor — including the valid inliers. The result is a filter that is slower to update, less responsive to correct measurements, and therefore slower to converge. The fix is to implement outlier rejection (Mahalanobis distance gating) upstream of the filter, so the filter only ever receives inliers, and the Gaussian model's assumptions are approximately satisfied.
4FollowBot uses both wheel encoders and IMU for odometry. Why is fusing these two sensors better than using either alone, and what does each sensor's failure mode contribute to the fused estimate?›
Wheel encoders measure displacement accurately over short distances but accumulate unbounded error due to slip — particularly on turns, smooth floors, or during acceleration. They have no notion of absolute heading; their heading is integrated from differential displacement, which amplifies errors over time. IMU gyroscopes measure angular rate with low short-term noise but integrate to a heading estimate that drifts due to bias random walk. They are insensitive to slip because they measure inertial rotation, not wheel rotation. Fusing the two: the encoder provides high-frequency, low-noise displacement increments in the absence of slip; the IMU provides independent heading rate that is uncorrelated with wheel slip and corrects systematic encoder heading error. In the EKF, each sensor's measurement noise (R_enc, R_imu) and process noise (Q, which encodes slip as noise) combine to produce a posterior estimate tighter than either alone. The failure modes create complementary weaknesses: encoder slip contaminates the displacement estimate but not the IMU heading; IMU bias contaminates the heading estimate but not the wheel arc length. A correctly tuned EKF will partially compensate for each sensor's failure using the other's uncorrupted measurement.