ProjekinAja. Robotics Stage 6 · Planning Deployment Lesson 6.8
● Stage 6 · Lesson 6.8

Hardware Bring-Up, Calibration, and Field Diagnostics

Hardware bring-up without a protocol is gambling — a systematic sequence (power → comms → sensors → actuators → control → navigation) saves days of debugging.

⏱ ~22 min read 🔧 Field engineering ⚠ Failure-mode focus

🎯 By the end you'll understand

Why a repeatable bring-up sequence exists and what goes wrong when you skip steps. How to validate each sensor layer before trusting it. Why a broken TF lookup silences cmd_vel downstream. What extrinsic calibration drift is and why it's one of the most common causes of person-following failures in the field. How temporal calibration fixes sensor fusion artifacts. How to use rosbag + Foxglove Studio to reproduce and diagnose field failures from your desk. How to tune parameters at runtime without recompilation using ROS 2 dynamic reconfigure.

KEY INSIGHTBring-up is a protocol, not a guess

The robot that died on day one of field testing almost always skipped the bring-up protocol. The engineer who invented the protocol had the same robot die on day one.

Every competent field robotics team has a bring-up document — a numbered checklist that is followed in the same order, every time, before any autonomous behavior is enabled. The ordering is not bureaucracy. It encodes a causal chain: you cannot validate sensor data if the sensor driver hasn't started; you cannot trust state estimation if the TF tree is incomplete; you cannot enable the controller if the actuators haven't been verified; you cannot run navigation if the controller hasn't been verified. Violating the order means validating the wrong thing or enabling behaviors on top of an undetected fault.

🔑 The upstream failure rule

Every failure mode in this lesson traces upstream: a bad actuator health check allows a silent motor fault to corrupt odometry, which corrupts the EKF, which corrupts navigation. The insight that separates experienced field engineers is this: when a behavior fails in the field, don't debug the behavior — debug the highest upstream system component that is still running. A failed TF lookup that silences cmd_vel looks exactly like a planner failure. A miscalibrated extrinsic transform looks exactly like a perception failure. The bring-up protocol is what gives you confidence that every upstream component was verified before the behavior layer ran.

HOW IT WORKSPower-first: the non-negotiable starting point

The bring-up sequence always starts with power, for a reason that seems trivially obvious until you've debugged a sensor that appeared to work but was running undervoltage. Sensors, especially IMUs and LIDAR units, have minimum operating voltages below which they produce structurally valid but physically incorrect data — no error flag, no disconnect, just wrong numbers. Motor drivers have similar behavior under brownout: they may accept commands and acknowledge them, but deliver reduced torque that corrupts the odometry model.

The power-first protocol for FollowBot:

1

Battery check: measure voltage under no-load and then under spin-up load

A LiPo that reads 16.8 V at rest may sag to 14.5 V when both motors accelerate. The motor driver's under-voltage lockout (UVLO) threshold is typically 12–14 V depending on driver model. If the sag under load crosses the threshold, the driver will cut out and re-enable in a loop — producing intermittent odometry spikes that look like encoder failures. Measure this before trusting any odometry data.

2

Compute platform power-on and boot verification

Confirm the Jetson or NUC has reached the target OS state (systemctl is-active ros2_launch.service) before sending any ROS 2 traffic. DDS discovery on a partially-booted node produces ghost participants that persist in the discovery database and can delay topic subscription by 10–30 seconds — long enough to appear as a sensor timeout during bring-up.

3

CAN bus / USB enumeration check

Verify that the LIDAR, IMU, motor driver, and any other USB/UART/CAN peripherals have enumerated at their expected device paths (/dev/ttyUSB0, /dev/can0, etc.). Use a udev-rules-based device alias (e.g., /dev/lidar) instead of bare USB paths — bare paths change across reboots if another device connects first.

HOW IT WORKSSensor driver validation: trust nothing until you've checked it

