ProjekinAja. Robotics Stage 1 · Foundations Lesson 1.5
● Stage 1 · Lesson 1.5

TF2: The Transform Tree at Runtime

TF2 is the hidden backbone of every ROS 2 robot — a wrong or stale transform silently poisons every downstream algorithm.

⏱ ~22 min read 🧠 ROS 2 infrastructure ⚠ Most common runtime error

🎯 By the end you'll understand

How the TF2 buffer and broadcaster architecture work at runtime. The difference between static and dynamic transforms — and why confusing them is one of the most common ROS 2 mistakes. How time-travel lookups and interpolation work, and when they fail. The exact conditions (stale TF, missing frame, future timestamp) that trigger each lookupTransform error variant. How to build FollowBot's complete TF tree from scratch.

KEY INSIGHTTF2 is a distributed time-series database, not a static lookup table

Every robotics algorithm that operates on geometry — every SLAM system, every path planner, every sensor fusion pipeline — silently depends on TF2 being correct, recent, and complete. When TF2 fails, the algorithm doesn't crash. It computes the right answer in the wrong frame and returns a number that looks plausible.

Most learners treat TF2 as a bookkeeping formality — you write the broadcaster once and forget it. This is exactly backwards. TF2 is a real-time, distributed system with its own failure modes that are among the most frequently Googled ROS 2 errors: ExtrapolationException, LookupException, ConnectivityException. Understanding why each one occurs — not just how to suppress the log message — is what separates a robotics engineer from someone who copies code until it stops complaining.

🔑 The core contract

TF2 guarantees: "given a source frame, a target frame, and a timestamp, I will give you the 4×4 homogeneous transform that maps points from source to target, using the best interpolation possible from the transforms I have buffered." If any part of that contract cannot be honored — the timestamp is too old, a frame is missing, the tree is disconnected — TF2 raises an exception rather than returning a silently wrong answer. Every TF2 exception is informative. Suppressing it with a try/except and continuing is almost always the wrong fix.

HOW IT WORKSThe buffer and broadcaster architecture

TF2 in ROS 2 is not a single node — it is a library that every node loads independently, backed by a shared data source: the /tf and /tf_static topics. Here is the architecture in full:

StaticTransformBroadcaster publishes once on /tf_static TransformBroadcaster publishes at runtime on /tf robot_state_publisher URDF joints → /tf + /tf_static /tf_static latched · QoS transient_local /tf best-effort or reliable TransformBuffer (local to each listener) caches last ~10 s of /tf holds all /tf_static forever tree traversal on query Listener node lookupTransform() SLAM / planner point cloud transform Each listener node holds its own local copy of the buffer — TF2 is decentralized, not a shared service. The buffer holds transforms for the last ~10 seconds (configurable via cache_time). Older data is evicted. /tf_static is transient-local QoS: late-joining nodes receive all static transforms on subscribe.
TF2 architecture. Broadcaster nodes write to shared topics; each listener node subscribes and maintains its own in-process buffer. There is no central TF2 server in ROS 2 — the buffer is distributed. This is fast but means each node only knows what its buffer has received.

The decentralized architecture is important. In ROS 1 there was a single tf server. In ROS 2, every node that needs transforms instantiates a tf2_ros.Buffer and a tf2_ros.TransformListener (which subscribes to /tf and /tf_static and populates the buffer). When you call lookupTransform(), you are querying your own local buffer — and that buffer only contains what has been published since you subscribed, plus all static transforms. This is why a node that starts late may throw LookupException before its buffer has received recent dynamic transforms.

💡 Why the buffer is 10 seconds, not 10 milliseconds

The default cache_time is 10 seconds, not some tiny window. This is intentional. Algorithms like SLAM need to transform a LiDAR scan (timestamped when it was acquired) into the map frame (at the current time). If processing is slow — the CPU spiked, a large map update ran — the scan's timestamp might be 2–3 seconds behind now(). With a 10-second buffer, TF2 can interpolate correctly. With a 0.1-second buffer, every scan under load would throw ExtrapolationException. Setting cache_time too small is a surprisingly common bug in deployed systems.

