ROS 2 for Beginners (ROS Jazzy - 2026)

Identify the appropriate ros 2 distribution by checking the official docs, understanding eol and lts status, and choosing the latest stable lts; this course uses jazzy with ubuntu 24.04.

Install Ubuntu 24.04 on a virtual machine using VirtualBox, download the Ubuntu ISO and VirtualBox, configure RAM and CPUs, install Ubuntu, update packages, and enable guest additions and shared clipboard.

learn how to set up ROS development on Ubuntu using Terminator terminal multiplexing, VS Code with ROS extension and CMake, plus Jedit for editing.

Install ros2 jazzy on Ubuntu 24.04 by adding ros sources, ensuring utf-8 locale, and selecting the desktop install, then update and upgrade packages, with optional dev tools and autoremove cleanup.

Learn how to set up your ROS 2 environment by sourcing the setup.bash script from the jazzy distribution and auto-sourcing it in bashrc for every terminal.

Launch a ros 2 program using ready-made demos, run talker and listener in two terminals, and verify the environment by observing hello world messages.

Create a ROS 2 workspace for the roster app, then build and source it. Organize src, build, install, and log folders and update bashrc with the workspace setup.

Create a python package inside a ros2 workspace, organize code into reusable packages, and configure dependencies like rclpy and rcl using ros2 pkg create.

Create a ROS 2 C++ package in your workspace with ros2 pkg create using element_cmake, add a rcl cpp dependency, and review the include, source, and cmakelists.txt and package.xml files.

Learn how ros 2 nodes, organized into packages, communicate through topics, services, and parameters, enabling scalable, fault-tolerant robot apps built from Python and C++ components.

Create a minimal Python ROS 2 node, install and run it, initialize rclpy, create and log from a node, and keep it alive with spin.

Develop a ros2 python node using object oriented programming by defining a class that inherits from the node class, initializes with super, and adds a timer to log every second.

Write a minimal ros2 c++ node, initialize ros2, create a shared rclcpp node, log a hello world message, then build, source the workspace, and run the executable with ros2 run.

Build an object oriented ros 2 c++ node by creating a my node class that inherits from the base node, then add a one second timer callback.

Explore how ros 2 client libraries sit atop the base rcl core library and enable cross-language communication via the ros 2 middleware ds, including clp and rcl cpp bindings.

Learn to introspect ros2 nodes using the ros2 cli, including ros2 run, ros2 node list, and ros2 node info, with autocompletion and workspace sourcing.

Rename a node at runtime in ROS 2 using --ros-args and --remap (or -R) to assign a new node name and avoid name conflicts when launching multiple sensors.

Learn to build your ros 2 workspace with Chalcone using colcon, build the workspace or packages, and use --symlink-install for Python node iterations—beware of bugs and not for production.

Learn to use rqt_graph, a graphical introspection tool for ROS 2, to visualize running nodes, topics, and inter-node communications, helping you debug and spot mistakes quickly.

Explore a 2D robot simulation with turtlesim in ROS 2, launch turtle sim nodes, control the turtle via teleop key, and observe cmd_vel topic communication in a graph view.

Launch four ros2 nodes (python, c plus plus, turtle sim with teleop) and rename them via remapping to custom pi and donatello to match the cut graph view, validating communication.

Explore how ROS 2 topics enable data streams by connecting publishers and subscribers through named topics, with consistent message types and flexible node communication.

Create a python ros2 publisher by building a node with a string publisher on a topic, using a timer to publish twice per second.

Create a python subscriber node in ROS 2 that subscribes to a topic with a string message, using a callback to process incoming data and demonstrate publisher-subscriber communication.

Write a C++ publisher in ROS 2 by creating the Robot News Station node that publishes example interfaces string messages to a topic twice per second.

Build a ros2 c++ subscriber node in smartphone.cpp to subscribe to robot news topic using example interfaces msg string, and print messages via callback. Test with python and c++ publishers.

Explore how to introspect ros 2 topics using command line tools, including listing topics, viewing topic info, echoing messages, checking frequency and bandwidth, and publishing for hands-on verification.

Remap a topic at runtime using ros args to rename a node and topic, aligning publishers and subscribers across different names.

Monitor ros topics with rqt_graph to visualize publishers and subscribers across multiple nodes. Verify topic alignment and explore how renaming nodes and topics at runtime creates dynamic configurations.

Explore topic communication in ROS 2 using turtlesim and a 2D robot simulation, mastering teleop control and publishers and subscribers for the cmdvel topic that moves the turtle.

Create a Python number publisher node that publishes int64 data on the number topic every second, building a two-step ROS 2 data pipeline and validating with ros2 tools.

Create a second ROS 2 node that subscribes to the number topic, accumulates received values into a counter, and publishes the result on a new number count topic.

Record and replay ros2 bag data to test robot behavior offline, saving topic data such as number count and number, inspecting bag metadata, and replaying with precise timing.

Discover how a ros2 service implements a client-server model with request and response messages, supporting synchronous or asynchronous calls via a service name.

Create a Python ros2 service server using the add to ints interface, processing requests and returning a sum via a callback and logging. Test with a ros2 service call.