Sensor drivers can launch, publish topics, and subscribe successfully while delivering garbage data. Three things to check for each sensor before proceeding:

Sensor Topic Hz check Data sanity check Common fault
RPLIDAR A2 /scan 10 Hz ± 0.5 > 300 finite ranges per scan; no sustained runs of inf USB latency spikes halve Hz; check usbhid power management
RealSense D435 /camera/color/image_raw 30 Hz ± 1 Mean pixel value 40–200 (reject full-black or full-white frames) USB 3.0 port required; USB 2.0 drops to 15 Hz silently
RealSense D435 (depth) /camera/depth/image_rect_raw 30 Hz ± 1 Valid depth pixels > 40% of frame at 1 m distance Infrared interference in sunlit rooms; valid-pixel fraction collapses
IMU /imu/data_raw 200 Hz ± 5 Static accel magnitude 9.75–9.85 m/s²; static gyro bias < 0.01 rad/s Vibration from motors introduces broadband noise; check mounting isolation
Wheel encoders /odom 50 Hz ± 2 Push robot 1 m by hand; verify pose.pose.position.x = 1.0 ± 0.03 m Encoder cable near motor driver induces EMI; false tick counts
💡 ros2 topic hz and ros2 topic echo are your first diagnostics

Before opening RViz or running any custom diagnostic node, check ros2 topic hz /scan and ros2 topic hz /imu/data_raw. If a sensor is publishing at 2 Hz when it should publish at 10 Hz, every downstream rate assumption — the EKF update rate, the person tracker's temporal model, the costmap update frequency — is wrong. Rate failures cascade silently because most ROS 2 subscribers don't enforce a minimum arrival rate; they just process whatever arrives.

sensor_health_check.pyrclpy · bring-up validation node
import rclpy
from rclpy.node import Node
from sensor_msgs.msg import LaserScan, Imu
import math, statistics

class SensorHealthCheck(Node):
    def __init__(self):
        super().__init__('sensor_health_check')
        self._scan_stamps = []
        self._imu_stamps  = []
        self.create_subscription(LaserScan, '/scan', self.scan_cb, 20)
        self.create_subscription(Imu, '/imu/data_raw', self.imu_cb, 100)
        self.create_timer(2.0, self.report)

    def scan_cb(self, msg):
        now = self.get_clock().now().nanoseconds() * 1e-9
        self._scan_stamps.append(now)
        if len(self._scan_stamps) > 50: self._scan_stamps.pop(0)
        # count finite ranges — inf/nan mean out-of-range or invalid
        valid = sum(1 for r in msg.ranges
                    if not math.isinf(r) and not math.isnan(r))
        if valid < 300:
            self.get_logger().warn(f'LIDAR: only {valid} valid ranges — check surface reflectivity')

    def imu_cb(self, msg):
        now = self.get_clock().now().nanoseconds() * 1e-9
        self._imu_stamps.append(now)
        if len(self._imu_stamps) > 400: self._imu_stamps.pop(0)
        a = msg.linear_acceleration
        mag = math.sqrt(a.x**2 + a.y**2 + a.z**2)
        if not (9.70 <= mag <= 9.90):
            self.get_logger().warn(f'IMU: static accel magnitude {mag:.3f} m/s² — suspect')

    def report(self):
        def hz(stamps):
            if len(stamps) < 3: return 0.0
            deltas = [stamps[i]-stamps[i-1] for i in range(1, len(stamps))]
            return 1.0 / statistics.mean(deltas)
        self.get_logger().info(
            f'LIDAR {hz(self._scan_stamps):.1f} Hz | IMU {hz(self._imu_stamps):.1f} Hz'
        )

CORE CONCEPTTF tree verification: the chain that must be complete

The TF2 transform tree is the backbone of FollowBot's coordinate system. Every sensor message is stamped with its source frame (laser, camera_color_optical_frame, imu_link); every algorithm that combines measurements needs TF2 to express those measurements in a common frame. A single broken link in the TF tree silences the entire downstream system — not loudly, but quietly, through a cascade of failed lookups that causes nodes to either block waiting for a transform or drop messages entirely.