CORE CONCEPTStatic vs. dynamic transforms — not just a performance choice

TF2 has two broadcaster types. This is not a performance micro-optimization — it is a semantic distinction with runtime consequences:

Property StaticTransformBroadcaster TransformBroadcaster
Publishes to/tf_static/tf
QoStransient_local (latched)best-effort or reliable (not latched)
Late-joining nodes receive it?Yes — immediately on subscribeNo — must wait for next publish
Held in bufferForever (never evicted)Only within cache_time window
Timestamp usedTime of publish (or zero)Current time at each publish
Use forFixed mechanical joints (base_link → laser)Moving joints, odom → base_link
What goes wrong if misusedStatic for dynamic: stale transform; ExtrapolationException under loadDynamic for static: unnecessary /tf traffic; late-joiner misses it

The design rule is simple: if the transform changes over time as the robot moves or its joints articulate, use TransformBroadcaster at the appropriate rate. If the transform is fixed by mechanical assembly — the offset between base_link and the LIDAR mounting point — use StaticTransformBroadcaster.

Here is what the broadcaster code looks like for FollowBot's fixed LIDAR mount, and for the continuously updated odometry transform:

tf_example.pyrclpy · static & dynamic broadcasters
import rclpy
from rclpy.node import Node
from tf2_ros import StaticTransformBroadcaster, TransformBroadcaster
from geometry_msgs.msg import TransformStamped
import math

class TFExample(Node):
    def __init__(self):
        super().__init__('tf_example')

        # ── Static: LIDAR is bolted 12 cm forward and 18 cm above base_link, 0° yaw
        self._static_br = StaticTransformBroadcaster(self)
        t_static = TransformStamped()
        t_static.header.stamp = self.get_clock().now().to_msg()
        t_static.header.frame_id = 'base_link'
        t_static.child_frame_id  = 'laser'
        t_static.transform.translation.x = 0.12  # 12 cm forward
        t_static.transform.translation.z = 0.18   # 18 cm above base
        t_static.transform.rotation.w    = 1.0    # identity quaternion
        self._static_br.sendTransform(t_static)    # once; latched on /tf_static

        # ── Dynamic: odometry updates odom → base_link at 50 Hz
        self._dyn_br = TransformBroadcaster(self)
        self.create_timer(0.02, self._publish_odom_tf)   # 50 Hz
        self._x = 0.0; self._y = 0.0; self._yaw = 0.0

    def _publish_odom_tf(self):
        t = TransformStamped()
        t.header.stamp    = self.get_clock().now().to_msg()
        t.header.frame_id = 'odom'
        t.child_frame_id  = 'base_link'
        t.transform.translation.x = self._x
        t.transform.translation.y = self._y
        # quaternion for pure yaw: (0, 0, sin(θ/2), cos(θ/2))
        t.transform.rotation.z = math.sin(self._yaw / 2)
        t.transform.rotation.w = math.cos(self._yaw / 2)
        self._dyn_br.sendTransform(t)   # every 20 ms; aged out after cache_time
📖 The tree constraint

TF2 requires the transform graph to be a tree (directed acyclic graph with a single root). Every frame has exactly one parent frame. This means: you cannot have map → odom → base_link and also odom → map — TF2 will silently drop the second edge, and which edge gets kept is undefined. In practice, this means your architecture must decide which node owns each edge and enforce that only one broadcaster ever publishes a given parent–child pair.

CORE CONCEPTTime-travel lookups and interpolation

The central operation in TF2 is lookupTransform(target_frame, source_frame, time). The time argument is where the "time-travel" concept lives — and where most errors originate.

When you call lookupTransform('map', 'laser', scan_stamp) where scan_stamp is the timestamp the LIDAR captured the scan, TF2 does the following:

1

Find the chain from source to target

TF2 traverses the tree from laser upward to the common ancestor of laser and map, then downward to map. For FollowBot this is: laser → base_link → odom → map. Each edge must exist in the buffer with data at or near scan_stamp.

