Self Driving and ROS 2 - Learn by Doing! Plan & Navigation

Install ROS 2 Jazzy on Ubuntu 24.04 by following the official installation steps, enabling repositories, installing dependencies, and configuring the environment to verify with ros2 help.

Install ROS 2 humble on Ubuntu 22.04 by following commands to set up sources, install the desktop package with RViz, and configure the environment via bashrc.

Verify gazebo simulation runs, move the simulated robot with keyboard or joystick, and create a map using slam; build and source the workspace, then launch and test localization in rviz.

Use the GitHub repository to follow the ROS 2 lab material, run bumper bot examples, and debug by comparing Python and C++ publisher and subscriber code.

Discover how a robot operating system unifies modules to enable autonomous navigation, obstacle avoidance, and object manipulation, and trace ROS to ROS 2 with open-source reuse across industry and research.

Ros2 manages drivers and hardware interfaces, letting a module work across different robots with cameras and motors. Learn why Ros2 is described as an operating system for robotics.

Explore the Ros 2 architecture, from the middleware and the Ros client library core to language bindings, and how RDS implementations enable robust inter-node communication.

Understand low-level device control in ros 2 by examining drivers that connect hardware to the operating system, enabling camera data to be sent and retrieved via a standard interface.

Learn how ros 2 enables inter-node communication via topics, services, and actions, with publishers, subscribers, servers, clients, and navigation goals sent to action servers.

Organize robot software into packages to improve reusability, maintainability, and modularity. Each package focuses on a single functionality, enabling navigation and mapping reuse across robots in ROS 2.

Develop a ROS 2 package and a rescue application, and learn how underlay and overlay workspaces manage standard and new packages, scripts, and startup configurations for node execution.

Create and activate a ros2 workspace with python and cpp packages. Build with colcon to produce build, install, and log folders, then source setup.bash and verify with ros2 package list.

Implement a simple ros2 subscriber in python using rclpy to subscribe to the chapter topic, print string messages via a callback, and compare with the Cplusplus subscriber.

Learn how planning and execution work together for autonomous navigation, using a planner to map routes and an executor to follow the plan while reacting to dynamic obstacles.

Represent the environment as a two-dimensional workspace and inflate obstacles by the robot's footprint to form the configuration space, enabling the planner to compute collision-free paths for a point robot.

Discretize the configuration space to transform the continuous path planning problem into a graph of vertices and edges with weights that encode costs like time, distance, or fuel.

Explore visibility graph, Voronoi diagrams, and cell decomposition to turn a map into a path-planning graph. Compare safety margins, graph size, and alignment with occupancy grids in ROS 2.

Explore occupancy grids for indoor robot mapping, localization, and path planning in ROS 2, using 0/100/-1 values and 1D vector storage.

Visualize a real map in ros2 using the mapserver from navigation2, publishing occupancy grids to enable localization, path planning, and obstacle avoidance with lifecycle nodes.

Create a ros2 lifecycle node in python that subscribes to a topic and prints the current state and messages when active, as a starter template in bumper bot pi examples.

Create a simple ros 2 c++ life cycle node that subscribes to the chapter topic and prints its state and messages only when active, as a reusable template.

Use the ros2 lifecycle cli to view node state, apply transitions from unconfigured to configured and active, publish to the chatter topic, and shut down the node cleanly.

Explore how the map_server, a life cycle node, hosts an occupancy grid for path planning and localization by loading maps from disk and exposing map and load map services.

Configure and run the nav2 map_server to load a yaml map file, publish an occupancy grid on the map topic, and visualize it with arviz.

Demonstrate how ROS 2 uses DDS and quality of service policies to govern publisher and subscriber communication, explore RCL and multi-language interfaces, and diagnose QoS incompatibilities affecting map data flow.

Learn to implement a ROS 2 publisher and subscriber in C++ with configurable QoS policies, including reliability and durability, and observe mismatches that block message transmission.

Master the nav2 map_server lifecycle and quality of service settings to visualize the occupancy grid in RViz, adjusting durability to receive past map messages.

Learn how breadth-first search uses a queue to explore nodes level by level, finding a path with the fewest nodes, and when it may not yield the optimal cost.

Explore depth-first search by using a stack to visit nodes in last-in, first-out order, starting from the initial node and noting it may not yield the best or fewest-node path.