For FollowBot, the required TF tree at bring-up is:

map nav2 (AMCL) odom diff_drive_controller base_link laser camera_color_optical_frame imu_link URDF static URDF static FollowBot required TF tree at bring-up (6 frames, 5 transforms)
The TF2 tree FollowBot requires before any sensor fusion can start. Static transforms (base_link → laser, base_link → camera, base_link → imu) come from the URDF via robot_state_publisher. The odom → base_link dynamic transform is published by the diff_drive_controller at 50 Hz. The map → odom transform appears only after AMCL or SLAM has localized — it is absent at cold start and must be verified before navigation is enabled.

To verify the TF tree at bring-up:

bashTF bring-up checks
# print the entire TF tree and check for missing links
ros2 run tf2_tools view_frames

# live check: can we transform laser → base_link right now?
ros2 run tf2_ros tf2_echo base_link laser

# check the odom → base_link transform is arriving at 50 Hz
ros2 topic hz /tf | grep -A1 'average rate'

# the critical check before enabling navigation:
# map → odom must be present (published by AMCL or SLAM)
ros2 run tf2_ros tf2_echo map odom
⚠ A failed TF lookup cascades to cmd_vel silence — no error, no crash

When Nav2's controller cannot look up the map → base_link transform (because the map → odom link hasn't appeared yet), it does not crash. It logs a single warning and silently stops publishing /cmd_vel. The robot sits stationary. The behavior tree may continue running, reporting its internal state as "navigating." From the outside, this looks like a slow planner or a stuck robot. The root cause — a missing TF frame — is three nodes upstream. The bring-up protocol catches this because TF verification is step 3 and navigation enable is step 6.

SEE ITFollowBot bring-up checklist runner

Work through FollowBot's six-stage bring-up sequence. Each step can pass or fail — inject the fault to see how it propagates downstream. The calibration drift monitor in the final step shows the extrinsic reprojection error growing over 10 hours of operation; trigger a recalibration and watch it recover.

⚙ Interactive · System bring-up + calibration drift monitor

Step through the bring-up sequence. Use "Pass" or "Inject Fault" for each step. A fault locks all downstream steps until the fault is resolved. The calibration drift panel unlocks at step 6.

1
Power — battery voltage + driver enumeration
Measure battery voltage at rest and under spin-up load. Verify all USB/CAN devices enumerate at their expected aliases. Check compute platform boot state.
2
Sensor drivers — topic rate + data sanity
Verify LIDAR at 10 Hz with >300 valid ranges; IMU at 200 Hz with static accel 9.75–9.85 m/s²; RealSense at 30 Hz; encoders publishing odometry.
3
TF tree — all 5 transforms present and publishing
Verify base_link→laser, base_link→camera, base_link→imu_link (static from URDF); odom→base_link at 50 Hz from diff_drive_controller; map→odom from SLAM/AMCL.
4
Actuator health — zero-velocity check + manual motion test
Send zero velocity; verify motors are quiet (no 60 Hz hum from misaligned driver). Push robot 0.5 m by hand; verify odometry matches within 5%. Check motor driver temperatures.
5
Control layer — velocity command roundtrip test
Send a 5-second 0.2 m/s forward command via /cmd_vel; verify the robot travels 1.0 ± 0.05 m in a straight line; check EKF pose output matches physical measurement.
6
Navigation + calibration — Nav2 stack + extrinsic check
Enable Nav2; send a short 2 m navigation goal; verify the costmap reflects LIDAR obstacles; check LIDAR-camera extrinsic calibration by projecting a known obstacle into the image frame.

Work through each step in order. A fault in any step cascades to downstream steps.