2

Interpolate each edge at the requested time

For each edge in the chain, TF2 finds the two buffered transforms whose timestamps bracket scan_stamp (one just before, one just after) and linearly interpolates translation and SLERP-interpolates rotation. If scan_stamp falls within the buffered range, interpolation succeeds.

3

Compose the chain

The interpolated transform for each edge is a 4×4 homogeneous matrix. TF2 composes them by matrix multiplication (right to left along the chain). The result is T_map_laser: the transform that maps laser-frame points to map-frame coordinates.

4

Raise an exception if any step fails

If the requested time falls outside the buffered range (too old or in the future), TF2 raises ExtrapolationException. If a frame in the chain does not exist, it raises LookupException. If the chain between source and target is disconnected (no path through the tree), it raises ConnectivityException. None of these return a "best guess" silently — they always fail loudly.

There is an important special case: if you pass rclpy.time.Time() (the zero time) as the timestamp, TF2 returns the most recent available transform for each edge, without attempting to synchronize timestamps across edges. This is useful for visualization and debugging but dangerous for sensor fusion — you may compose transforms from different times and violate temporal consistency.

⚠ The extrapolation error appears under load, not in tests

The most insidious aspect of ExtrapolationException is that it typically does not appear in light test runs. Under light load, the odometry node publishes odom → base_link at 50 Hz and the perception node processes LIDAR scans at 10 Hz — the requested timestamps are always well within the buffer. Under heavy CPU load (running SLAM, YOLO, and map updates simultaneously), the perception node falls behind and processes scans timestamped 3–8 seconds ago. The odom transform for that timestamp has now been evicted from the buffer. ExtrapolationException fires. The standard fix is to increase cache_time — but the root cause is processing lag, which the exception is faithfully reporting.

SEE ITTF tree builder — simulate lookup failures

Build FollowBot's TF tree frame by frame. Set each transform as static or dynamic, then simulate a lookupTransform at a lagged timestamp. Watch the extrapolation error grow with delay. Inject a missing frame and observe which downstream nodes go silent. Every failure here mirrors a real ROS 2 runtime error.

⚙ Interactive · FollowBot TF tree builder

Add frames to the tree. Configure each as static or dynamic. Then run a lookup and see which error variant fires — and why.

map world frame · root odom odometry origin base_link robot body origin laser LIDAR frame camera RGB-D frame dynamic dynamic static static
Transform type
map → odom
odom → base_link
base_link → laser
base_link → camera
Lookup lag

How many seconds behind now() is the requested timestamp? Models slow perception processing under CPU load.

0.0 s
Buffer coverage
10.0 s
Lag vs cache_time
0.0 s

Ready — configure the tree and run a lookup

The default tree is FollowBot's correct configuration: map → odom → base_link → laser → (camera is sibling). Try setting lag to 0 first (instant success), then increase lag, then flip a transform to "missing" and observe which error fires.

✓ lookupTransform succeeded

✗ ExtrapolationException

Why: the requested timestamp (t − lag) falls outside the buffered range for one or more dynamic transforms in the chain. The buffer holds the last 10 s; your lag of 0 s has exceeded it. TF2 refuses to extrapolate because linear extrapolation of transforms diverges quickly — even 50 ms of extrapolation on a turning robot produces centimeters of error.

Downstream effect: the LIDAR perception node that called this lookup throws an exception, catches it, and skips that scan. The person-tracker receives no update. After enough missed scans, FollowBot loses the person. The root cause — CPU overload — appears as a person-tracking failure.

Correct fix: reduce processing lag (profile and optimize the CPU spike) or increase cache_time if the lag is bounded and acceptable. Do not suppress the exception and continue with a stale transform — that returns wrong results silently.

✗ LookupException

Why: one or more frames in the chain from laser to map do not exist in the buffer. This happens when the broadcaster for that frame has not yet started, has crashed, or was never implemented.

Downstream effect: every node that needs a transform through the missing frame will fail. In FollowBot's case, if odom is missing, both the LIDAR and camera perception nodes lose their ability to express observations in map coordinates. SLAM cannot run. The planner has no map-frame pose. The robot is effectively blind.

