Self Driving and ROS 2 - Learn by Doing! Map & Localization

Install ROS 2 Jazzy on Ubuntu 24.04 using the provided commands and environment setup, then verify the installation and explore visualization tools like RVs.

Install ROS 2 Humble on Ubuntu 22.04 by copying commands, choosing Amble for 22 or Jazzy for 24, and setting up the desktop version and ROS developer tools.

Configure a complete development environment for ROS 2 projects using Visual Studio Code, rosdep, and a bumper bot workspace; install extensions, Terminator terminal, and Python packages such as transforms3d.

Verify the simulated bumper bot runs in Gazebo, control it with a joystick, visualize odometry and TF transforms in RViz, and reproduce the workspace setup for map and localization.

Access up-to-date, tested robotics code on GitHub organized by section to follow labs, copy or compare code, and use debugging strategies and community resources to solve issues.

Discover how the robot operating system unifies diverse modules, enabling autonomous navigation, obstacle avoidance, and object manipulation by reusing widely tested software components.

Explore how ROS 2 streamlines hardware interfaces and enables cross-robot code reuse by managing drivers and communication, illustrating why it is described as an operating system for robotics.

Explore why a new ROS version was needed, addressing ROS1 limitations in wireless networks, real-time control, and security, and how ROS 2 enables multi-robot fleets and broader applications.

Explore the ROS 2 architecture, including the rmw middleware, rcl core, and rds-based communication, and see how RQL CPP library and RQL Py library enable C++, Python, and Java development.

Explore hardware abstraction in ROS, comparing it to a PC operating system, and see how a standard interface manages sensors and motors for application developers.

Drivers enable ROS 2 to manage and control devices by implementing a standard interface between hardware and software, including cameras.

Learn how ros2 nodes communicate via topics, services, and actions, enabling publishers and subscribers to exchange messages, and clients and servers to perform and monitor tasks.

Package management organizes robot code into interacting packages, enabling modularity and maintainability. Divide functionalities into focused packages to enable reusing navigation and mapping across robots, like from mobile to drone.

Learn how to create your first ROS 2 package and application, and explore the underlay and overlay workspace structure. Understand how packages override and how startup files configure the robot.

Create and activate a ros2 workspace, organize packages under a source folder, build with colcon, and source setup.bash to recognize the bumper bot workspace in ros2.

Develop a ros2 python publisher node with rclpy to publish string messages on the chapter topic at 1 hertz, illustrating the publisher-subscriber workflow.

Develop a first ros 2 c++ node using a publisher to send string messages on the chatter topic, driven by a one-hertz timer in the bumper bot cpp workspace.

Learn to implement a Python ROS 2 simple subscriber node that subscribes to the chatter topic, handles string messages with a callback, and demonstrates cross-language ROS 2 communication.

Create a simple ros 2 c++ subscriber node that subscribes to the chatter topic with string messages, using rclcpp, a callback, and a publisher-subscriber demonstration with a python publisher.

Explore why statistics and probability matter in robotics amid environmental uncertainty from dynamic obstacles and sensor noise, and learn probabilistic localization with sensor fusion.

Explore the random variable as the core of probability theory, using coins and dice to illustrate outcomes, probabilities, and multiplying probabilities for independent events.

Explore conditional probability and dependent events through robot localization and rock detection, using random variables and joint probability via conditional probabilities.

Explore probability distributions, from uniform starts to the sums of two dice, and learn to compute mean, variance, and standard deviation for robust map and localization in robotics.

Explore Gaussian distributions, or normal distributions, and learn how the mean and standard deviation shape the bell curve, symmetry, and uncertainty, while combining Gaussians yields new Gaussian distributions.

Use the total probability theorem to estimate robot position in a park by combining detections from B1, B2, and B3 to compute the probability of being on the path A.

Apply Bayes rule to update the robot's location as new sensor observations reduce localization uncertainty. Define prior, posterior, likelihood, and marginal probabilities to explain how new evidence updates estimates.

Explore probability theory to solve real-world localization problems by understanding sensor noise, its intrinsic and system-related causes, and how robust localization algorithms mitigate noisy measurements.

Learn how localization and map-based reasoning enable self-driving systems to identify your position after a jump, track movements in Barcelona, and reliably return to the starting point.

Robot localization defines a robot's pose and orientation in a reference frame, expressed as x, y and theta on a 2D plane, or x, y, z in 3D space.

Learn how shared reference frames enable localization by fixing the map frame, the odom frame, and the base_link, linked through a continuous transformation.

Establish a shared convention for reference frames in open source robotics to enable heterogeneous systems to communicate localization data, integrating navigation, perception, and human interaction.