The most important lesson in this widget: step 3 (TF tree) failing silences step 6 (navigation) without any explicit error from the navigation stack. The cmd_vel topic goes dark. A new engineer sees a "navigation failure" and starts debugging the planner. The root cause is three layers upstream — a missing transform that could have been caught in 10 seconds with ros2 run tf2_ros tf2_echo map odom. The bring-up protocol makes this impossible to miss.

CORE CONCEPTExtrinsic calibration: what it is and why it drifts

Intrinsic calibration (focal length, principal point, distortion coefficients) describes the camera's internal optics — it is stable for the lifetime of the lens unless the lens is physically damaged. Extrinsic calibration describes the rigid-body transform between two sensor coordinate frames: in FollowBot's case, the transform from the LIDAR frame to the camera frame (and equivalently, to base_link). This transform is measured once during calibration and stored as a static TF.

The extrinsic transform matters for person-following because FollowBot fuses LIDAR clusters (which give precise 2D range but no appearance information) with camera detections (which give appearance and depth but at lower angular resolution). The fusion step transforms the LIDAR cluster centroid into the camera image plane to check which image detection it corresponds to. If the extrinsic transform is wrong by even a few millimeters of translation or a fraction of a degree of rotation, the projected point misses the bounding box. The fusion fails silently: the LIDAR person candidate and the camera detection are treated as two different objects. The tracker loses its initialization.

⚠ Mechanical shock resets your extrinsic calibration

Any event that changes the relative pose of the LIDAR and camera invalidates the stored extrinsic transform. This includes: robot colliding with a wall or door frame (common in field testing), shipping the robot (vibration in transit shifts the sensor mount by 0.5–2 mm routinely), tightening a nearby screw (torquing through the chassis), and motor vibration over many operating hours (cumulative micro-displacement of the mount). The reprojection error of a known point (e.g., a calibration board corner visible in both LIDAR and camera) is the ground-truth health check — not visual inspection of the physical mounts.

The calibration procedure for LIDAR-camera extrinsic after mechanical shock:

1

Set up a calibration target with both LIDAR and camera visibility

A planar checkerboard at 1.5–2.5 m range, in an otherwise empty space, works reliably. The LIDAR must see at least one corner of the board as a distinct range discontinuity. The camera must see the full board with good contrast. Avoid indoor sunlight — infrared saturation affects both sensors simultaneously.

2

Record a rosbag of synchronized scans and images while moving the board

Collect 20–30 board positions spanning the overlap region of the two sensor FOVs. Use hardware time synchronization or the message_filters.ApproximateTimeSynchronizer with a 50 ms tolerance. Use the cam_lidar_calibration ROS 2 package or equivalent to solve for the 6-DOF extrinsic transform via point-to-plane ICP between the board's LIDAR plane and the camera-detected plane.

3

Validate reprojection error before deploying

Project a known LIDAR point (e.g., a corner retro-reflector) into the camera image using the new extrinsic transform. The pixel reprojection error should be below 2 px for acceptable LIDAR-camera fusion. Above 3 px, fusion performance degrades. Above 5 px, consider the sensors misaligned at the mount level before re-running calibration — the optimizer may be fitting a bad measurement.

CORE CONCEPTTemporal calibration: when sensors disagree in time

LIDAR and camera don't expose their data at the same instant. The LIDAR scan timestamp is the start of the rotation (or the end, depending on driver implementation); the camera frame timestamp is the sensor's exposure start. Both timestamps are further delayed by USB buffering, kernel scheduling, and DDS serialization — each by an amount that varies with system load.

The result is that a LIDAR scan and a camera frame that appear "simultaneous" in ROS 2 may describe the world at times 30–80 ms apart. At FollowBot's walking speed of 0.8 m/s, 80 ms of temporal misalignment means the fused person position is off by 6.4 cm — enough to miss a narrow doorway detection or generate a phantom obstacle in the costmap.

💡 Measure actual time offsets, don't assume zero

