Mapping & Navigation

Launch SLAM Toolbox in online asynchronous mode:

ros2 launch my_bot online_async_launch.py use_sim_time:=false  # real robot
# ros2 launch my_bot online_async_launch.py use_sim_time:=true  # simulation

Online asynchronous mode processes lidar scans and odometry in real time, continuously building the occupancy grid. “Async” means scan processing is not frame-locked to the sensor rate — the node stays responsive under variable system load.

Leave this running. It subscribes to /scan and the robot’s TF tree, and publishes the growing map to /map.

rviz2

Configure the display:

1. Set Fixed Frame to map
2. Add → TF and Add → RobotModel (set Description Topic to /robot_description)
3. Add → By Topic → /map (Map display)
4. Add → By Topic → /scan (LaserScan display)

The map expands in the viewport as the robot moves.

Install teleop_twist_keyboard if not already present:

sudo apt install ros-humble-teleop-twist-keyboard

Inside the Docker container, elevated privileges are already available — sudo may be omitted if unavailable.

Launch teleop:

ros2 run teleop_twist_keyboard teleop_twist_keyboard

Click the terminal to focus it, then drive the robot through the space. SLAM fills in walls and free space in real time wherever the lidar scans. Regions the robot has not passed near remain unknown (grey) on the map.

Drive every area you want represented in the final map. Unvisited regions will not appear.

Explore Lite implements frontier-based exploration: it identifies boundaries between mapped and unknown space, selects the nearest reachable frontier, and dispatches a Nav2 goal to drive toward it. As each frontier is reached, SLAM expands the map and new frontiers emerge further out. The cycle continues until no reachable frontiers remain.

This section requires four terminals (real robot) or five terminals (simulation). Start each layer in sequence and wait for it to fully initialize before proceeding.

Simulation Setup

Physical robot users: Skip to Terminal 1 — Start SLAM.

Launch the simulation environment as described in Simulation Setup — Launch the Environment. Leave this terminal running.

Terminal 1 — Start SLAM

# Real robot
ros2 launch slam_toolbox online_async_launch.py \
  params_file:=$(ros2 pkg prefix my_bot)/share/my_bot/config/mapper_params_online_async.yaml \
  use_sim_time:=false
 
# Simulation — wait ~5 s after the world is up, then run with use_sim_time:=true

SLAM Toolbox starts publishing the live occupancy grid to /map.

Terminal 2 — Start Nav2

Wait ~5 seconds after SLAM is running, then:

# Real robot
ros2 launch nav2_bringup navigation_launch.py \
  params_file:=$(ros2 pkg prefix my_bot)/share/my_bot/config/nav2_params.yaml \
  use_sim_time:=false
 
# Simulation (uses a separate params file)
# ros2 launch nav2_bringup navigation_launch.py \
#   params_file:=$(ros2 pkg prefix my_bot)/share/my_bot/config/nav2_params_sim.yaml \
#   use_sim_time:=true

This brings up the full Nav2 stack — global and local costmaps, planner, and controller. Explore Lite sends goal poses through Nav2, so Nav2 must be fully active before starting exploration.

Terminal 3 — Open RViz

Wait ~15 seconds after Nav2 starts, then:

rviz2 -d /opt/ros/humble/share/nav2_bringup/rviz/nav2_default_view.rviz
# Simulation: append --ros-args -p use_sim_time:=true

This opens RViz with Nav2’s default layout (map, costmaps, robot model, navigation displays). Watch the map grow as Explore Lite drives the robot.

This terminal only requires the base ROS 2 environment sourced — workspace sourcing is not needed since no my_bot packages are loaded here.

Terminal 4 — Start Explore Lite

Once the robot and an initial partial map are visible in RViz:

ros2 run explore_lite explore --ros-args \
  --params-file $(ros2 pkg prefix explore_lite)/share/explore_lite/config/params.yaml \
  -p costmap_topic:=/global_costmap/costmap \
  -p costmap_updates_topic:=/global_costmap/costmap_updates \
  -p min_frontier_size:=0.5 \
  -p return_to_init:=false \
  -p use_sim_time:=false   # change to true for simulation

Parameter notes:

• costmap_topic / costmap_updates_topic — Explore Lite’s defaults do not match Nav2’s published topic names; these overrides are required.
• min_frontier_size:=0.5 — suppresses noise-level frontier segments, preventing the robot from pursuing map artifacts.
• return_to_init:=false — the robot remains at its final position when exploration ends rather than returning to its start pose.

The robot begins navigating autonomously. In RViz, observe it select a frontier, drive toward it, and the map expand with each traversal. Exploration concludes automatically when no reachable frontiers remain.

Save the Map

Once exploration completes (or at any satisfactory coverage point), save the map using the same command documented in Save the Map above.

Step 1 — Set the Initial Pose

The robot has the map but does not yet know its position on it. An initial pose estimate is required before sending any navigation goals.

In RViz2, click 2D Pose Estimate in the toolbar, click the robot’s actual location on the map, and drag in the direction it is facing. Release to confirm.

AMCL’s particle cloud will converge around the estimated pose. If the robot model is visibly offset from the map geometry, re-estimate from a more accurate position.

An accurate initial pose is critical. An incorrect estimate causes the robot’s planned paths to be offset from the actual environment, leading to navigation failures.

Step 2 — Send a Navigation Goal

Click Navigation2 Goal in the RViz2 toolbar, click the target location on the map, and drag to set the arrival orientation. Release to confirm.

Nav2 will:

1. Plan a collision-free global path using the static map and costmap
2. Execute the path via the local controller, sending velocity commands to the robot
3. Re-plan continuously if the robot deviates or a new obstacle is detected

The planned path appears as a line in RViz2. A new goal can be sent at any time; the active goal is immediately cancelled and a fresh path is computed.

Goal unreachable? Nav2 will time out if the goal is inside a wall, too close to an obstacle, or in an unmapped region. Select a point in open, mapped space.

Obstacle Avoidance

Monitor the interaction between the Global Path (the long-term planned route) and the Local Costmap (the small colored grid that moves with the robot):

• Local Costmap — updates in real time from live lidar data, capturing obstacles not present in the saved map.
• Dynamic re-planning — when a new obstacle is detected ahead, the local planner re-routes around it automatically. The robot decelerates, computes a new local trajectory, and continues toward the goal.

Cancel or Redirect

• Change destination: Click Navigation2 Goal and select a new point. The current goal is cancelled immediately and a new path is planned.
• Stop the robot: Click Cancel in the Navigation2 panel on the left side of RViz2.
• Recovery behaviors: If the path is fully blocked, Nav2 executes recovery behaviors (e.g., in-place rotation, short reverse) to clear the costmap. If no path can be found after all attempts, the goal is cancelled and a failure is reported.