FollowBot System Architecture: Requirements to Block Diagram
A robot without a requirements specification is a research project; a robot with one is an engineering project — know the difference before writing a line of code.
🎯 By the end you'll understand
How to translate a mission statement into a formal, testable requirements specification. How to draw FollowBot's complete node graph, topic graph, and TF tree from first principles. What distinguishes hard real-time boundaries from soft real-time ones — and why getting that wrong breaks the entire architecture. How to justify each sensor in the suite against the requirements. And why every requirement that is not quantified is, in practice, untestable and therefore worthless.
KEY INSIGHTRequirements are the real design — code is just transcription
The moment you write cmd_vel before you have written the latency budget, you have made an irreversible architectural decision without knowing it.
Every robotics project starts with a mission: "follow a person." That is not a requirements specification — it is a wish. A requirements spec quantifies the wish: "maintain a distance of 1.0 ± 0.2 m to the target person at speeds up to 1.5 m/s, in indoor environments with obstacle densities up to 0.5 m⁻², with a person-detection failure rate below 0.1% per second of tracking." Each clause is a design constraint that eliminates options and makes the architecture legible.
A requirement is an engineering artifact only if it can be tested. "The robot should follow the person well" cannot be tested — "well" has no unit. "The robot shall maintain 0.8–1.2 m separation at velocities up to 1.5 m/s" can be tested with a tape measure, a stopwatch, and a willing colleague. Every vague requirement is a deferred argument about what "success" means, usually resolved in the field on a demo day. Engineers who write the requirements before the code resolve those arguments in writing, in advance, where they are cheap to fix.
CORE CONCEPTTranslating the FollowBot mission into formal requirements
The mission is: follow a specific person at a safe distance in an indoor environment, autonomously, using onboard sensors only. Decompose it into functional requirements (what the system must do) and non-functional requirements (how well it must do it, under what constraints). Each requirement is labeled, quantified, and assigned a test method.
| ID | Requirement | Quantified threshold | Test method |
|---|---|---|---|
| FR-1 | Person detection | Detect and re-identify target across occlusion ≤ 2 s | Walk behind obstacle for 1 s; robot recovers tracking within 2 s |
| FR-2 | Following distance | Maintain 0.8–1.2 m to target at v ≤ 1.5 m/s | Measure separation 30× at random instants during 60 s follow run |
| FR-3 | Obstacle avoidance | Zero collisions with static or slow obstacles (v < 0.3 m/s) | 10 trials through obstacle field; count collisions |
| FR-4 | Stop-on-loss | Robot stops within 2 s of target disappearing beyond sensor range | Target walks out of view; measure time to safe stop |
| FR-5 | Safe-stop distance | Emergency stop within 0.5 s when obstacle enters 0.3 m bubble | Approach static obstacle at v = 1.0 m/s; measure stopping distance |
| NFR-1 | Sensor-to-cmd_vel latency | End-to-end ≤ 80 ms at steady state; ≤ 200 ms spike tolerance | Timestamp LIDAR scan header vs. cmd_vel; log 500 cycles; compute p99 |
| NFR-2 | Control loop rate | cmd_vel published at 20 Hz minimum; controller at 50 Hz minimum | Record topic rate with ros2 topic hz /cmd_vel over 60 s |
| NFR-3 | Localization drift | Odometry drift ≤ 3% of distance traveled over 50 m | Drive 50 m closed loop; measure endpoint displacement |
| NFR-4 | Runtime environment | All nodes on ROS 2 Humble; Python ≥ 3.10 | Node startup log confirms ROS 2 distro |
Notice that NFR-1 (latency) and NFR-2 (loop rate) are not performance wishes — they are stability constraints. A 20 Hz cmd_vel rate sets the Nyquist bound for the velocity control loop: the fastest motion frequency the controller can track is 10 Hz, and at FollowBot's nominal speed of 1.0 m/s that corresponds to a positional period of roughly 10 cm. That is the coarsest motion you can track without aliasing. This number, derived from the requirement, immediately determines the architecture: the controller must be a separate, high-priority ROS 2 node that cannot be blocked by the path planner.
NFR-1 (latency ≤ 80 ms) forces the choice between Python and C++ for the EKF: a Python EKF on a Jetson Nano takes 8–12 ms per update; a C++ implementation takes 1–2 ms. If the LIDAR driver (2–4 ms), Python EKF (10 ms), YOLO detector (25 ms), DWA planner (20 ms), and controller (2 ms) all run sequentially, the total is 59 ms — just inside the budget. Add a costmap update and you blow it. Requirements written before the architecture force these calculations early, where they are cheap.
HOW IT WORKSFollowBot's node graph and topic graph
In ROS 2, the architecture is a directed graph of nodes exchanging typed messages on named topics. The node graph documents which processes exist; the topic graph documents which data flows where, at what rate. Together they are FollowBot's software architecture diagram.
The node graph reveals an architectural decision that is not obvious from the sense-think-act loop alone: the controller and the planner are separate nodes at different rates. The controller_server runs at 50 Hz and consumes local velocity targets. The planner_server runs on demand (≈ 5 Hz in normal following) and produces global path goals. This separation is not a style choice — it is a consequence of NFR-2. If the planner and controller ran in the same process, a planner spike (which regularly hits 50 ms) would stall the velocity controller, violating the 50 Hz requirement.
ROS 2 topics follow a namespace hierarchy. FollowBot uses: /scan (LIDAR, global), /color/image_raw and /depth/image_rect (camera namespace), /imu/data, /odom (raw wheel), /odom/filtered (EKF output), /target_pose (tracked person), /map, /cmd_vel. The convention: raw sensor data uses device-type names at the top level; processed outputs are nested under functional names. This matters when you launch multiple robots: namespace prefixing (/robot1/scan, /robot2/scan) keeps the graphs disjoint without code changes.
HOW IT WORKSThe TF tree: every transform FollowBot needs
The TF tree is not a bookkeeping formality — it is the architecture's contract for coordinate geometry. Every sensor measurement arrives in the sensor's frame; every plan is computed in the map frame; every velocity command is issued in base_link. Without the TF tree, these frames cannot be related, and every node would need to hardcode transform logic. With it, any node can query tf_buffer.lookup_transform() and get the right answer.
The critical property of this tree: it has exactly one root (map) and is acyclic. Every frame has exactly one parent. This means any transform between any two frames can be computed by walking up to the common ancestor and composing the individual transforms. If FollowBot's SLAM node cannot broadcast map→odom (e.g., it lost localization), the entire map-rooted subtree becomes unavailable — you get a TF timeout exception in every node that needs a map-frame lookup. That is not a bug; it is the correct behavior: better to fail loudly than to use a stale map.
import rclpy from rclpy.node import Node from tf2_ros import Buffer, TransformListener from geometry_msgs.msg import PointStamped import tf2_geometry_msgs # registers do_transform_point class LaserToMap(Node): def __init__(self): super().__init__('laser_to_map') self.buf = Buffer() self.tf = TransformListener(self.buf, self) def transform_point(self, pt_laser: PointStamped) -> PointStamped: # lookup the chain: laser → base_link → odom → map # tf2 composes the whole chain automatically try: return self.buf.transform(pt_laser, 'map') except Exception as e: self.get_logger().warn(ff'TF lookup failed: {e}') return None
Calling buf.transform(pt_laser, 'map') traverses the entire chain laser → base_link → odom → map automatically. You never write the matrix multiplication yourself. What you do control: the timestamp on the PointStamped header. Use the sensor's stamp, not rclpy.clock().now(). TF2 will interpolate to that exact time, removing the latency-induced error that would otherwise accumulate at 1.0 m/s over an 80 ms pipeline (8 cm of positional error per lookup if timestamps are wrong).
CORE CONCEPTHard real-time vs. soft real-time boundaries
Not all nodes in the graph have the same timing requirements. The distinction between hard and soft real-time is architectural: it determines which nodes need an RT-preemptive kernel, which need dedicated CPU cores, and which can share compute with other tasks.
| Node | Rate | Class | Deadline miss consequence | Mitigation |
|---|---|---|---|---|
| controller_server | 50 Hz | Hard RT | Missed motor command → velocity spike, possible collision | Isolated CPU core; RT thread priority; watchdog stop |
| imu_driver | 200 Hz | Hard RT | Missed IMU sample → EKF uses stale angular rate → heading drift | Hardware interrupt-driven; dedicated serial DMA |
| ekf_node | 50 Hz | Soft RT | Late update → larger position uncertainty this cycle; recovers next | Robot_localization package with C++ EKF; priority process |
| person_tracker | 10 Hz | Soft RT | Missed update → tracker covariance grows; planner uses last estimate | C++ DBSCAN + kalman predict-only mode during miss |
| yolo_detector | 15 Hz | Non-RT | Late detection → person_tracker runs predict-only; degrades gracefully | Async callback; separate GPU process |
| planner_server | On demand | Non-RT | Planning failure → bt_navigator triggers recovery; robot slows | Hard time limit 300 ms; simplified DWA as fallback |
| slam_toolbox | 1 Hz map, 10 Hz pose | Non-RT | Late map update → slightly stale costmap; acceptable for indoor following | Best-effort QoS; map update latency ≤ 1 s |
The practical consequence of this table: on a single-board computer like the Jetson Orin, you assign the controller_server and imu_driver to isolated CPU cores (SCHED_FIFO, priority 90) and let the rest run as standard Linux processes. You do not need a full RTOS for FollowBot because the hard-RT nodes are simple enough that standard Linux with careful isolation and a RT-preempt kernel patch provides sufficient determinism for a 50 Hz control loop. In a surgical robot or a safety-critical drone, the hard-RT boundary would extend much further upstream — requiring full RTOS or dedicated microcontroller for all hard-RT work.
Calling a node "soft real-time" means missed deadlines degrade performance gracefully — it does not mean you can be sloppy. The EKF at 50 Hz can miss one or two cycles and recover; it cannot miss 10 consecutive cycles without the uncertainty covariance growing large enough to trigger spurious planner replanning. Set QoS deadline policies on all soft-RT topics (deadline_ns=20000000 for a 50 Hz topic) so that the subscriber gets a callback on deadline miss, not silence. Silent deadline misses are the soft-RT version of the silent sensor failure from Lesson 1.6.
SEE ITBuild FollowBot's block diagram — wire topics and read the critical path
Place each node into the architecture, wire its primary output topic, set the data rate, and the diagram will compute the total latency along the critical path from LIDAR scan to cmd_vel. The goal is NFR-1: end-to-end ≤ 80 ms. Make a bad rate choice and the budget blows. Notice which nodes are on the critical path and which are not.
The key insight the widget is designed to make visceral: the YOLO detector and SLAM node are not on the critical path. YOLO feeds the person tracker asynchronously; the tracker runs on LIDAR-only when YOLO lags, degrading gracefully. SLAM feeds the costmap, which the planner uses — but the planner runs at 5 Hz, so even a 200 ms SLAM update cycle does not touch the LIDAR→cmd_vel latency. The critical path is narrow: LIDAR driver → EKF → person_tracker → controller_server. Optimize that chain; let the rest be best-effort.
IN PRACTICESensor suite justification: every sensor earns its seat
FollowBot's sensor suite is not a wishlist — each component was chosen to satisfy a specific requirement. Here is the complete justification. If a requirement changes, the sensor choice may too.
| Sensor | Primary topic | Requirement satisfied | Why not alternative? |
|---|---|---|---|
| RPLIDAR A2 (2D LIDAR, 360°, 10 Hz) | /scan |
FR-3 (obstacle avoidance), FR-1 (person LIDAR cluster), NFR-3 (SLAM localization) | Ultrasonic: 5–6 sensors needed for 360° coverage; no SLAM capability. Stereo camera: depth fails under direct sun. 2D LIDAR: proven, cheap, reliable 360° at 10 Hz. |
| Intel RealSense D435 (RGB-D, 30 Hz) | /color/image_raw, /depth/image_rect |
FR-1 (YOLO person ID), FR-2 (depth-based distance check), FR-5 (close-range obstacle) | Camera only (no depth): cannot satisfy FR-2 metrically. Depth only: YOLO person re-ID requires color. The D435 is the smallest package that satisfies both in one device. |
| 6-axis IMU (200 Hz, accel + gyro) | /imu/data |
NFR-3 (low-drift odometry), EKF heading correction between wheel encoder updates | Encoder-only odometry drifts 5–8% over 50 m on carpet. IMU reduces drift to < 2% when fused with EKF. Without IMU, NFR-3 cannot be met on non-ideal surfaces. |
| Wheel encoders (1000 PPR · 4000 counts/rev, 4× quadrature) | /odom |
NFR-2 (50 Hz base velocity feedback), primary dead-reckoning source | No alternative: you cannot close a velocity loop without a velocity measurement. Encoders are the cheapest, most reliable velocity sensor for a wheeled robot. |
Notice what is not in this suite: GPS. Indoor environments have no GPS signal. Ultra-wideband (UWB) beacons are a valid alternative for person ranging but require infrastructure installation that violates the "onboard sensors only" constraint of the mission. A 3D LIDAR (like the VLP-16) would eliminate the 2D SLAM limitation but costs 10× more and produces a point cloud FollowBot's compute cannot process at its latency budget. Every component choice is a tradeoff forced by the requirements — and justified by them.
YOLO detects the person; the LIDAR cluster tracks the person. These are not redundant — they are complementary. YOLO provides semantic identity ("this blob is a person, that blob is a chair") but fails in low light and gives imprecise depth. LIDAR provides precise depth but is identity-blind (all clusters look alike). The fusion in person_tracker uses YOLO for identity confirmation and LIDAR for metric position. Remove either sensor and you lose either metric precision or semantic disambiguation — both of which are needed to satisfy FR-1 and FR-2 simultaneously.
FOLLOWBOTStage 1 milestone: architecture complete
This lesson is the culminating architectural step of Stage 1. Before Lesson 1.8, you had individual pieces: the sense-think-act mental model (1.1), coordinate frames (1.2–1.3), the ROS 2 communication layer (1.4), the TF2 system (1.5), sensor physics (1.6), and the real-time constraint (1.7). This lesson assembles them into a coherent, testable specification.
At the end of Lesson 1.8, FollowBot has: (1) a formal requirements specification with quantified thresholds and test methods; (2) a complete node graph, topic graph, and TF tree; (3) hard/soft/non-RT classification for every node; (4) a sensor suite with per-requirement justification; (5) a latency budget (≤ 80 ms) derived from the requirements rather than guessed. Lesson 1.9 builds the URDF from this specification. Every inertial parameter and sensor placement in the URDF will trace back to a number established here.
Here is the canonical ROS 2 launch file structure that instantiates this architecture. It is the entry point you will fill in across Stages 1–3:
from launch import LaunchDescription from launch_ros.actions import Node def generate_launch_description(): return LaunchDescription([ # ── SENSE layer ───────────────────────────────────────── Node(package='rplidar_ros', executable='rplidar_node', name='lidar_driver', parameters=[{'frame_id': 'laser'}]), Node(package='realsense2_camera', executable='realsense2_camera_node', name='camera_driver'), Node(package='followbot_hw', executable='imu_driver'), Node(package='followbot_hw', executable='wheel_odom'), # ── ESTIMATE layer ────────────────────────────────────── Node(package='robot_localization', executable='ekf_node', name='ekf_node', parameters=['config/ekf.yaml']), # NFR-3 Node(package='followbot_perception', executable='yolo_detector'), Node(package='followbot_perception', executable='person_tracker'), Node(package='slam_toolbox', executable='sync_slam_toolbox_node'), # ── PLAN layer ────────────────────────────────────────── Node(package='nav2_planner', executable='planner_server'), Node(package='nav2_bt_navigator', executable='bt_navigator'), # ── ACT layer — isolated for hard RT ──────────────────── Node(package='nav2_controller', executable='controller_server', additional_env={'RCUTILS_LOGGING_BUFFERED_STREAM': '0'}), # NFR-2, NFR-1 ])
The structural choice that is easy to miss: the controller_server has RCUTILS_LOGGING_BUFFERED_STREAM=0. Buffered logging introduces non-deterministic flush latency on the RT thread. Disabling it prevents that. It is a one-line decision that derives directly from the hard-RT classification established in this lesson's table. This is what "requirements-driven architecture" means in practice: every configuration line has a traceable cause.
WEAKNESSWhere this bites
The most common failure in the requirements-to-architecture transition is writing requirements that sound quantified but omit the test method. "Latency shall be less than 80 ms" is not testable as written. What clock source? What measurement interval? At what load? The test method ("timestamp LIDAR scan header vs. cmd_vel header; log 500 cycles; compute p99") is what makes the requirement auditable. Without it, two engineers can disagree about whether the system passes — and they always will, at the worst time. Write the test method first; it forces precision in the requirement statement.
The TF tree is a coordinate geometry contract; the node graph is a software communication contract. They look superficially similar — both are directed graphs — but they are entirely different artifacts. A node can publish to a TF topic without appearing as a "logic node" in your system diagram. slam_toolbox publishes the map→odom transform and appears in both the node graph (as a compute node) and the TF tree (as the broadcaster of a dynamic link). The costmap_server appears in the node graph but adds no new TF frame. Confusing the two leads to TF trees with phantom nodes and node graphs with missing transforms — both of which produce cryptic runtime errors rather than clean architecture diagrams.
The most expensive mistake in mobile robotics architecture is choosing an algorithm (e.g., Neural SLAM, a vision transformer for person detection) before computing the latency budget it must fit. A ViT-based person detector takes 80–150 ms per frame on a Jetson Orin without TensorRT optimization. If you discover this after integrating it into the tracking pipeline, you have two choices: spend two weeks on TensorRT optimization, or redesign the pipeline to make YOLO async (which you should have done from the start). The latency budget, derived from NFR-1 and the control rate in NFR-2, should be the first architectural document — before any algorithm is chosen. It is the constraint that makes algorithm selection engineering rather than preference.
KEY INSIGHTHow it connects
- 1.1 · What Is a Robot? The Sense-Think-Act Loop — the four logical nodes (Sense, Estimate, Plan, Act) introduced there map exactly onto the node graph layers built here. The requirements specification is what turns those logical abstractions into concrete software boundaries.
- 1.4 · ROS 2 Architecture: Nodes, Topics, Services, and Actions — every edge in the node graph is a topic, service, or action defined in Lesson 1.4. The QoS policies for each edge (especially the deadline setting for hard-RT topics) are now determined by the real-time classification table above.
- 1.5 · TF2: The Transform Tree at Runtime — the TF tree drawn in this lesson instantiates the TF2 concepts from Lesson 1.5. The distinction between dynamic and static broadcasts, the single-root requirement, and the timestamp-matching behavior all come directly from Lesson 1.5's teaching.
- 1.6 · Sensors: Physics, Noise Models, and Failure Modes — every sensor in the suite justification table was chosen knowing its noise model and failure modes from Lesson 1.6. The LIDAR absorption failure, the camera clipping failure, and the IMU bias drift are all architectural risks that the requirements specification must acknowledge.
- 1.7 · Actuators and the Real-Time Constraint — the hard/soft real-time classification table above is the concrete instantiation of the real-time theory in Lesson 1.7. The 50 Hz controller rate and the RT thread priority for the controller_server derive directly from the real-time analysis.
- 1.9 · URDF: Building FollowBot's Digital Twin — the TF tree specifies the sensor positions (laser at x=0.12, z=0.18; camera_link at x=0.20, z=0.30). Lesson 1.9 makes those positions physical: encoded in URDF
<origin>elements, with matching inertial parameters, so that Gazebo and the real robot agree on where the sensors are.
Stage 1 now has its capstone: a complete, quantified, testable architecture specification. Every later stage — kinematics in Stage 2, dynamics and control in Stage 3, state estimation in Stage 4, perception and SLAM in Stage 5, planning and deployment in Stage 6 — fills in one of the algorithm boxes defined here. The architecture does not change; the implementations do. That is the value of a good requirements specification: it stays stable while the code evolves underneath it.
GLOSSARYKey terms
- Functional requirement (FR)
- A statement of what a system must do, expressed in observable, testable behavior. Distinguished from non-functional requirements by describing capability rather than quality or constraint. Example: "FR-1: detect and re-identify the target person across occlusion ≤ 2 s."
- Non-functional requirement (NFR)
- A constraint on how the system performs its functions — latency, accuracy, resource usage, reliability. NFRs determine architecture; FRs determine features. A system can satisfy all FRs while violating an NFR and still be undeployable.
- Critical path
- In a computation graph, the longest chain of dependent operations that determines the minimum end-to-end latency. In FollowBot, the critical path is /scan → EKF → person_tracker → controller → /cmd_vel. Optimizing any node off the critical path has no effect on end-to-end latency.
- Hard real-time
- A timing constraint where missing a deadline results in system failure (collision, crash, safety violation). Requires deterministic scheduling — usually a dedicated CPU core at RT priority or a dedicated microcontroller. The controller_server's 50 Hz deadline is hard real-time for FollowBot.
- Soft real-time
- A timing constraint where missing a deadline degrades performance but the system can recover on the next cycle. The EKF's 50 Hz update is soft real-time: a missed update grows the uncertainty covariance; the next on-time update partially corrects it.
- Node graph
- A directed graph in which nodes are ROS 2 processes and edges are topics, services, or actions. The node graph is the software architecture artifact that describes which computations exist and how they communicate. Distinct from the TF tree, which describes coordinate geometry.
- TF tree
- A directed acyclic tree in which nodes are coordinate frames and edges are transforms (position + orientation) with timestamps. Every frame has exactly one parent; the root is the global reference frame (map). All geometric data in FollowBot is associated with a TF frame, enabling cross-frame queries via tf2_ros.Buffer.
- Latency budget
- The apportioning of an end-to-end latency requirement across individual pipeline stages. A latency budget allocated before algorithm selection constrains the choices: an algorithm that cannot fit its share of the budget is eliminated before integration, not after.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1What makes a requirement "testable," and give one example of converting an untestable FollowBot requirement into a testable one.›
A requirement is testable when it specifies: (1) a measurable quantity, (2) a threshold, and (3) a test procedure with specified conditions. "The robot should follow closely" fails all three. A testable version: "The robot shall maintain 0.8–1.2 m separation from the target at velocities up to 1.5 m/s (test: measure separation 30 times at random intervals during a 60 s follow run in a 5×5 m room with 3 static obstacles; > 90% of samples must be within the range)." The quantity is separation distance; the threshold is 0.8–1.2 m; the procedure specifies the measurement method, count, environment, and pass criterion. Without the procedure, any number of robot behaviors could be argued to "follow closely." With it, the argument is replaced by a measurement.
2Why are the YOLO detector and SLAM toolbox not on the critical path from /scan to /cmd_vel, while the EKF and person_tracker are?›
The critical path is defined as the chain of sequential, dependent computations that determine end-to-end latency. YOLO and SLAM are not on this chain because their outputs are consumed asynchronously: YOLO feeds the person_tracker as an optional input (tracker runs predict-only if YOLO is late); SLAM feeds the costmap, which the planner uses — but the planner runs on demand, not on every LIDAR scan. Neither YOLO nor SLAM blocks the controller from publishing. By contrast, the EKF must update its pose estimate before the person_tracker can localize the target, and the person_tracker must publish /target_pose before the controller can compute a velocity command. These are sequential dependencies, so their latencies add on the critical path. Optimizing YOLO from 25 ms to 15 ms saves 10 ms on person re-ID quality but zero milliseconds on end-to-end latency.
3FollowBot's controller_server is classified as hard real-time. What are the two practical consequences of that classification for how you configure the ROS 2 launch file and the OS?›
Two concrete consequences: (1) OS-level isolation: the controller_server process gets a dedicated CPU core (using Linux CPU affinity or isolcpus kernel parameter) running at SCHED_FIFO priority ~90, preventing OS scheduler jitter from delaying the 50 Hz timer callback. Without this, a burst of DDS traffic or a GC cycle in another Python process can delay the callback by 5–20 ms — enough to drop a cycle on a 20 ms period. (2) Logging configuration: buffered logging is disabled (RCUTILS_LOGGING_BUFFERED_STREAM=0) because the periodic buffer flush introduces unpredictable latency spikes on the RT thread. These two changes together bring worst-case jitter on the controller callback from ~30 ms to < 2 ms on a Jetson Orin. Neither change is needed for soft-RT or non-RT nodes, which is why the hard/soft/non-RT classification table drives concrete configuration decisions rather than being a philosophical distinction.
4The TF tree has a single root (map) and is acyclic. Why does the single-root requirement matter for SLAM-based systems like FollowBot?›
The single-root requirement ensures that any transform between any two frames is uniquely computable by walking up to the common ancestor. If the tree had two roots (map and odom, both floating), the transform between a laser scan point and a map-frame goal would be undefined — there would be no path through the graph. In SLAM systems this is especially important because the map→odom dynamic link is the SLAM correction: it absorbs the drift between the incrementally-integrated odometry (odom→base_link) and the globally consistent map. When SLAM localization fails (loop-closure miss, featureless corridor), the SLAM node stops publishing map→odom. The tree is then rooted at odom only — a degraded but consistent mode. The system can detect this (TF timeout on map-frame queries) and switch to a safe-stop or recovery behavior. A two-root system would have no such clean failure mode: you would simply get incorrect transforms without any diagnostic signal.