The standard diagnostic is to place a fast-moving LED in both the camera FOV and the LIDAR FOV (an IR LED that the LIDAR sees as a reflective anomaly) and blink it at 10 Hz. The time difference between the LIDAR's detection of the blink and the camera's detection gives the inter-sensor offset. This should be measured on the target hardware under load, not estimated from spec sheets. Software-sync tools like chrony eliminate NTP jitter but don't fix within-machine sensor offset. The RealSense SDK exposes a global_time_enabled option that timestamps at the sensor hardware clock — enable it.

For ROS 2 Humble, the recommended temporal synchronization stack for FollowBot:

sensor_sync.pyrclpy · ApproximateTimeSynchronizer
import rclpy
from rclpy.node import Node
from sensor_msgs.msg import LaserScan, Image
import message_filters

class SyncedFusion(Node):
    def __init__(self):
        super().__init__('synced_fusion')
        scan_sub = message_filters.Subscriber(self, LaserScan, '/scan')
        img_sub  = message_filters.Subscriber(self, Image,     '/camera/color/image_raw')
        # queue=10: pairs cached; slop=0.05: 50 ms tolerance
        # tune slop to your measured inter-sensor offset + margin
        self._sync = message_filters.ApproximateTimeSynchronizer(
            [scan_sub, img_sub], queue_size=10, slop=0.05
        )
        self._sync.registerCallback(self.fused_cb)

    def fused_cb(self, scan, img):
        # both messages are within 50 ms of each other
        dt = (float(scan.header.stamp.sec) + scan.header.stamp.nanosec * 1e-9) \
           - (float(img.header.stamp.sec)  + img.header.stamp.nanosec  * 1e-9)
        self.get_logger().debug(f'scan-image dt = {dt*1000:.1f} ms')
        # ... fuse here

Log the dt value for the first 100 pairs on new hardware. If the median is above 40 ms, investigate the USB bandwidth allocation across the two sensors — they may be sharing a hub and competing for bandwidth.

IN PRACTICErosbag recording and Foxglove Studio

The most important rule in field robotics: always record a rosbag. Any failure that isn't recorded cannot be diagnosed reproducibly. A failure you can replay is a failure you can fix. A failure you cannot replay is a failure you'll encounter again in a demo.

bashrosbag recording for field debugging
# Record everything except camera images (too large for long sessions)
ros2 bag record -a --exclude '/camera/color/image_raw /camera/depth/image_rect_raw'

# Or record a targeted subset for calibration debugging:
ros2 bag record /scan /tf /tf_static /cmd_vel /odom /imu/data_raw \
  /camera/color/image_raw /followbot/person_detections

# Split into 60-second chunks (avoids large file loss on crash):
ros2 bag record -a -d 60 -o followbot_field_session

# Replay at half speed for analysis:
ros2 bag play followbot_field_session --rate 0.5

Foxglove Studio (open source, runs locally, no data upload required) provides the most practical visualization layer for rosbag debugging. For FollowBot diagnostics, a minimal Foxglove layout should include: a 3D panel showing the TF tree, LIDAR scan, and camera image with LIDAR projections overlaid; a time-series panel for /cmd_vel linear.x and angular.z alongside /odom twist; a topic graph panel showing message rates. The LIDAR-on-image overlay is the single fastest visual check for extrinsic calibration drift.

💡 Runtime parameter tuning: no recompilation needed

ROS 2 dynamic parameters allow you to update node parameters at runtime via ros2 param set /node_name param_name value. This is the correct workflow for tuning inflation radii, costmap update rates, EKF noise matrices, and DWA velocity limits in the field. Do not recompile and redeploy for parameter changes — the round-trip time destroys your ability to iterate quickly. Declare all tunable parameters with declare_parameter() and handle them via a on_set_parameters_callback. For the EKF specifically, use robot_localization's native ROS 2 parameter file — all noise matrices are hot-reloadable without restart.

