Getting a robot to drive itself does not start with a planner or a costmap. It starts metres behind them — with a LiDAR SLAM backend that produces a trustworthy pose and a usable map at a frame rate your single-board computer (SBC) can actually sustain. Too many 2026 indoor-AGV builds pick a backend first and a processor second, then spend weeks fighting CPU stalls or dropped costmap updates. This is a selection and bring-up guide: how to match a LiDAR SLAM backend to your sensor and SBC compute budget, wire the resulting odometry and map into Nav2 on ROS 2 Jazzy, and absorb what changed in the Nav2 1.5 (Lyrical) era, which reshaped plugin interfaces and moved path handling out of individual controllers. It is the practical companion to the earlier piece on mecanum-wheel robot design with ROS 2, which covered the drive side of the same platform.
Why the choice changed in 2026
Two things changed this year and should inform your decision. First, the LiDAR-inertial odometry front-ends once confined to research drones now run comfortably on Jetson-class hardware: FAST-LIO, Point-LIO, DLIO, and graph-based options such as RTAB-Map all have published evidence of real-time operation on embedded or ARM-class compute. Second, the navigation stack moved to Nav2 1.5 for ROS 2 Lyrical Luth, which Open Navigation announced on 25 August 2026 as one of the broadest Nav2 releases in several distributions. Lyrical introduced a nav2_ros_common abstraction layer that every custom plugin must migrate to, a centralized PathHandler in the controller server, major MPPI upgrades, an adaptive goal checker, pause-and-resume behavior trees, and a substantially faster inflation layer.
The bring-up fundamentals below are identical on Jazzy and Lyrical; the migration notes near the end apply specifically when you port an existing Jazzy/Kilted build to the Lyrical era, which is where the interface changes bite.
Why a LiDAR SLAM backend is the right first decision
A SLAM backend does two jobs at once. It produces localization — a pose estimate published continuously — and a map that Nav2’s planners and costmaps consume. If those jobs fight for CPU on a constrained SBC, everything downstream (costmap updates, planner time, controller bandwidth) degrades.
For an indoor AGV that already carries an IMU and a LiDAR, a LiDAR-inertial odometry (LIO) backend is the natural fit: it fuses LiDAR features with IMU data in a tightly-coupled filter. FAST-LIO, its maintainers state, is a computationally efficient, robust LiDAR-inertial odometry package that fuses LiDAR feature points with IMU data using an iterated extended Kalman filter for navigation in fast-motion, noisy, or cluttered environments. The IMU fills the gaps between LiDAR frames and deskews scans for better maps, and the EKF keeps the estimate smooth when one sensor momentarily degenerates. That fusion matters far more on a slow indoor vehicle than raw odometry rate: you are rarely bandwidth-starved at 0.4 m/s, but very often tripwire-starved in a feature-poor corridor.
Matching the backend to sensor and compute budget
The candidates below cover the realistic corners of the design space for a Jetson-class SBC. Use the table as a first-pass filter, then read the notes before committing.
| LIO backend | Sensor needs | Compute cost | Best for |
|---|---|---|---|
| FAST-LIO / FAST-LIO 2 | Mechanical-spin (Velodyne, Ouster) or solid-state (Livox) LiDAR + IMU; raw points accepted | Low–moderate; real-time on low-power ARM-class computers | General indoor AGV with a budget IMU; the default |
| Point-LIO | Solid-state LiDAR with per-point timestamps + IMU | Low–moderate; real-time on low-power ARM | Fast/high-vibration platforms, IMU saturation |
| DLIO | Spinning LiDAR (e.g. Hesai) + IMU; multiple combos supported | Low (lightweight by design); coarse-to-fine continuous time | Embedded builds wanting precision-per-watt |
| RTAB-Map | LiDAR (2D/3D) and/or RGB-D + optional IMU; graph-based | Low–moderate; loop-closure graph spikes on large maps | Long-duration loop closure, map hand-off |
FAST-LIO / FAST-LIO 2 — the pragmatic default
FAST-LIO 2 (from the HKU-MARS group; the ethz-asl/fast_lio repository is a maintained fork of hku-mars/FAST_LIO) builds an incremental map with an ikd-Tree, which its authors credit for sustaining over 100 Hz LiDAR rates. It performs direct scan-to-map odometry on raw points, so feature extraction can be disabled. Crucially, it supports mechanical-spin LiDARs (Velodyne, Ouster) and solid-state units (Livox Avia, Horizon, MID-70) without per-LiDAR feature tuning. For a slow indoor AGV whose limiting factor is filter stability and CPU headroom rather than point rate, FAST-LIO is the defensible default: it gives Nav2 a clean odometry feed and a good map while leaving CPU for everything downstream.
Point-LIO — only if you are actually fast or vibrating
Point-LIO performs a point-by-point state update at each point’s true sampling time instead of accumulating frames. Its paper reports odometry output around 4–8 kHz, no in-frame motion distortion, and robustness to aggressive motion — angular velocities beyond 75 rad/s and IMU saturation. That is real, but aimed at aerial platforms with violent motion. For a ground AGV cruising under a metre per second it is oversubscribed: you pay for high-bandwidth machinery you do not need. One caveat: it wants per-point LiDAR timestamps (the livox_ros_driver/CustomMsg structure on Livox). Keep Point-LIO in reserve and skip it for the standard indoor AGV.
DLIO — the lightweight alternative
DLIO (ETH Zürich legged robotics) is a lightweight LiDAR-inertial odometry algorithm from ICRA 2023, built around a coarse-to-fine approach to continuous-time trajectory construction for precise motion correction. Its design language is explicitly a small compute footprint, and its demo payload pairs a STIM IMU with a Hesai XT-32. Its trajectory-based motion correction yields clean deskewed clouds (/dlio/deskewed_point_cloud) that costmap and perception layers can reuse. If your SBC sits at the very low end and you want a leaner LIO than the full FAST-LIO stack, DLIO is a strong candidate.
RTAB-Map — when loop closure is the requirement
RTAB-Map takes an appearance- and graph-based route and organically handles long-duration operation where a robot must revisit places and keep a globally consistent map. Its graph optimizer spikes on loop-closure events, so on a constrained SBC expect occasional CPU bursts, not a steady predictable load — budget for the peak. If the AGV must run continuously in the same warehouse, hand maps off between sessions, and reuse a prebuilt map, RTAB-Map’s loop closure earns its keep. For single-session, small-footprint indoor runs, the lighter LIO front-ends are cheaper to keep real-time.
Wiring the SLAM front-end into Nav2
Once the backend publishes /odom and a map, the path to autonomy is the standard Nav2 bring-up — the structure the Nav2 First-Time Robot Setup Guide lays out in order:
- Transformations first. Nav2 lives or dies by TF2. Install the static transforms between
base_link, the LiDAR frame, and the IMU frame, and publish theodom→base_linklink the backend will drive. - Odometry. Export the LIO pose as
nav_msgs/Odometry. If you run wheel encoders too, fuse them with the IMU viarobot_localizationso the planner sees a smoothodom→base_linkrather than encoder jitter. - Sensor sources. Publish a point cloud the costmap can inscribe. Since the LIO already fuses the IMU, no separate scan-based odometry is needed — but keep the raw cloud available for AMCL if you later localize against a saved map.
- Footprint. Define the real footprint (
footprintorrobot_radiusplus inscribed/circumscribed radii) so inflation and goal checking use correct geometry. An optimistic footprint is the classic cause of “should have cleared that door frame” failures. - Costmap and map. Either build the map at bring-up with a SLAM layer, or save a map from the LIO and serve it as a static layer with a live obstacle layer on top — the production pattern, since you stop re-running scan-to-map alignment during normal navigation.
- Planners and controllers. Select the global planner (NavFn/Theta* for a slow AGV) and a local controller — MPPI is the modern default, DWB the simpler fallback — and define the motion model explicitly.
The lifecycle of these nodes is managed through Nav2’s lifecycle-manager brings-up, which is also where you consolidate bond-heartbeat settings in the Lyrical era (below).
Configure Nav2 1.5: the controller server now owns the path
The most impactful 2026 change for controller configuration is that the controller server now owns the global path. Before Lyrical, every controller plugin pruned and transformed the path on its own, each slightly differently — which, per the migration notes, caused a real bug where NavigateThroughPoses could stop early when the robot passed close to an intermediate pose. Lyrical moves that into a single PathHandler in the controller server:
controller_server:
ros__parameters:
PathHandler:
plugin: "nav2_controller::FeasiblePathHandler"
prune_distance: 2.0
enforce_path_inversion: true
enforce_path_rotation: false
inversion_xy_tolerance: 0.2
inversion_yaw_tolerance: 0.4
minimum_rotation_angle: 0.785
reject_unit_path: false
For a slow indoor AGV, prune_distance dominates behaviour: it sets how far “far sight” sits ahead before replanning. Set it a little larger than your worst-case stopping distance to stop the robot oscillating around the pruned horizon. Path-inversion settings matter for a symmetric AGV: enforce_path_inversion: true lets the controller consider inverted paths rather than forcing a spin to back out of a dead end.
Because the controller server owns the path now, per-controller path parameters were removed. Per the migration guide, DWB loses prune_plan, prune_distance, forward_prune_distance, shorten_transformed_plan, transform_tolerance; Regulated Pure Pursuit and Graceful lose transform_tolerance and max_robot_pose_search_dist; MPPI loses those plus prune_distance and the path-inversion settings, all now in the PathHandler. Delete stale parameters before the config will validate.
MPPI parameters that matter for a slow indoor AGV
MPPI samples thousands of candidate control sequences, simulates each with a motion model, and blends them by cost. On a slow, often mecanum-drive AGV the failure mode is rarely “not enough bandwidth” and almost always “the simulated motion model disagrees with the real motors.” Lyrical targets exactly that with four changes to exploit:
- Name the motion model explicitly. Motion models became plugins and must be named even for the default:
FollowPath:
plugin: "nav2_mppi_controller::MPPIController"
motion_model: "diff_drive"
diff_drive:
plugin: "mppi::DiffDriveMotionModel" # or OmniMotionModel, AckermannMotionModel
- Asymmetric acceleration limits. A slow indoor AGV lives near zero velocity and rarely needs symmetric limits. Set asymmetric
max_*_accelerationvalues so the controller commands aggressive braking (safe floor-space stopping) but gentle forward acceleration (protects the load). This is the single biggest quality-of-life setting for an indoor shuttle. - Per-axis delay compensation. If motors or steering respond slowly (hydraulic steering, or a heavy mecanum drivetrain), measured velocity lags commanded velocity and the controller oscillates around the path. The new
model_delay_vx,model_delay_vy,model_delay_wzparameters (seconds, default 0 = off) let the optimizer replay commands sent but not yet enacted. Pair them withopen_loop: true, which starts each optimization from the last command rather than from odometry — right for laggy wheel odometry. - Trajectory validity and per-critic visualization. The
OptimalTrajectoryValidatorplugin checks the chosen trajectory before execution and can be extended to enforce obstacle margins or progress. Meanwhile per-critic cost visualization makes tuning beyond guesswork — use it to see which critic punishes a corner-cutting behavior.
Goal checking for a tight-precision AGV
Lyrical added an adaptive tolerance goal checker for the classic indoor-AGV symptom: the robot gets within a few centimetres of the goal, then crawls or wiggles because it is not inside a fixed tolerance. It uses two tolerances — inside the fine one the goal is reached immediately; inside the coarse one the goal is reached if the robot’s linear and angular speed stay below a threshold for a set number of cycles, the distance to the goal stops improving, or the robot crosses a “finish line” through the goal perpendicular to its entry. Tight precision when achievable, without stalls when it is not.
For docking bays and aisles, AxisGoalChecker is more useful: it measures error along the path and across it separately (along_path_tolerance and cross_track_tolerance, both 0.25 m by default), since sideways precision often matters more than forward precision at a dock. And for a front-back symmetric robot, the new symmetric yaw tolerance accepts the goal facing either way instead of forcing a 180° spin. Pair these with Lyrical’s pause-and-resume behavior-tree nodes (PauseResumeController, plus PersistentSequence and NonblockingSequence) to build missions that suspend mid-run and resume from the correct step.
The free CPU: inflation layer and bond heartbeat
Two 2026 changes return compute with no behavioural trade-off:
- Rewritten inflation layer. The queue-based cell loop became a Felzenszwalb–Huttenlocher distance transform parallelized with OpenMP when built with it (single-threaded fallback otherwise); large maps benefit most, exactly the profile of a vehicle driving the same floor daily. Asymmetric inflation is available, and a
custom_inscribed_radiusexists, but the Nav2 docs flag the latter as a potential safety issue, so keep the footprint-derived default. - Bond heartbeat. The default
bond_heartbeat_periodon lifecycle nodes went from 0.1 s to 0.25 s; the migration guide reports composed Nav2 CPU dropping from roughly 140% to 100% of a core after removing a pinned 0.1 s value — meaningful headroom on an SBC. If you pin it, delete it and let the default stand. Combined withuse_intra_process_comms:=truefor zero-copy between composed nodes, this is the cheapest performance you can buy.
2026 migration notes: Jazzy/Kilted to Lyrical
If you built on Jazzy and are porting forward, the interface changes are concentrated and knowable:
- Lifecycle node and factories.
nav2_util::LifecycleNodebecomesnav2::LifecycleNode, and itscreate_*factories returnnav2::wrappers (nav2::Publisher,nav2::Subscription,nav2::ServiceClient,nav2::SimpleActionServer) instead of rawrclcpptypes. This is thenav2_ros_commonlayer — one place to control QoS, service/action introspection, and future lifecycle-aware subscriptions across the stack. - QoS is the last argument and usually optional. QoS moved to the end and defaults to
nav2::qos::StandardTopicQoS(reliable, volatile, depth 10). Socreate_publisher<nav_msgs::msg::Path>("plan", 1)becomescreate_publisher<nav_msgs::msg::Path>("plan"). Prefernav2::qosprofiles overrclcppones and, per the docs, avoidSystemDefaultsQoS. Action clients also shorten tocreate_action_client<ClientT>("navigate_to_pose", callback_group_). - Service server signatures. Callbacks now take an
rmw_request_id_theader, sostd::bindneeds three placeholders instead of two — a subtle, easy-to-miss break. - Controller and goal-checker interfaces.
setPlan()becomesnewPathReceived(), doing only light state-reset work, andcomputeVelocityCommands()now receives the transformed global plan and global goal. Custom goal checkers gain atransformed_global_planargument inisGoalReached(). RPP’s stateful parameter moved into the goal checker via a newisGoalXYReachedAPI. - Behavior-tree renames. Three nodes became actions with new names because they can return RUNNING and should not sit in a tree ticked at 100 Hz:
IsStopped→CheckStopStatus,IsPathValid→ValidatePath,IsPoseOccupied→CheckPoseOccupancy. Update BT XML or the tree silently fails to load. - Removed parameters.
action_server_result_timeoutwas removed from all action servers — delete it from YAML. Custom docking plugins must implementstartDetectionProcessandstopDetectionProcess(return true if unused).
These are mechanical, testable changes. None silently corrupts runtime behavior if you address them during the port.
A proven bring-up order for the SBC build
- Validate the LIO backend on the SBC first. Run FAST-LIO or DLIO on your Jetson against a recorded bag and watch CPU and odometry latency before wiring Nav2 — if the backend cannot hold real-time on the actual hardware, no tuning fixes it.
- Publish correct TF. Confirm
odom→base_linkfrom the backend and the staticbase_link→lidar/imutransforms sample as expected. Wrong transforms are the number-one silent cause of a control stack fighting itself. - Set up the costmap with a static map (from the LIO) plus a live obstacle layer; tune footprint and inflation once.
- Configure the
PathHandler, delete stale per-controller path parameters, and setprune_distancefrom real braking distance. - Name the MPPI motion model, set asymmetric accel limits, add delay compensation if motors lag, and enable per-critic visualization to tune weights with evidence.
- Choose the goal checker — adaptive for general navigation,
AxisGoalCheckerfor docking, symmetric yaw tolerance if the AGV is symmetric. - Take the free performance — the new inflation transform with OpenMP, the 0.25 s bond heartbeat, and intra-process comms for composed nodes.
- If porting from Jazzy to Lyrical, run the migration checklist against every custom plugin and BT XML before the port lands.
The decision in one paragraph
For a quiet, slow, indoor wheeled AGV on a Jetson-class SBC, the well-worn path is: FAST-LIO 2 for odometry and mapping (real-time on ARM, tolerant of both mechanical-spin and solid-state LiDARs), a static map served to Nav2 with a live obstacle layer, MPPI with an explicitly named diff_drive motion model, asymmetric acceleration limits, and delay compensation if the drivetrain lags, and the adaptive or axis goal checker for general navigation or docking respectively. Reach for Point-LIO only if the platform is fast or vibration-prone, DLIO if you want the leanest real-time LIO, and RTAB-Map if long-duration loop closure and map hand-off are hard requirements. Bring up the backend in isolation first, then wire transforms, odometry, costmap, and controller in that order — and run the Lyrical migration checklist explicitly when you cross from Jazzy to the 1.5 era.
Sources
- Open Navigation. Nav2 Lyrical Release & Key Features! ROS Discourse, 25 Aug 2026. discourse.ros.org/t/nav2-lyrical-release-key-features/57666
- RoboCloud Hub (D. Menon). Nav2 Lyrical Release: What’s New and How to Migrate from Kilted, Sep 2026. robocloudhub.tech/learn/blog/nav2-lyrical-release-migration-2026
- Nav2 Documentation. First-Time Robot Setup Guide. docs.nav2.org/rolling/configuration_and_development/first_time_robot_setup_guide/
- ETH Zürich ASL. FAST-LIO. github.com/ethz-asl/fast_lio
- ETH Zürich Legged Robotics. DLIO. github.com/leggedrobotics/dlio
- HKU MARS. Point-LIO: Robust High-Bandwidth LiDAR-Inertial Odometry. github.com/hku-mars/Point-LIO
Hardware used in this guide
- 2D LiDAR sensor on Amazon.in
- NVIDIA Jetson Orin Nano Super Developer Kit on Amazon.in
- MPU6050 IMU module on Amazon.in
Links open search results on Amazon.in. As an Amazon Associate we earn from qualifying purchases.