Correct fix: verify which node should publish this transform (check with ros2 run tf2_tools view_frames) and confirm that node is running. A missing static transform usually means robot_state_publisher has not been launched or the URDF is malformed.

⚠ Misuse: static broadcaster for a dynamic transform

Why: you configured a dynamic transform (one that changes as the robot moves) as a StaticTransformBroadcaster. The transform will be published once and latched. As the robot moves, the transform becomes increasingly stale — but it stays in the buffer forever. Under light load the error may be small. Under high load (when the robot has moved significantly since the static publish), the stale transform silently introduces large errors. Unlike ExtrapolationException, this failure is silent — no exception is raised.

Downstream effect: the LIDAR perception node uses a transform that was correct when the robot started. After 10 seconds of movement, points that should be in one part of the map are projected to a location 0.8 m off. SLAM diverges gradually. The symptom looks like "bad sensor noise" or "SLAM drift."

Correct fix: move the dynamic transform to TransformBroadcaster, published at the odometry rate (typically 50 Hz). Check your broadcaster assignments whenever you see consistent, directional pose drift.

Default FollowBot tree loaded. All dynamic transforms published at 50 Hz. Lag = 0 s.

HOW IT WORKSThe three TF2 exception types: exact conditions

These are among the most frequently encountered ROS 2 runtime errors. Here is a precise taxonomy — not "how to suppress them" but what conditions deterministically produce each one.

Exception Trigger condition Specific scenario Silent?
ExtrapolationException Requested time is before the oldest or after the newest buffered transform for any edge in the chain LIDAR scan timestamp is 11 s old; odom → base_link buffer only holds 10 s; lookup at scan time fails No — throws exception
LookupException A frame ID in the source-to-target chain does not appear in the buffer at all The broadcaster for camera_depth_frame crashed 2 minutes ago; buffer evicted all its transforms; frame is now unknown No — throws exception
ConnectivityException No path exists in the tree connecting source and target frames An arm link is published relative to arm_base which has no parent in the tree; the tree is disconnected No — throws exception
Stale static transform A dynamic transform was broadcast as static; robot has moved; cached transform is wrong odom → base_link published once at startup; robot moved; transform reports robot at origin Yes — no exception
Wrong-time zero-time lookupTransform called with time = zero; returns newest per-edge, not synchronized timestamps Sensor fusion call mixes map → odom at t=1.0 s with odom → base_link at t=1.05 s; subtle temporal inconsistency Yes — no exception
⚠ ExtrapolationException under future timestamp

There is a second, less obvious trigger for ExtrapolationException: the requested time is in the future. This happens when a node's clock is slightly ahead of the broadcaster's clock due to clock drift across containers or machines in a distributed setup. A timestamp difference of 50 ms can cause this. The fix is to use lookup_transform_full with a timeout parameter, or to synchronize clocks with /clock topic in simulation (use_sim_time: true). This exact bug appears in virtually every first Gazebo simulation session.

FOLLOWBOTBuilding FollowBot's complete TF tree

FollowBot's TF tree is the connective tissue of its Stage 1 milestone. Every sensor's data must be expressible in every other sensor's frame and in the global map frame, with correct timestamps. Here is the complete tree design and the reasoning behind each edge choice:

dynamic (TransformBroadcaster) static (StaticTransformBroadcaster / URDF) map published by: SLAM / AMCL rate: on SLAM update (~5 Hz) dynamic odom published by: nav2_odom node rate: 50 Hz (odometry integration) dynamic base_link published by: robot_state_publisher origin: geometric center, floor level static laser +0.12 m x, +0.18 m z, 0° yaw from URDF link offset static camera_link +0.05 m x, +0.22 m z tilted −5° pitch (down) static camera_depth_frame RealSense optical axis
FollowBot's complete TF tree for Stage 1 milestone. Dynamic edges (blue) are published at runtime by odometry and SLAM nodes. Static edges (gold) are published once from the URDF via robot_state_publisher and held in the buffer forever. The tree is the prerequisite for every sensor fusion and planning operation in Stages 4 and 5.