FOLLOWBOTFollowBot bring-up: the complete field checklist

At this stage of the course, FollowBot has a complete Nav2 stack: A* global planner on a SLAM map, DWA local planner with tuned dynamic constraints, LIDAR obstacle layer with inflation, and a behavior tree orchestrating detect → navigate → follow → handle occlusion → recover. The sim-to-real checklist is signed off. What's left is the recurring field ritual that makes all of that reliable.

🔑 The FollowBot field bring-up sequence (every session)

1 · Power: battery ≥ 15 V under spin-up. 2 · Boot: ros2_launch.service active; all device aliases present. 3 · Sensors: LIDAR 10 Hz, IMU 200 Hz, RealSense 30 Hz, odom publishing. 4 · TF tree: all 5 transforms present; map→odom live. 5 · Actuators: 1 m push test within 5%; zero-velocity hold quiet. 6 · Control: 1 m autonomous drive test, EKF pose within 3 cm. 7 · Calibration: extrinsic reprojection error check < 2 px. 8 · Navigation: 3 m goal, person detection in camera FOV visible in Foxglove LIDAR-on-image overlay. Sign off and begin session.

The milestone for this stage is documented: a signed-off system architecture document with honest per-subsystem performance assessments. The bring-up protocol is the living part of that document — it is wrong the first time you write it and correct approximately two field sessions later, once you've seen which steps actually fail and which are just ceremony. Update it after every failure.

Subsystem Sim performance Field performance (honest) Primary failure mode
LIDAR person detection 100% detection at 1–4 m ~88% detection — drops in crowd or at room edges near walls Cluster merge: person + nearby wall treated as one object
LIDAR-camera fusion Seamless re-ID on re-detection Fails within 2 min of extrinsic drift in high-vibration environments Extrinsic calibration drift (primary topic of this lesson)
EKF localization < 2 cm position error in mapped area ~5–8 cm in area with dynamic obstacles (chairs moved) LIDAR scan matching ambiguity in symmetric hallways
DWA local planner Smooth trajectories at all simulated speeds Oscillation above 0.8 m/s on polished tile; safe below 0.6 m/s Sim used flat tire friction; real surface is highly variable
Behavior tree recovery Recovers in < 3 s in all test scenarios Occasionally enters spin-in-place recovery loop in narrow corridors Sim costmap had no concave obstacles — corridor recovery not tested

This table is the honest outcome of sim-to-real transfer — better than starting from scratch, worse than you hoped, and the path forward is clear: fix the cluster merge algorithm, add automatic extrinsic drift monitoring (as the widget demonstrates), and expand the recovery behavior test suite to include narrow corridors. The architecture doesn't need to change. The parameters and edge-case handling do.

WEAKNESSWhere this bites

⚠ Calibrating once and never checking again

The most common cause of person-following failures in extended field testing is not a software bug — it's extrinsic calibration drift that nobody checked. The calibration performed on day one, in a controlled lab, with the robot fresh out of the box, will be wrong by field week two. The drift is small (sub-pixel initially), invisible to the eye, and reveals itself only when the LIDAR-camera fusion starts producing "ghost detections" or losing track of a clearly visible person. The fix is simple: add a 30-second extrinsic check to the pre-session bring-up protocol, every session, without exception. The drift monitor in the widget above is the minimal implementation — reprojection error on a known point before every session.

⚠ Recording bags is not optional "if you have time"

Field failures that aren't recorded are nearly impossible to reproduce. The specific sequence of sensor inputs, timing, and environmental state that triggered a failure is gone 10 seconds after it happens. "We'll remember what it looked like" is not a debugging strategy. The correct discipline is: if the robot is running outdoors or in a test environment, a bag is always recording. Disk space is cheap; engineering hours replaying a failure from memory are not. Use the split-bag approach (60-second chunks) to limit file sizes and eliminate the "we lost the whole session when the SSD filled" failure mode.

