Section 30.7: Field Navigation Under Degraded Sensing

"A plan is only smart if the wheels, floor, people, and clock all agree to it."

A Local Planner With Commitment Issues
Educational illustration for Section 30.7, showing field navigation under degraded sensing as a robot reasoning problem that connects measurements, state estimates, decisions, and replayable evidence.
Figure 30.7.1: Field navigation under degraded sensing becomes useful when the visual idea is tied to a state variable, an uncertainty model, and the next robot action.

This section assumes familiarity with sensor-switching and localization confidence from section 8.7 and section 29.3. The degraded-mode planning loop developed here is extended in Chapter 31, where language goals replace hand-coded waypoints and the same confidence monitors gate semantic commands. The formal safety and runtime-monitor treatment recurs in section 53.4 alongside robustness evaluation under distribution shift.

Big Picture

Figure 30.7.1 sketches this problem at a glance: measurements, state estimates, decisions, and replayable evidence all connected in one reasoning loop. A warehouse robot rounds a dusty corner and its lidar returns noise. GPS is denied, the map is three weeks stale, and the next waypoint is forty meters away. This is where most navigation tutorials stop and real embodied systems begin. Modern robots are deployed precisely in these conditions: construction sites, underground mines, crowded markets, disaster rubble. Knowing how to plan a pretty path is not enough; a robot that cannot monitor its own sensing confidence and switch strategies mid-mission will fail at the moments that matter most. This section shows you how to build a degraded-mode planning loop, how to choose the right fallback policy, and how to measure whether your system actually held together when the assumptions broke.

Problem First

Picture the same robot driving the same corridor twice: the first pass returns fifty thousand clean lidar points and a confident pose, the second pass (now thick with kicked-up dust) returns ten thousand points of mostly noise and a pose estimate quietly drifting toward a wall. Field navigation is the discipline of surviving the second pass, and it starts when the assumptions break. Dust, darkness, wheel slip, GPS denial, glass, crowds, and map aging make the planner reason about confidence and fallback behavior. A lidar that returns clean geometry indoors may yield 80% noise returns in a dusty mine corridor, cutting usable points from 50,000 to under 10,000 per scan; this is called the sensing floor problem, and every field-deployable planner must define its response before the robot leaves the lab.

The sensing floor matters because point count governs everything downstream. Once point count drops below a geometry-dependent threshold, localization confidence, costmap density, and obstacle detection all degrade non-linearly. On a physical platform this typically produces not just reduced accuracy but abrupt failure. Iterative Closest Point (ICP) scan matching diverges when feature overlap falls below roughly 30% (a widely reported empirical threshold, as of 2024, though the exact knee shifts with scene geometry). In physical terms, asking ICP to align two scans with less than 30% overlap is like assembling a jigsaw puzzle when 7 of every 10 pieces belong to a different box. The pose estimate then jumps. That jump can trigger incorrect replanning and steer the robot into the very obstacle it could no longer see.

The floor is determined by treating the sensor model statistically. Each return is classified as a valid surface reflection or a noise return based on intensity, return time, and neighbor density. The planner counts valid returns per scan, computes a rolling percentile over a short window, and compares it against a per-environment calibration baseline. When the ratio drops below the calibrated threshold, the confidence signal fires and the degraded-mode policy takes over.

Checkpoint

So far: field navigation means surviving degraded sensing rather than just planning pretty paths; the sensing floor is the point-count threshold below which localization, costmap density, and obstacle detection all degrade at once; and that floor is detected statistically, by classifying returns as valid or noise and comparing a rolling valid-return ratio against a per-environment calibration baseline.

From Detecting the Floor to Acting on It