Explore how Gazebo worlds and models create rich 3d environments to test localization and mapping algorithms, adding realistic scenes, objects, and humans to simulate real-world conditions.

Learn to load Gazebo environments such as the small house and small warehouse and run mapping and localization tests for a robot using prepared models and launch scripts.

Breaks down the robotics localization problem by representing it with map, odom, and base_link frames and decomposing transforms. Clarifies local and global localization by solving the map-to-odom and odom-to-base_link transforms.

Explore local localization and odometry to estimate the robot's pose and velocity relative to the Odom frame, via transformation to the base link and wheel encoder data, incorporating sensor fusion.

Global localization computes the transform from the map to the base link frame using a known odom frame transform, contrasting with local localization.

Discuss how wheel odometry errors affect robot localization over time, including radius misestimation and wheel slip, and why odometry alone (even with sensor fusion) can mislead.

Explore how laser odometry uses successive laser scans to estimate robot movement, aligning readings to derive the transformation between p0 and p1, and revealing velocity amid environmental uncertainty.

Global localization uses a map to correct odometry errors and improve overall robot localization by integrating global information with local sensors.

Adopt a probabilistic approach, treating the robot pose as a random variable shaped by odometry noise and use a motion model with x_t and x_{t-1} to predict position and uncertainty.

Derive the odometry motion model by decomposing movement into a rotation, translation, and rotation, each affected by zero-mean noise with alpha1–alpha4, linking noisy estimates to true pose.

Develop a gaussian noise odometry model by computing rotation and translation variances with alpha coefficients, then sample particles to estimate noise-free motion and update orientation via quaternion from Euler.

Learn to model odometry with zero-mean Gaussian noise whose variance depends on alpha one through alpha four, and generate particles that represent possible robot poses in ROS 2.

Explore testing the odometry motion model in a gazebo simulation, visualizing 300 particles in rviz and observing how alpha1–alpha4 parameters shape rotation and translation noise.

Learn how odometry errors affect localization and how global localization uses maps to correct them. Compare map representations, from 2d occupancy grids to topological graphs, and weigh accuracy against compute.

Explore how robots perceive the world using sensors to build maps; map type guides localization, with camera and laser shaping 2D and 3D representations.

Explore how mono dimensional sonar, bidimensional, and 3D sensors shape a self-driving robot's perception and localization. Understand their outputs, the physics behind operation, and each sensor's environments, advantages, and limitations.

See how ultrasonic sensors, or sonar, measure distance to obstacles with time of flight. Use a transmitter and receiver, and humidity and surface properties affect accuracy.

LiDAR revolutionizes indoor mobile robotics by scanning the entire environment with light beams, measuring distance to obstacles via time-of-flight, and providing bidimensional distance and angle data for 360° scans.

Simulate a 2D lidar in Gazebo by configuring a 360-beam lidar with range, field of view, and Gaussian noise in bumper bot URDF, publishing scans to ROS 2 scan topic.

Explore how rgbd cameras and 3d lidar emit multi-plane light to build a 3d point cloud, conveying distance and horizontal and vertical angles.

Use the 2D LiDAR to sense obstacles and implement a speed and separation monitoring node that slows in yellow zones and stops in red zones using ROS 2 twist mux.

Master the twist mux in ros2 for managing multiple velocity sources with priority and timeouts, using lock and turbo features to support speed and separation monitoring.

Develop a Python twist relay node in ros2 that converts twist stamped messages to twist messages and vice versa, and manage publishers and subscribers across joystick and bumper bot controller.

Develop C++ twist relay node that converts twist messages to twist stamped messages and back, enabling integration with twist mux and joystick interface using publishers and subscribers in ROS 2.

Configure and launch the twist mux in a bumper bot controller setup, integrating joystick teleop, twist relay, and yaml configuration files for topics, locks, and turbo interface.

Explore twist_mux with twist mocks in a gazebo ROS 2 simulation, validating joystick and keyboard teleop, and testing safety stop, lock, priority control, and turbo actions to adjust max velocity.

Create a ros2 python safety stop node in bumper bot utils package that subscribes to 2d lidar scan and publishes safety stop boolean when an obstacle is within danger distance.

Develop a ros2 c++ safety stop node that halts the robot when a LiDAR laser scan detects a nearby obstacle, using danger distance and topic parameters.

Launch and test the safety stop node in a ROS 2 Gazebo simulation to prevent collisions, verify operation via the safety stop topic, and preview a warning zone.

Discover how ROS 2 actions coordinate long-running tasks with goal, feedback, and result messages between an action client and server, including cancel when conditions change.

Build a Python ROS 2 action server that computes the Fibonacci sequence using a custom Fibonacci.action interface with goal, feedback, and result.