⚠ The TF tree is a dependency graph — debug it top-down

When a robot stops moving and the logs show "transform timeout" or "could not look up transform," the natural first response is to restart the navigation stack. This sometimes works by coincidence (something else also restarts) and fails to diagnose the root cause. The correct first step is to run ros2 run tf2_tools view_frames and find the broken link. In 80% of cases it is either the map→odom link (AMCL or SLAM not yet localized) or a static transform that wasn't published because robot_state_publisher launched before the URDF was fully loaded. Fix the broken link; don't restart everything hoping it resolves itself.

KEY INSIGHTHow this connects

  • 6.7 · The Sim-to-Real Gap: Taxonomy, Root Causes, and Honest Mitigations — the previous lesson identified categories of sim-to-real failures; bring-up and calibration protocols are the field engineering side of closing that gap. The honest performance table in the FollowBot section above is the direct output of the sim-to-real audit from Lesson 6.7.
  • 1.5 · TF2: The Transform Tree at Runtime — the TF verification steps in this lesson assume fluency with the TF2 frame graph model, why map→odom→base_link is a specific design choice (not convention), and the distinction between static and dynamic transforms. A missing static transform has a different fix than a stale dynamic one.
  • 1.6 · Sensors: Physics, Noise Models, and Failure Modes — the sensor validation table (valid range counts, IMU static accel bounds, USB bandwidth) maps directly to the noise models developed in Lesson 1.6. The validity thresholds are derived from those noise models, not invented arbitrarily.
  • 5.1 · Camera Geometry: The Pinhole Model, Distortion, and Why Calibration Is Not Optional — extrinsic calibration drift is an extrinsic failure, not an intrinsic one (the lens itself is fine); but computing reprojection error requires the full pinhole projection pipeline from Lesson 5.1, including the distinction between the camera matrix K and the extrinsic transform [R|t].
  • Next: 6.9 · Safety Architecture: Watchdogs, E-Stops, and Speed Governors — bring-up protocols assume the safety layer exists and is the last thing to enable. Lesson 6.9 builds the safety architecture: hardware e-stops, software watchdogs, and speed governors that limit the consequences of any remaining undetected fault.

GLOSSARYKey terms introduced