Learn to build a Python service client without object oriented programming to call a ROS 2 service, wait for the server, and test any service with a reusable template.

Create a ros2 node that uses object oriented programming to build a service client for adding two ints. Send requests asynchronously and handle responses with a future callback using partial.

Learn to build a C++ ROS 2 service server that sums two integer requests using example interfaces, a callback, std::bind, and a Python client for cross-language testing.

Learn to build a basic C++ ROS 2 service client without object-oriented programming, including creating a node, awaiting a service, sending an asynchronous request, and handling the response.

Implement a C++ ROS 2 service client inside an existing node using object oriented programming, create and call the service, and handle responses with a callback while the node runs.

Learn to introspect ros2 services with the command line, list and inspect services, their types, and interfaces, and call them from the terminal or with a graphical tool.

Remap a service at runtime in ROS 2 using -r to rename the old service to ABC. Update both server and client to the new name to keep communication.

Explore ros2 services with turtlesim, learn to list services, use clear to erase traces, spawn new turtles, and kill to remove them.

Add a ROS 2 service server using the set bool interface to reset a counter to zero. The callback handles true/false data, returning success and a message.

Explore how ROS 2 interfaces define topics and services through message and service definitions, and how the build system generates language-specific code for C++ and Python.

Create a dedicated ROS 2 interfaces package, define hardware status.msg with temperature, ready, and debug fields, then build, source the workspace, and verify the interface with ros2 interface show.

Use a custom message in a Python ros 2 node by creating a hardware status publisher, importing the interface, and publishing timed messages with fields like temperature and ready.

Create and build custom ros 2 services by defining a compute rectangle area in a my robot interfaces package, with float64 requests and a float area response.

learn how to use the ros2 command line to introspect interfaces, list and show package interfaces, and inspect topics and services for your running nodes.

Publish an LED panel state using a custom LED state array message in a ROS 2 LED panel node, then implement a Python service server and a timer-driven update workflow.

Learn how to build a ROS 2 service server to set an LED state via a new set_led service, including validation, response handling, and immediate state publishing.

Create a ROS 2 battery node that simulates full and empty states with a timer and uses a set LED service to drive the LED panel.

Understand ros2 parameters as runtime configuration values for nodes; declare them, set at startup with ros2 run, enabling diverse node instances.

Learn to declare and retrieve parameters in a Python ROS 2 node, set default values, and override them at runtime using ros2 args and parameter names.

Learn to declare and retrieve parameters in a c++ ros 2 node, set defaults, and use them to configure a timer and the published number at runtime.

Experiment with turtlesim to practice ros 2 parameters, learn command line tools like ros2 params and ros2 get, and read and set node parameters via services.

Explain how to save and load node parameters using YAML files with ros__parameters, enabling multiple parameters and configurations for several nodes loaded at runtime from a single file.

Learn to parameterize a robot news station node in ROS 2, declaring and retrieving the robot name at runtime, and overriding parameters via the command line for multiple nodes.

Configure a LED panel node in ROS 2 using a list of integers to set initial LED states, validate values, and load settings from YAML via ros args and parameters.

Learn how ROS 2 parameter callbacks work, including get/set operations and a post set parameters callback that updates node state in a Python/C++ number publisher.

A ROS 2 launch file centralizes node startup, parameters, remappings, and YAML loading to quickly launch multiple camera and robot nodes from a single file, enabling scalable, error-free initialization.

Create a dedicated ros 2 launch package, set up a launch folder, and write an xml launch file to start multiple nodes with exec_depend dependencies.

Explains xml versus python launch files in ros 2, demonstrates creating a python launch file and including it in xml, and argues xml for simplicity.

Learn to rename nodes and remap topics and services in ROS 2 launch files, using xml and python syntax with name and remap tags, then verify with ros2 launch.

Learn to set node parameters in a ROS 2 launch file and load them from a YAML within the myrobot bringup package, using param tags, names, and values.

Explore adding namespaces to ROS 2 nodes and launch files, using remapping with __ns, the role of leading slashes, and how namespaces isolate topics across multiple robots.

Orchestrate several ros2 nodes via a launch xml, rename nodes, set parameters, and load them from a yaml config to reproduce the activity's robot news station.

Launch the total sim with three ROS 2 nodes to control the main turtle. Spawn and remove other turtles, and catch each new turtle before moving to the next.

Use a Python ROS 2 node to control a turtle in turtle sim by publishing to cmd_vel and subscribing to pose, with a 100 Hz loop and a P controller.

Learn to build a ROS 2 turtle spawner node using the turtle sim spawn service to spawn named turtles at random x, y, theta with a timer.

Connect the turtle spawner and controller in ROS 2 by publishing a live turtles list (name, x, y, theta) as a turtle array and subscribing to it.

Develop and test a ROS 2 final project that spawns turtles, directs them to targets, and kills completed turtles via a catch turtle service and list updates.

Target the nearest alive turtle in ROS 2, instead of the first in the list, using distance calculations to switch targets, with a toggle to choose catch behavior.

learn to make a ros 2 project dynamic and scalable by adding parameters and launch files loaded from a yaml config for the controller and spawner.