Start a ros2 action server that computes the fibonacci sequence via C++ or Python, send goals, receive progress feedback, and obtain the full result up to the requested order.

Build a Python ROS 2 action client for the Fibonacci action server, sending a ten-order goal and handling feedback and final result via callbacks.

Learn to implement a C++ ROS 2 action client that talks to a fibonacci action server, including setup, waiting for the server, sending goals, and callbacks.

Demonstrate cross-language communication in ros 2 by starting a python-based action server and a c++ action client, sending goals, receiving feedback, and returning the complete fibonacci sequence.

Implement speed and separation monitoring in a ROS 2 safety stop node, using twist mux turbo actions to slow in the warning zone and stop in the danger zone.

Implement speed and separation monitoring in the safety stop node using ros2 action clients to slow down at 0.6 m and stop at 0.2 m, via the twist turbo interface.

Explore speed and separation monitoring in a simulated ROS 2 setup. The safety stop node slows and stops the bumper bot as obstacle distance drops.

Visualize safety zones in rviz using marker arrays and visualization messages, displaying warning and danger zones around the bumper bot and aligning markers with the laser scan frame.

A safety stop node slows and stops the robot before a collision and visualizes yellow warning and red danger zones in RViz using a marker array.

Visualize the safety stop node in RViz using zone markers and laser scan visualization. See how obstacle presence affects marker colors and triggers robot stopping in danger zones.

Explore map representations in robotics, including topological, occupancy grid, and detailed three-dimensional maps, and how sensor choice and accuracy trade off with localization and planning in ROS 2.

Topological maps discretize space into discrete nodes connected by edges, enabling localization, navigation, and path planning; identify the current node using beacons or visual markers such as Aruco or Apriltag.

Explore two dimensional occupancy grids in ROS to model environments with occupied, free, and unknown cells, illustrating map resolution, cell probabilities, and memory efficient vector storage for localization and planning.

Explore how 3D occupancy grids use voxels to discretize space and trade detail for memory. See how octo tree in Octo map subdivides space into free, occupied, or unknown regions.

Explore how Nav2 enables autonomous navigation with localization, mapping, path planning, obstacle avoidance, and recovery behaviors, using Mapserver to publish occupancy grids.

Explore ros2 lifecycle nodes that manage a driver and application through unconfigured, inactive, active, and finalized states, with configure, activate, deactivate, cleanup, and shutdown transitions.

Create a simple ros 2 lifecycle node in python that subscribes to a topic, prints the lifecycle state and messages only when active, and provides a starting template.

Create a simple ros2 life cycle node in c++, subscribe to a topic, and display the current state and messages in the terminal when active using a template lifecycle node.

Learn to manage a simple ROS 2 life cycle node using the lifecycle CLI to view state, list transitions, and activate transitions from unconfigured to active, enabling chatter topic communication.

Discover how nav2 map_server hosts an occupancy grid in ros2, publishing on a topic and offering map and load map services as a lifecycle node activated via configure and activate.

Load and publish an occupancy grid map with the nav2 map_server in ros2, enabling visualization in rviz and use by localization, planning, and obstacle avoidance.

Explore how the quality of service policies in DDS-based ROS 2 communication govern map data delivery and reveal why publisher-subscriber QoS mismatches block message transmission.

Develop two Python ROS 2 nodes—a publisher and a subscriber—and experiment with two quality of service policies to see how mismatched reliability and durability settings block communication.

Explore ROS 2 quality of service by building two simple C++ nodes—a publisher and a subscriber—and observe how mismatched reliability and durability policies can block message transmission.

Explore a simple ROS 2 QoS publisher and subscriber, experimenting with reliability and durability policies to observe incompatibilities and learn how matching QoS enables communication.

Configure and activate the ros2 map_server lifecycle, load the small house map, and visualize the occupancy grid in rviz, while tuning qos durability to transient local to receive all messages.

Explore how ROS 2 lifecycle nodes use a state machine to configure and activate, and how the lifecycle manager coordinates startup, activation, and recovery of multiple navigation components.

Use Nav2 lifecycle manager to automatically configure and start the map server and localization nodes via a launch file, with auto start and sim time settings.

Create occupancy grid maps for autonomous navigation using known poses, odometry, and lidar scans. Use these maps to enable robot localization, path planning, and obstacle avoidance.

Treat each cell as a probability and update the occupancy grid with odometry and 2d lidar scans to maximize the likely map of free, occupied, or unknown cells despite noise.

Develop and publish an empty occupancy grid map using a Python ROS2 node, marking the robot's odometry pose and setting up obstacle and free-cell mapping for future lessons.