Explain how the Dijkstra algorithm finds the shortest path from A to I using a cost-priority queue that reorders by traversal cost.

Develop a ROS 2 Python node that ingests a map, current pose, and destination pose to compute a path with the Dijkstra planner.

Develop a ros2 c++ dijkstra planner node that ingests an occupancy grid map and current and destination poses, computes a path, and publishes the path and visited map for visualization.

Develop the Dijkstra planner in C++ for ROS 2, representing graph nodes with coordinates and costs, using a priority queue to compute the shortest grid path and reconstruct the route.

See how the Dijkstra planner computes a shortest obstacle-free path from the robot’s current position to a chosen goal in ros2. Visualize the visited map and the path in rviz.

Explain how the A* algorithm speeds up path planning by using a heuristic, often Euclidean or Manhattan distance, with edge costs in a priority queue, noting no guaranteed global optima.

Implement a star path planner in Python for a grid-based occupancy map, using a priority queue with cost plus Manhattan distance heuristic to reach the goal.

Implement an A* planner in C++ for an occupancy grid, adapting the Dijkstra planner, using a heuristic Manhattan distance to guide from the robot start pose to the goal.

Run the A* planner in simulation to compute a collision-free path from the robot to the goal, using a heuristic and visualizing the path and visited cells on cost map.

Plan and execute mobile robots autonomously by using fast, reactive motion planners (inner loop) that dodge dynamic obstacles, while an outer loop replans to update maps in real time.

Track a planner path with a PID-based path tracker that computes x, y, and orientation errors to generate forward and rotational velocity commands, iterating until the destination is reached.

Develop a Python ROS 2 PD motion planner in the bumper bot motion package to drive the robot along a star path using pid control and velocity commands.

Develop a c++ ros2 pd motion planner node that subscribes to a path, uses tf2 to get the current pose, computes velocity commands, and publishes commands and next pose visualizations.

Demonstrates the PD motion planner using the A-star path and robot pose, transforming the global plan from the map frame to autumn frame to compute pose error and velocity commands.

Explore how reference frames define the origin and how a robot determines its pose (x, y, theta) on a two-dimensional plane to solve localization.

Adopt a global map frame, an odom frame at the robot's initial position, and a movable base_link; compute their continuous transformation to solve localization.

Establish a shared convention for reference frames in robot localization to enable open-source navigation and perception systems to collaborate, aligning coordinates across heterogeneous software.

Compute the two-dimensional translational component of robot pose by projecting x and y, then obtain the obstacle's world coordinates by adding the robot-to-world translation vector t.

Combine translation and rotation into the homogeneous transformation matrix to map coordinates from the robot frame to the world frame in two dimensions, enabling world coordinates of obstacles.

Learn how transformation matrices encode position and orientation and how composing and inverting them across map, odom, and base link frames enables robust localization.

Transform the global plan into the robot frame using TF2 tools and transformation matrices, converting rotations with quaternions and translations for all path poses.

Transform the global plan from map to autumn frame in the PD motion planner using tf2, then transform all poses to guide the robot.

Implement a Python PD motion planner that computes the next path pose, derives linear and angular errors, and outputs velocity commands within limits to reach the goal.

Explore how model predictive control (MPC) and MPPI use a detailed robot model to predict trajectories, optimize command sequences with a cost function, and send only first command before replanning.

Implement the pure pursuit controller to track a path using a lookahead distance, including obstacle avoidance, then compute the arc and curvature to command steering and velocity.

Develop a python node that implements the pure pursuit algorithm to follow the A* path, using a 0.5 m lookahead and velocity limits, reusing the PD motion planner.

Explore pure pursuit motion planning in a ROS 2 simulation by pairing an A-star path planner with a pure pursuit controller and visualizing 2D goal poses.

Discover how footprint inflation and cost maps enable reliable obstacle avoidance in autonomous navigation, addressing static maps, dynamic obstacles, and safe motion planning.

Costmaps fuse sensor data into a 2d occupancy grid that marks obstacles, inflates them for safety, and can encode semantic zones to guide path planning and autonomous navigation.

Integrate static maps and sensor data into a layered 2D cost map, using plugins to add dynamic obstacles, inflate margins, and finally merge layers for path planning and motion planning.