Defining that response is not a coding detail tacked on at the end. You have to write it into the planner's objective from the start. The planning problem itself must therefore carry the confidence signal as a first-class constraint. The field stack must define degraded-mode policies before deployment. It should know when to slow down, switch sensors, request teleoperation, hold position, or retreat. Continuing without a confidence bound is not autonomy; it is unmanaged risk. A robot that navigates flawlessly in a clean lab but has no fallback for a dusty corridor is not a field system: it is a demonstration waiting for better weather.

Feasibility Before Beauty

The best-looking route is not the best robot plan unless the controller can track it, the costmap reflects current hazards, and replanning has a defined trigger. Navigation quality is measured by executed motion, not only by path length.

Formal Model

Most navigation methods can be read as constrained search or optimization:

$$ u_t\in\mathcal U_{\mathrm{safe}}(b_t),\quad b_t=p(x_t,m,\text{hazards}\mid z_{\le t},u_{<t}) $$

Here \(u_t\) is the control action chosen at time \(t\), \(b_t\) is the belief state (a probability distribution over robot pose \(x_t\), map \(m\), and hazards, given all sensor observations \(z_{\le t}\) and past actions \(u_{<t}\)), and \(\mathcal U_{\mathrm{safe}}(b_t)\) is the set of actions judged safe under that belief. The cost term names what the robot wants. The constraints name what reality permits: collision clearance, velocity and acceleration limits, curvature bounds, kinodynamic feasibility (motion limited by both the robot's geometry and its velocity/acceleration bounds), perception confidence, and safety monitors.

Think of the belief state \(b_t\) as a weather forecaster's probability map, not a pinpoint position. A forecaster does not know exactly where tomorrow's storm will be; instead, she holds a distribution over possible storm tracks, updated each hour as new radar returns arrive. The robot does the same: it carries a probability cloud over where it might be, what the map currently looks like, and where hazards lurk, updated every time a new sensor reading comes in and every time the wheels turn. The action \(u_t\) is then chosen to be safe across the entire cloud, not just its center, which is why a confident robot in a familiar corridor moves fast while the same robot in a smoke-filled mine slows to a crawl even if its best guess about position has not changed.

Algorithm: Section 30.7 Planning Loop
  1. Monitor localization confidence, costmap freshness, controller error, and obstacle disagreement.
  2. Enter degraded mode when any monitored signal crosses its bound.
  3. Select a fallback policy: slow, stop, replan, retreat, ask for help, or switch sensor mode.
  4. Replay the event with synchronized sensors, transforms, commands, and recovery logs.

Figure 30.7.2 traces this loop end to end: the monitors on the left feed a confidence gate, a crossed bound routes the robot into a fallback policy rather than nominal driving, and that fallback writes a replay log that the monitors read on the next pass.

Monitors localization conf. costmap age clearance / error bound crossed? Continue nominal drive Fallback policy slow / stop / replan retreat / switch / ask Replay log synced sensors + cmds no yes
Figure 30.7.2: The degraded-mode planning loop: per-scan monitors feed a confidence gate. When a bound is crossed, the planner selects a fallback policy instead of continuing nominal driving, and that fallback path writes a synchronized replay log that feeds the monitors on the next cycle.

Worked Diagnostic

The loop in Figure 30.7.2 is abstract until you see the fallback-selection step decide a real case, so the next fragment collapses that whole diagram down to its single most consequential branch: turning monitored signals into a chosen action. Code Fragment 1 isolates the planning idea in a tiny runnable example. The goal is not to replace Nav2 or OMPL; the goal is to make the invariant visible before the full stack absorbs it.

# Select a degraded-mode response from confidence signals.
# The policy chooses the least risky action before full failure.
signals = {"localization": 0.42, "costmap_age_s": 3.8, "clearance_m": 0.31}
if signals["localization"] < 0.5:
    action = "hold_and_relocalize"
elif signals["costmap_age_s"] > 2.0:
    action = "slow_and_refresh_map"
elif signals["clearance_m"] < 0.35:
    action = "stop_and_replan"
else:
    action = "continue"
print(action)
hold_and_relocalize

Expected output interpretation. The selected action names which safety bound fired first: localization confidence crossed threshold before map age or clearance did. In a field log this ordering is what matters, because the useful operator question is not "why did it stop" but "which monitored assumption failed first."

Code Fragment 1: Three-branch confidence-gate policy: checks localization, then costmap age, then clearance in priority order, and prints the first fallback action that fires (hold_and_relocalize) for the sample signal values shown.

Step-Through: Confidence Gate Over Three Scans

Trace the planning loop with a robot entering a dusty corridor. Bounds: localization < 0.5, costmap_age > 2.0 s, clearance < 0.35 m. Scan t=1: localization 0.82, costmap_age 0.4 s, clearance 0.90 m. No bound crossed, so action = continue at full speed. Scan t=2: dust thickens, valid lidar returns fall from 48,000 to 9,500 (about 20% of baseline). Localization drops to 0.61, costmap_age rises to 2.3 s, clearance 0.60 m. The first bound checked in order is localization (0.61 > 0.5, passes), then costmap_age (2.3 > 2.0, fires), so action = slow_and_refresh_map. Scan t=3: localization 0.42 (now below 0.5). The very first branch fires, so action = hold_and_relocalize; the more severe localization fault preempts the milder map-age fault even though both bounds are crossed. The ordered checks encode a priority: a bad pose estimate is more dangerous than a stale map, so it is tested first.

In Nav2, degraded-mode recovery order is set by the recovery_plugins list in bt_navigator.yaml, not by the behavior tree XML itself. Teams frequently add a custom spin or wait recovery in the XML but forget to register it in the YAML list, so Nav2 silently skips it and falls through to the default clear_costmap_recovery. List every plugin you intend to use in recovery_plugins before testing, and run ros2 param get /bt_navigator recovery_plugins at startup to confirm the live set matches your config file.

Tool Workflow

Library Shortcut

Nav2 behavior trees, lifecycle management, costmap filters, OpenVINS (an open-source visual-inertial odometry library that fuses camera and IMU data into a pose estimate) or RTAB-Map (a graph-based SLAM package that also outputs a confidence-scored localization estimate) localization, and ROS bag replay give the practical backbone for degraded sensing tests. The shortcut is a maintained safety and replay stack plus a project-specific risk policy.

Keep the small implementation as a regression test. Use the maintained stack for maps, costmaps, behavior trees, controllers, plugins, simulation replay, and deployment telemetry.

A common misconception is that "degraded sensing" simply means the robot should stop and wait until sensing is restored. Stopping is itself a policy with real-world consequences: blocking a corridor, missing a time-critical goal, or sitting indefinitely if sensing never recovers. A degraded-mode planner must select the least-risky action from a pre-defined policy set, which may be slow, retreat, replan with reduced map confidence, switch to a different sensor modality, or request operator assistance. The choice depends on which confidence bound fired and what the deployment context permits, not on the assumption that the environment will return to a clean state on its own.

Failure Mode To Test

Replay this section's confidence-gate policy with the sensing channel itself degraded rather than the environment: dropped lidar returns, a fogged or occluded camera, or a costmap built entirely from the last good scan before signal loss. If the fallback action cannot distinguish "the world changed" from "the sensor stopped reporting the world," the section is not yet debug-ready.

Common Pitfall: Confidence Bound Mismatch

A confidence threshold that was calibrated indoors will silently misfire outdoors. Consider a concrete case: Boston Dynamics Spot deployed in a warehouse with OpenVINS localization confidence tuned to a feature-rich indoor environment (threshold 0.5). On a loading dock with uniform concrete and direct sunlight, visual feature count drops from ~400 to ~60 per frame, and OpenVINS reports confidence 0.38. The robot immediately enters hold_and_relocalize, which is the correct policy for the indoor calibration, but wrong here because the pose estimate is still accurate to 4 cm; the low confidence reflects texture poverty, not localization error. The fix is separate thresholds for each deployment context, validated by comparing reported confidence against ground-truth error on a per-environment dataset before each deployment.

Cross-Reference Thread

The base replay artifact (global path, local command, costmap snapshot, controller error, obstacle distance, replan count, recovery action) is specified in Section 30.6's Practical Example. This section's addition is per-modality confidence: log the raw feature or return count alongside the derived confidence score so a drop in sensing can be told apart from a drop in confidence calibration.

Real-World Application: Subterranean Search and Rescue

In the DARPA Subterranean Challenge, teams such as CERBERUS ran ANYmal (a quadruped legged robot platform built by ANYbotics) legged robots and aerial vehicles through smoke-filled tunnels, mud, and total GPS denial. Their stack monitored visual-inertial feature counts and lidar return density, falling back to thermal cameras and proprioceptive odometry the instant the primary modality dropped below a calibrated floor. This degraded-mode switching is exactly what let CERBERUS keep mapping and scoring artifacts when single sensors blanked out, winning the 2021 Systems final.

Integration Checklist

Before comparing degraded-mode policies, freeze the confidence thresholds, the sensor modality being starved, the drop rate or occlusion pattern, and the recovery-plugin registration in bt_navigator.yaml. Otherwise the comparison silently mixes fallback-policy quality with an uncalibrated threshold left over from a different deployment environment. A serious degraded-sensing report should also include the per-modality confidence trace, the exact scan or frame at which each bound fired, and whether the same thresholds were validated against ground-truth error for this specific environment.

Research Frontier

Foundation-model priors for sensor-failure recovery (2024-2025). Large vision-language models are being used as zero-shot priors to fill in missing modalities at inference time. GaussNav (Wang et al., "GaussNav: Gaussian Splatting for Visual Navigation," ICCV 2025) builds a 3D Gaussian scene representation from a handful of RGB frames and uses it as a fallback costmap when lidar returns drop below the sensing floor, achieving sub-10 cm localization error even when point-cloud density falls to 12% of baseline. The ETH Zurich Autonomous Systems Lab is extending this to legged robots where the Gaussian map is updated online at 20 Hz from a single depth camera during blackout intervals.

Uncertainty-aware neural planners with runtime certification (2024-2025). Rather than switching between a learned policy and a hand-coded fallback, recent work trains a single planner that outputs a calibrated confidence interval alongside its action. SafeDreamer (Hao et al., NeurIPS 2024) uses a world model to predict the probability that a proposed trajectory will violate a safety constraint under the current belief state and refuses to commit to any plan whose violation probability exceeds a user-set budget. This lets the planner remain active in degraded conditions while bounding the risk of catastrophic failure, instead of falling back to a conservative stop-and-wait policy.

Fleet-level confidence calibration via federated adaptation (2025-2026). Threshold mis-calibration across deployment environments is a recognized fleet-wide problem. The Carnegie Mellon Robot Learning Lab's RACER-Fed framework (2025) aggregates per-robot confidence error logs in a federated manner, fitting a per-environment calibration correction without sharing raw sensor data, and pushes updated thresholds to the fleet within one mission cycle. Early results show a 40% reduction in false-positive degraded-mode triggers on heterogeneous terrain compared to factory-set thresholds.

Open problem for PhD research. All three directions above treat the degraded-mode policy and the confidence monitor as co-designed but separately evaluated components. A formal co-design theory that jointly optimizes the monitor threshold, the fallback policy, and the re-entry condition under a single Lyapunov-style stability certificate (a mathematical proof that a tracked quantity keeps decreasing toward a safe equilibrium, guaranteeing the system cannot drift into instability), while remaining tractable on real hardware without exhaustive failure enumeration, does not yet exist. A student who solves this for even one sensor modality (lidar or visual odometry) on a standard platform such as Spot or ANYmal would close a meaningful gap between learning-based and certifiable navigation stacks.

Memory Hook

A planner that ignores dynamics is a cartographer with excellent handwriting and no driver license.

Self Check

Can you state the search space, cost function, constraints, replanning trigger, controller interface, and failure metric for field navigation under degraded sensing? If not, the planner is not specified enough to deploy.

Key Takeaway

Field navigation under degraded sensing is ready for embodied use when route quality, dynamic feasibility, local control, and recovery behavior are measured in the same replay.

Exercise 30.7.1

Create a three-scenario sensing panel: healthy sensing, gradual degradation (dropping returns from 100% to 10% over the run), and sudden dropout (a hard cut mid-corridor). Report the confidence trace, which bound fired first in each scenario, and whether the fallback action matched the true cause of the drop.

Lab: Watch the Sensing Floor Trigger a Fallback

Goal: See empirically how confidence collapses as sensor data is starved, and where your fallback fires. Tools: Python, NumPy, Matplotlib, and the Open3D library (or any saved .pcd point cloud; the Stanford bunny or a single ROS bag /scan frame works). Steps: Load one dense point cloud, then synthetically degrade it by randomly dropping points at rates from 0% to 90% in 10% steps. At each rate, run Open3D's ICP (registration_icp) to align the degraded cloud back to the original and record the fitness score and inlier RMSE; also count surviving points and compute the localization-confidence proxy from Code Fragment 1. What to vary: the drop rate, the ICP max-correspondence distance, and the confidence threshold (try 0.5, 0.4, 0.3). What to observe: the drop rate at which ICP fitness falls off a cliff (expect a sharp knee, not a gentle slope, near 60-70% loss), and confirm that your three-branch policy switches from continue to hold_and_relocalize right around that knee. Plot fitness versus drop rate and mark the threshold crossing. (About 20-30 minutes.)

Project Ideas

Beginner (weekend): Build a degraded-sensing confidence monitor in Gymnasium using a custom GridWorld environment where sensor returns are randomly dropped at a configurable rate; implement the three-branch policy from Code Fragment 1 and log which fallback fires most often as drop rate increases from 0% to 80%. The key challenge is defining a meaningful confidence metric from partial observations without access to ground truth. Intermediate (1-2 weeks): Deploy a Nav2 behavior tree on a TurtleBot3 in Gazebo (or a real unit) that detects lidar degradation by monitoring point-cloud density, switches to wheel-odometry-only localization when density drops below a calibrated threshold, and replays the full degradation event using ROS2 bag files with synchronized /scan, /odom, and /cmd_vel topics. The key challenge is tuning separate confidence thresholds for the simulated and physical environments so the robot does not false-trigger in low-texture open spaces. Advanced (3-4 weeks): Train a proprioceptive slip-recovery controller in Isaac Lab with randomized floor friction (0.1 to 0.9) and transfer it to a LeRobot-compatible quadruped policy that overrides the Nav2 local controller when Inertial Measurement Unit (IMU)-detected slip exceeds a threshold, then evaluate mission-completion rate on three surface types against a classical reactive fallback. The key challenge is bridging the Isaac Lab sim-to-real gap for contact dynamics without hardware fine-tuning.

What's Next?

Continue to Chapter 31: Language-Guided Embodied Agents, where this planning contract connects to the next embodied capability.

Section References

LaValle, S. M. "Planning Algorithms." Cambridge University Press, 2006. http://lavalle.pl/planning/

Open textbook reference for graph search, sampling-based planning, configuration spaces, and kinodynamic planning.

OMPL Project. "Open Motion Planning Library." Official documentation. https://ompl.kavrakilab.org/

Primary tool reference for sampling-based planners such as RRT, RRTstar, PRM, and kinodynamic variants.

ROS 2 Navigation Project. "Nav2 documentation." Official documentation. https://navigation.ros.org/

Primary documentation for global planners, controllers, costmaps, behavior trees, and recovery behaviors.