Bring-up protocol
A numbered, ordered checklist executed before enabling autonomous behavior. Each step validates a specific system layer; completing the step is a prerequisite for the next. The ordering encodes causal dependencies (power → comms → sensors → TF → actuators → control → navigation).
Extrinsic calibration
The rigid-body transform (rotation R and translation t) between two sensor coordinate frames — for example, LIDAR frame to camera frame. Determines where in the image a LIDAR point projects. Distinct from intrinsic calibration (which describes the camera's internal optics). Invalidated by mechanical shock or displacement of the sensor mount.
Reprojection error
The pixel distance between a 3D point projected into the image using a calibration transform and the actual observed image location of that point. The primary quantitative health metric for extrinsic calibration quality. Acceptable below 2 px for LIDAR-camera fusion; degraded above 3 px.
Temporal calibration
The measurement and compensation of time offset between two sensors whose clocks or buffering pipelines introduce a delay relative to each other. Uncompensated temporal offset causes spatial misalignment of fused measurements proportional to robot velocity × time offset.
Transform timeout
The error raised by TF2 when a requested transform (e.g., from map to base_link) is not available within a specified wait time. Typically indicates a broken TF link — a publisher that has stopped, a frame that was never configured, or a latency spike. The symptom is navigation silence; the cause is upstream.
Dynamic reconfigure
The ROS 2 mechanism for updating node parameters at runtime via ros2 param set without restarting the node. Enables in-field parameter tuning of EKF noise matrices, costmap parameters, PID gains, and planner limits. Requires the node to declare parameters with declare_parameter() and register an on-change callback.
Under-voltage lockout (UVLO)
A protection feature in motor drivers and voltage regulators that disables output when supply voltage falls below a safe threshold. At the threshold boundary, the driver may cycle on and off rapidly, producing intermittent behavior indistinguishable from encoder faults. Caught by measuring battery voltage under load at the start of every session.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1FollowBot starts up, all sensors are publishing, but Nav2 never issues any cmd_vel commands and the robot doesn't move. No error is logged. What is the most likely single root cause, and how do you verify it in under 30 seconds?›

The most likely root cause is a missing map → odom TF transform. Nav2's controller server needs to express the robot's pose in the map frame to compute velocity commands. If this transform is absent — because AMCL hasn't localized yet, or SLAM didn't initialize, or the map server crashed — the controller silently blocks on a transform lookup and publishes nothing. To verify in under 30 seconds: run ros2 run tf2_ros tf2_echo map odom. If it immediately outputs transform data, the TF link exists and the problem is elsewhere. If it prints "Waiting for transform..." indefinitely, you've confirmed the root cause. Fix by initializing the robot's pose in AMCL (via RViz's "2D Pose Estimate" tool) or verifying the SLAM node is running and publishing the map frame.

2After shipping FollowBot to a demo venue, the person-following system starts producing "ghost detections" — the LIDAR cluster and camera detection refuse to associate, creating two tracks for the same person. What is the most likely physical cause, and what is the correct diagnostic metric to verify it?›

The most likely physical cause is extrinsic calibration drift due to mechanical vibration during transport. The stored LIDAR-to-camera transform was calibrated in the lab; the relative pose of the two sensor mounts shifted by even 1–2 mm or < 0.5° during transit. When the LIDAR cluster centroid is projected into the camera image using the stale transform, it misses the bounding box by more than the fusion's association threshold, so the two detections are treated as separate objects. The correct diagnostic metric is reprojection error: project a retro-reflective target (visible in both sensors) through the extrinsic transform and measure the pixel distance between the projected point and the actual image location. If it's above 2–3 px, recalibrate the extrinsic transform before the demo.

3What is the difference between intrinsic and extrinsic camera calibration, and why does mechanical shock invalidate one but not the other?›

Intrinsic calibration captures the camera's internal optics: focal length (f_x, f_y), principal point (c_x, c_y), and lens distortion coefficients. These parameters describe the geometry of the lens and sensor grid. Mechanical shock does not change the lens or the sensor, so intrinsic calibration survives transport and rough handling (absent physical damage). Extrinsic calibration captures the rigid-body transform (rotation R, translation t) between the camera coordinate frame and another sensor's frame (e.g., LIDAR). This transform depends entirely on the physical mounting — the screws, brackets, and spacers holding the sensors. A 2 mm shift in the camera mount changes the translation vector t by 2 mm, which at 2 m range produces a 1 mm spatial error in the projected LIDAR point, equivalent to roughly 0.5 px reprojection error per mm of offset. Enough shifts to cause fusion failure without being visible to the naked eye.

4Why does the bring-up protocol order actuator validation (step 4) before the control layer test (step 5)? What failure does this ordering catch that the reverse order would miss?›

Actuator validation (step 4) checks the raw physical mechanism: push the robot by hand and verify odometry reads the correct displacement within 5%; listen for 60 Hz hum indicating a motor driver issue. These checks are done passively — without issuing any autonomous velocity command. The control layer test (step 5) issues an autonomous command and observes the result. If you run step 5 before step 4, and there is a left encoder EMI fault (producing 15% excess tick counts), the autonomous test produces a trajectory that curves right by a consistent bias. This looks like a PID tuning problem or a planner error. The step 4 check — pushing the robot by hand and measuring the odometry output directly — immediately reveals the encoder fault as a discrepancy between physical distance and reported distance, unambiguously pointing to the sensor layer, not the control layer. The ordering ensures you know the physical mechanism is correct before testing the control algorithm that depends on it.

Next: safety architecture — watchdogs, e-stops, and speed governors →