Configure the static layer to read the map topic and convert the occupancy grid into a ghost map with 0 to 255 values for autonomous navigation and localization.

Configure a ros 2 nav2 cost map 2d static layer using a yaml file in the bumper boat navigation package, loading the static map and publishing the occupancy grid.

Explore the obstacle layer of a layered costmap, translating 2d lidar and rgb-d or 3d lidar data into occupied cells and free space via ray tracing, including Bresenham.

Configure and activate the obstacle layer in nav2 costmap 2d to convert 2d lidar laser scans into dynamic obstacles on the costmap.

Learn how the inflation layer expands obstacle costs in a layered costmap, modeling the robot’s footprint with exponential decay within the inflation radius to guide safer, lower-cost paths.

Configure the inflation layer as the last layer in nav2_costmap_2d to inflate static and laser-detected obstacles, using an inflation radius of 0.55 m and a cost scaling factor of 3.0.

Leverage the costmap to plan paths that account for dynamic obstacles, environmental changes, and the robot's footprint, achieving safer, context-aware navigation.

Adapt the Dijkstra costmap planner to use a cost map (occupancy grid) instead of a static map, enabling cost-aware path planning that avoids obstacles.

Configure the Nav2 planner and controller servers with plugins for path and motion planning, enabling autonomous, obstacle-avoiding navigation using cost maps and ros2 actions.

Explore ROS 2 actions as a long-running, goal-oriented communication protocol with action server and client, including goal, feedback, result, and cancel, illustrated by a robot navigating to a detected human.

Implement a simple C++ action server for ROS 2 that computes the Fibonacci sequence using a Fibonacci action interface with goal, feedback, and result.

Create a Python action client in ROS 2 that talks to the fibonacci action server using bumper bot pi examples and rclpy, sending goals and handling feedback and results.

Create a C++ action client in ROS 2 to communicate with a Fibonacci action server, implementing goal, feedback, and result callbacks with rclcpp and bumper bot messages.

Launch the action server and client in Python and C++ to show ROS 2 goal handling, feedback, and results with a Fibonacci sequence.

Explore how the Nav2 planner uses a ROS2 action interface and plugins to plan from the robot’s position to a destination, using a global cost map and publishing the path.

Configure the nav2 planner server with a planar server yaml. Load planner plugins, configure the global cost map with static, obstacle, and inflation layers, and compute path actions.

Transform a plain ROS 2 dijkstra planner into a nav2 global planner plugin by configuring and using the planner server cost map and create_plan.

Develop a Dijkstra planner plugin for Nav2 in ROS2, exporting via plugin lib and XML, and integrate with the global planner to load at runtime.

Load the Dijkstra planner via the grid based plugin and start the Nav2 planner server, then visualize the global cost map and enable switching to A* by the planner field.

Export the a star planner as a nav2 global planner plugin, register it with plugin lib and XML, and build the library for dynamic loading by the planner server.

Load and compare two planner plugins, Dijkstra and A-star, in the planner server, configure via YAML, and visualize their paths in RViz using ros2 actions.

Load multiple path planning plugins into the Nav2 smoother server, send goals to compute trajectories, and apply plugin-based smoothing algorithms to produce a smoother path for motion.

Configure and start the ros2 nav2 smoother server with a yaml file, loading the simple smoother plugin and tuning tolerance, max iterations, and refinement for path smoothing.

Modify Dijkstra planner to use a router server for smoothing. Initialize a nav2 smooth path action client, set a three-second timeout, send the path, and update with the smoothed result.

Compute a path with the Dijkstra planner and smooth it with the smoother server to produce a neat, followable trajectory for a robot in a ROS 2 Gazebo simulation.

Learn how the Nav2 controller server uses plugin-based motion planners and ros2 actions to follow paths, with tf2 localization and local cost maps to publish velocity commands for autonomous navigation.

Configure and run nav2 controller server with a yaml file to load controller plugins and goal and progress checkers alongside a three by three meter local costmap for robust navigation.

Convert the C++ PD motion planner into a ros2 nav2 controller plugin, implementing configure, set plan, set speed limit, and compute velocity commands for twist stamped outputs.

Export the PD Motion Planner as a nav2 core controller plugin using plugin lib and a motion planner plugins XML. Build the workspace to verify compilation and plugin loading.