Notice the separation of concerns: robot_state_publisher owns all the rigid-body transforms derived from the URDF (the static edges). The odometry node owns the continuously-updated odom → base_link edge. The SLAM node owns map → odom, which it corrects each time a loop closure is detected. This division means that if you replace the SLAM system with a different localization algorithm, only the map → odom edge changes — the rest of the tree is unaffected.

🔑 Why map → odom → base_link (not map → base_link)?

This is one of the most important architectural decisions in mobile robotics. odom → base_link is published by wheel odometry at high rate (50 Hz) and is locally accurate (no jumps) but drifts over time. map → odom is published by SLAM at lower rate (on loop closure) and corrects the accumulated drift — but it can jump discontinuously when a loop closure fires. By keeping them as separate edges, any node that cannot tolerate discontinuous pose jumps (like the velocity controller) can consume odom → base_link directly. Any node that needs globally consistent pose (like the planner) can consume map → base_link, which is composed through both edges. This is a standard ROS 2 REP-105 convention — not arbitrary naming.

Here is the URDF snippet that generates the static transforms for FollowBot's sensor frames. These become the gold edges in the tree above, published automatically by robot_state_publisher:

followbot.urdf.xacroURDF · sensor frame definitions
<!-- LIDAR frame: 18 cm above base_link, centered, 0° rotation -->
<joint name="laser_joint" type="fixed">
  <parent link="base_link"/>
  <child  link="laser"/>
  <origin xyz="0 0 0.18" rpy="0 0 0"/>
</joint>

<!-- Camera link: 5 cm forward, 22 cm up, -5° pitch to aim slightly down -->
<joint name="camera_joint" type="fixed">
  <parent link="base_link"/>
  <child  link="camera_link"/>
  <!-- rpy: -5° pitch = -0.0873 rad, so person's legs appear in frame -->
  <origin xyz="0.05 0 0.22" rpy="0 -0.0873 0"/>
</joint>

<!-- Depth optical frame: RealSense SDK convention (x right, y down, z forward) -->
<joint name="camera_depth_joint" type="fixed">
  <parent link="camera_link"/>
  <child  link="camera_depth_frame"/>
  <!-- optical convention: rotate -90° roll, -90° yaw from NED camera_link -->
  <origin xyz="0 0 0" rpy="-1.5708 0 -1.5708"/>
</joint>

The type="fixed" joint is the URDF mechanism that tells robot_state_publisher to treat this as a static transform. A type="revolute" or type="continuous" joint generates a dynamic transform keyed to the joint's current position, which must be published on the /joint_states topic. This is how the 6-DOF arm's TF edges will work in Stage 2.

⚠ The camera_depth_frame optical rotation is not optional

The RealSense D435 (and most depth cameras) uses a coordinate convention where Z points forward, X points right, and Y points down — the standard computer vision optical frame. ROS 2 convention has X forward, Y left, Z up. The rpy="-1.5708 0 -1.5708" rotation in the URDF handles this conversion. If you omit it, point clouds expressed in camera_depth_frame will appear rotated 90° in RViz and SLAM will silently receive geometrically wrong observations. This is one of the most common silent TF errors in the wild.

WEAKNESSWhere TF2 bites hardest

✗ Catching TF2 exceptions and continuing

The standard pattern that appears in tutorials and GitHub repos: wrap lookupTransform in a try/except, log a warning, and return or use a cached transform. This suppresses the symptom while hiding the cause. The correct response to an ExtrapolationException is to investigate processing lag; to a LookupException, to verify the broadcaster is running; to a ConnectivityException, to check the tree structure with ros2 run tf2_tools view_frames. Returning a cached transform when TF2 cannot provide a fresh one is not recovery — it is silent degradation. The robot will continue operating on stale geometry and produce wrong behavior that looks like an algorithm problem.

✗ Publishing transforms at the wrong rate