Develop a basic ros2 c++ node that publishes an empty occupancy grid from lidar readings and odometry, then marks the robot trajectory as occupied cells on the map for visualization.

Publish an occupancy grid for ROS 2, showing robot’s current position marked in black in the map, visualized in RViz, with 50 m by 50 m and 0.1 m resolution.

Understand the laser scan message structure, convert distances and angles to cartesian coordinates, and transform them into the map frame using tx, ty, and phi for occupancy grid mapping.

Builds on the mapping lesson to mark obstacles detected by lidar on the occupancy grid, converting laser readings to map coordinates and marking cells as 100 while skipping infinite readings.

Modify the mapping node to mark obstacle positions detected by lidar on the occupancy grid. Convert laser scans from polar to odom-frame Cartesian coordinates using tf2, then mark occupied cells.

Publish an occupancy grid map from mapping with known poses, using laser scans to mark obstacles as black and reveal the evolving map in the gazebo simulation.

Explain how a laser model populates an occupancy grid by marking occupied cells where obstacles reflect the laser and free cells within the lidar view, including unknown areas.

Map the environment with a laser model that marks occupied and free cells, visualize scans and maps, and explore with known poses, using Bresenham lines toward probabilistic occupancy grids.

Learn to build a probabilistic occupancy grid by fusing multiple lidar scans across robot poses with Bayes theorem, using log odds notation for clarity and accuracy.

Implement probabilistic occupancy grid in Python by converting between probability and log odds, updating a probability map with prior and occupancy and free probabilities from the sensor model for visualization.

Implement a probabilistic occupancy grid in C++ by converting probabilities to log odds, updating a probability map, and publishing an occupancy grid for map localization.

Launch a simulated robot to build a probabilistic occupancy grid, where each cell stores an occupancy probability from laser scans. Observe gradual updates, reduced flicker, and free versus occupied areas.

Learn to localize a robot on a known occupancy grid map by fusing lidar readings, odometry, and sensor data to correct drift and estimate the position x_t over time.

Combine odometry, lidar readings, and a map for map-based localization along the x axis, using an initial Gaussian pose, state prediction, and measurement update to sharpen the robot's position.

Explore single and multiple hypothesis localization for map-based robot positioning, using odometry and lidar with gaussian distributions, and learn how Markov localization tracks multiple pose hypotheses.

Explore how Markov localization localizes a robot on an occupancy grid from an unknown pose by tracking multiple hypotheses and updating gaussian distributions with sensor and odometry data.

Explore randomized sampling for Markov localization in robotics to solve global localization on occupancy grids, sampling a subset of poses to balance computation with completeness amid odometry and sensor noise.

Monte Carlo localization uses a particle filter for global localization of autonomous robots. It updates particle weights with sensor readings and moves particles with odometry, then resamples to converge.

Explore monte carlo localization with adaptive monte carlo localization (amcl) in ros2, using nafcu amcl to solve global localization on an occupancy grid from lidar, odometry, and a static map.

Launch the simulation and localize the robot on a map using odometry and laser scans. Observe particle cloud and map in Arviz visualization, with resampling and recovery alpha enabling relocalization.

Explore simultaneous localization and mapping (slam) by combining odometry and lidar readings to build an occupancy grid and locate the robot in real time.

Discover why slam integrates mapping with odometry and lidar to correct drift, instead of relying on mapping with known poses or known maps alone.

Explore how tiny odometry errors, such as a misestimated wheel radius, degrade mapping with known poses and produce misaligned walls in rviz during simulation.

Practice solving the chicken and egg problem of slam by iteratively using the partial map to refine robot pose and, in turn, use localization to improve the map.

Explore particle filter slam, where each particle holds its own occupancy grid map and pose, updated by localization and mapping steps with odometry and resampling.

Use the extended Kalman filter to fuse odometry and sensor data for map building and robot localization, starting from an initial guess with covariance and applying data association.

Graph slam uses a graph of robot poses and landmarks, connecting nodes with odometry and sensor measurements to optimize the robot's trajectory and map while accounting for noise.

Demonstrate graph slam with front end and back end: front end adds pose and landmarks from odometry and lidar, while back end optimizes graph via data association and loop closure.

Explore graph slam for accurate simultaneous localization and mapping, using 2D lidar to create occupancy grid maps and localize the robot, while supporting landmarks and lifelong mapping with slam toolbox.

Learn to use slam_toolbox with ros 2 to map a large warehouse, handle odometry errors, close loops, and save the map for amcl localization.

Launch all functionalities of the simulated robot with a single ros2 launch file, dynamically choosing localization with amcl or mapping with slam toolbox.