Configure and load the PD motion planner plugin in the nav2 controller YAML, then launch the planner, router, and controller servers to execute a compute path to follow path workflow.

Convert the pure pursuit motion planner into a Nav2 core controller plugin by inheriting from the controller and implementing configure, activate, deactivate, and compute velocity commands.

Export and install the pure pursuit nav2 controller plugin by mirroring the PD motion planner steps, configure the XML, build the library, and load the plugin into the controller server.

Configure the Nav2 controller to load the pure pursuit plugin, set look at distance, maximum linear velocity, and maximum angular velocity, then simulate in Gazebo and follow the path.

Explore how lifecycle nodes use a deterministic state machine to configure and activate, and how the lifecycle manager orchestrates multiple nodes in startup order, keeping them active.

Launch all navigation lifecycle nodes—controller, planner, and smoother—with a single ros 2 launch file and the Neptune lifecycle manager, using config files and runtime arguments.

Explore how behavior trees help robots plan, navigate, and execute complex tasks by composing simple actions into modular, reusable strategies, demonstrated through grabbing a beer from a refrigerator.

Explore how behavior trees express complex logic by composing action, control, condition, and decorator nodes. Learn how nodes form leaves, manage execution order, and enable modular, robust robot behavior.

Learn how a behaviour tree uses tick signals to drive actions, propagate through sequence and fallback nodes, and manage running, success, and failure states for robust robot control.

Learn how behavior trees use ports to receive input and provide output between nodes and share results via a blackboard, enabling cross-node communication for plan and navigation.

Configure and launch the bt navigator in ros 2, set ros parameters, frames, timeouts, and behavior trees, and drive the robot with navigate to pose actions.

Create a behavior tree with Groot to compute a path to a pose and execute it, using a sequence and nav2 nodes via the blackboard.

Learn to use a behavior tree to control robot navigation with nav2, including starting the BT navigator, configuring lifecycle management, and triggering plan and follow path stages.

Switch to Nav2 smac planner and regulated pure pursuit controller to boost path planning speed, obstacle avoidance, and robustness of autonomous navigation.

Analyze how the Nrf2 server stack enables autonomous navigation with bit navigator and nav two behaviors, combining path planning, smoothing, and follow-path control to reach a target pose.

Configure the nav2 behavior server with a YAML file to load spin, backup, and wait plugins, set local cost map and footprint topics, cycle frequency, and run actions in simulation.

Enhance navigate-to-pose performance by adding a recovery node to the behavior tree, with a recovery sequence of spin, wait, and backup actions for a single retry and replanning.

Configure a Raspberry Pi 4 to serve as the robot's brain, enabling ros2 jazzy or humble, ssh, static IP, and bluetooth to manage wheel actuation, sensors, and arduino integration.

Install ROS 2 on a Raspberry Pi with Ubuntu 24, selecting Jazzy or Humble, enable ROS repositories, initialize rosdep, install dependencies, and build the bumper bot workspace.

Assemble the robot in a hands-on hardware lab, part 1, to prepare for self-driving and ROS 2 navigation projects.

Assemble the robot in a hands-on lab, building core self-driving systems with ROS 2. Develop plan and navigation skills through practical part 2 assembly tasks.

Participate in hands-on robot assembly as part of the plan and navigation learning track, advancing through part 3 of the hardware lab series.

Assemble the robot in hardware lab part 4, practicing hands-on construction to support self-driving and navigation with ROS 2.

Set and align ros domain ids across devices to enable bidirectional ros2 communication over the same network, using topic pub/echo and bashrc exports for consistent topic visibility.

Upload the Arduino firmware to the real robot, install the PID library, and configure the Raspberry Pi with udev rules; then teleoperate using ROS via a PS4 joystick or keyboard.

Launch all functionalities on the real robot to map the environment, localize within the map, and autonomously navigate using the planner, controller, and behavior tree.

Explore planning and navigation for self-driving robots by learning path planning, graph traversal, and motion control. Apply behavior trees with Groot to handle unpredictable events and achieve autonomous navigation.

Explore self-driving and ROS 2 through a learn-by-doing series on plan and navigation, with modules on odometry, control, mapping, and localization, plus manipulator and ROS-based projects.