Dynamic transforms must be published faster than they are consumed. If the odometry node publishes odom → base_link at 10 Hz but the LIDAR perception node runs at 10 Hz and requests a transform at each scan timestamp, the timing becomes tight — under any jitter, the requested timestamp falls between two buffered entries that are 100 ms apart. Interpolation still works, but with worse accuracy. If the broadcaster rate drops below the consumer rate (e.g., the odometry node is blocked), every lookup starts throwing ExtrapolationException. The rule of thumb: broadcast dynamic transforms at 2–5× the rate of the fastest consumer. For FollowBot, 50 Hz odometry serving 10 Hz LIDAR is an adequate margin.

✗ Multiple broadcasters for the same parent–child pair

If two nodes both publish odom → base_link, the buffer receives transforms from both. The listener has no way to know which is authoritative — it uses whichever arrives last. The result is a transform that flickers between two sources, producing random interpolation errors. In simulation with Gazebo this happens frequently: the Gazebo plugin publishes ground-truth odometry to /tf, and a separate odometry integration node also publishes to the same edge. The robot appears to jitter randomly. Fix: ensure exactly one node owns each transform edge, enforced by launch file design.

KEY INSIGHTHow this connects

  • Coordinate Frames and Homogeneous Transforms (1.2) — TF2 is the runtime implementation of the homogeneous transform mathematics from 1.2. The 4×4 matrix that TF2 composes across the tree is exactly the SE(3) transform chain introduced there. If the math felt abstract, TF2 is where it becomes concrete and consequential.
  • ROS 2 Architecture: Nodes, Topics, Services, and Actions (1.4) — TF2 runs on top of the /tf and /tf_static topics introduced in 1.4. The QoS distinction between transient_local (/tf_static) and volatile (/tf) is a direct application of the QoS policies from that lesson. Late-joiner behavior and the "missed message" failure mode both trace to topic QoS settings.
  • Next: Sensors: Physics, Noise Models, and Failure Modes (1.6) — every sensor topic consumed in the course carries a frame_id that references the TF tree built in this lesson. The LIDAR scan's frame_id="laser" is meaningless without a correct base_link → laser transform. Sensor noise models are applied in sensor-local frames and then projected to map frame through TF2.

TF2 is one of those systems where the cost of a wrong mental model is paid gradually and invisibly. The algorithms you will build in Stage 4 (EKF, particle filter) and Stage 5 (SLAM, point cloud registration) all call lookupTransform internally — often dozens of times per second. A subtly misconfigured TF tree produces algorithm behavior that looks like numerical instability, sensor failure, or implementation bugs. The correct diagnostic question is always: before I blame the algorithm, is the TF tree correct?

GLOSSARYKey terms introduced

TF2 (Transform Library 2)
ROS 2's distributed transform library. Maintains a time-indexed tree of coordinate frame transforms. Each listener node holds its own in-process buffer populated by subscribing to /tf and /tf_static. Provides lookupTransform() for querying the buffered tree.
TransformBuffer
The in-memory data structure maintained by each tf2_ros.TransformListener. Stores the last cache_time seconds of dynamic transforms (default 10 s) and all static transforms indefinitely. lookupTransform() queries this buffer, not a network service.
StaticTransformBroadcaster
A broadcaster that publishes to /tf_static with transient_local QoS (latched). Published once; held in every listener's buffer forever. Use for mechanically fixed transforms (LIDAR mounting, camera pose). Misusing it for dynamic transforms causes silent stale-transform errors.
ExtrapolationException
Raised when the requested timestamp falls outside the buffered range for any edge in the source-to-target chain. Most commonly caused by processing lag exceeding cache_time under CPU load. Also triggered by future timestamps from clock drift in distributed systems.
LookupException
Raised when a frame ID referenced in the lookup chain does not exist in the buffer. Indicates the broadcaster for that frame has not started, has crashed, or was never implemented. Debug with ros2 run tf2_tools view_frames.
ConnectivityException
Raised when no path exists in the transform tree connecting the source and target frames. Indicates a disconnected tree — a frame's parent has not been published, creating an island. Often caused by a missing robot_state_publisher or a URDF link with no associated joint.
REP-105
ROS Enhancement Proposal 105: the standard convention for mobile robot coordinate frames. Defines the map → odom → base_link hierarchy, the semantics of each frame (map = globally consistent but may jump; odom = locally consistent, drifts; base_link = robot body), and the expected frame IDs for sensors. FollowBot follows REP-105 exactly.
cache_time
The duration for which dynamic transforms are retained in the TransformBuffer. Default 10 seconds. Setting it too small causes ExtrapolationException under processing load. Setting it too large increases memory use and makes stale-transform bugs harder to detect.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1Why does TF2 raise ExtrapolationException instead of returning its best extrapolated guess when the requested timestamp is too old?›

TF2 does not extrapolate because even short extrapolations can produce large positional errors for rotating systems. A robot turning at 1 rad/s that extrapolates 100 ms beyond its last known transform will have a heading error of 0.1 rad (~5.7°). At 0.5 m from the sensor, that translates to nearly 5 cm of positional error per single extrapolated transform — and the chain may have three or four edges, each extrapolated. Rather than return a number that looks plausible but could be far wrong, TF2 raises the exception and forces the calling code to handle the failure explicitly. The caller can then decide to skip the scan, wait for a fresh transform, or apply domain-specific recovery logic. This is the correct engineering contract: the algorithm must know when its input data is unreliable.

2FollowBot's SLAM node fires loop closures every 5–10 seconds, causing map → odom to jump discontinuously. The velocity controller is consuming cmd_vel and does not want to see jumps. How does the two-edge TF tree (map → odom → base_link) solve this?›

The velocity controller consumes transforms through only the odom → base_link edge — it plans motions relative to the odometry frame, which is locally consistent and never jumps. The SLAM jump propagates only through the map → odom edge, which no controller-level node queries. The path planner, which works in the map frame, does query through both edges and does see the correction — but this is appropriate because the planner is producing long-horizon goals where global consistency matters more than local smoothness. The two-edge design decouples the globally-consistent but potentially-jumping map frame from the locally-smooth odometry frame. This is precisely the semantic contract defined in REP-105 and is the main reason the convention exists.

3A node starts late and immediately calls lookupTransform('map', 'laser', rclpy.time.Time()). It gets a LookupException for the 'odom' frame. The odom broadcaster has been running for 30 seconds. What most likely caused this?›

The most likely cause is that /tf uses volatile QoS (not transient_local). A late-joining subscriber receives no historical messages — only messages published after it subscribed. Since 30 seconds of odom transforms have already been published, the late node's buffer is empty and the frame is unknown. The fix is not to change /tf to transient_local (that would flood late joiners with 30 seconds of buffered data) — instead, the node should add a small wait or retry loop after initializing its TransformListener, allowing time for the first few transforms to arrive (~0.1–0.5 s is usually sufficient). Alternatively, use buffer.wait_for_transform() with a timeout rather than calling lookupTransform() immediately. This is distinct from static transforms, which use transient_local and are received immediately on subscribe.

4You publish the odom → base_link transform using StaticTransformBroadcaster instead of TransformBroadcaster by mistake. The robot runs for 30 seconds. Describe precisely what will happen and why no exception is thrown.›

The transform is published once at startup, with the robot's initial position (0, 0, 0°). It is stored in every listener's buffer forever under /tf_static. As the robot drives, no new transform is published. Every call to lookupTransform for any chain through odom → base_link returns the startup-time transform — the robot appears to be at its initial position in the odometry frame, regardless of how far it has actually moved. No exception is thrown because the transform exists in the buffer and its timestamp is valid (static transforms are treated as valid for all times). The SLAM node would report the robot at its starting pose indefinitely; the planner would send commands based on a ghost position. The symptom looks like "the odometry is broken" or "the robot is not moving according to sensors" — a slow-to-diagnose silent failure, detectable only by comparing the TF tree output to actual wheel encoder readings.

Next: sensors — where the data that TF2 transforms actually comes from →