Sensor publisher
Publish typed sensor samples and inspect rates, values and QoS behavior.
Course 03 · Free
ROS 2 Lyrical Luth
A complete seven-phase path on ROS 2 Lyrical Luth and Ubuntu 26.04: foundations, tools, Gazebo simulation, kinematics, perception, Nav2 navigation and professional-level robotics, finishing with a full warehouse robot.
- Duration
- 86 lessons · 7 phases · self-paced
- Prerequisite
- Ubuntu course and C++ Beginner
NODE NETWORK
Course 03
Learning outcomes
What you will be able to do
- Build C++17 nodes, topics, services, actions and launch files
- Describe, visualize and simulate a robot with URDF, TF2 and Gazebo
- Model kinematics and control joints with ros2_control
- Process LiDAR, camera and IMU data for perception
- Map, localize and navigate with the Nav2 stack
- Deploy, monitor and coordinate robots and fleets safely
Course outline
Lessons in order
- Phase 1 — ROS 2 Foundations (Lyrical Luth Core)
- 01
What ROS 2 is and where Lyrical Luth fits
The ROS 2 idea, distributions, LTS releases and why this course targets Lyrical Luth.
Open lesson - 02
DDS basics: CycloneDDS and FastDDS
The middleware under ROS 2, discovery, domains and choosing an RMW implementation.
Open lesson - 03
Workspace structure: src, build, install and log
What each workspace folder holds, underlay and overlay, and what to commit.
Open lesson - 04
Creating a workspace with colcon
colcon build options, selecting packages, symlink install and running tests.
Open lesson - 05
Creating your first package (ament_cmake and ament_python)
ros2 pkg create, package.xml, CMakeLists.txt, setup.py and the two build types.
Open lesson - 06
Nodes in C++17
rclcpp::Node, init/spin/shutdown, logging macros and the node graph.
Open lesson - 07
Topics: publishers and subscribers
Streaming typed data, timers, callbacks and inspecting topics from the CLI.
Open lesson - 08
Message types: standard and custom
std_msgs, sensor_msgs, geometry_msgs, writing .msg files and building a custom interface package.
Open lesson - 09
Services: request and response
Service servers and clients, .srv files, and when not to use a service.
Open lesson - 10
Actions: goal, feedback and result
Long-running tasks with progress and cancellation, .action files, servers and clients.
Open lesson - 11
Parameters
Declaring, reading and changing parameters, YAML files and validation callbacks.
Open lesson - 12
Launch files (Python launch system)
Starting many nodes with parameters, remappings, arguments and includes.
Open lesson - 13
Logging and debugging
Log levels, throttled logs, rqt_console, ros2 doctor and debugging nodes with gdb.
Open lesson - 14
QoS (Quality of Service) profiles
Reliability, durability, history and depth, and matching publishers to subscribers.
Open lesson - 15
Executors: single-threaded vs multi-threaded
How callbacks are scheduled, callback groups and running several nodes in one process.
Open lesson - Phase 2 — ROS 2 Tools & Visualization
- 16
RViz2 basics
Displays, fixed frame, saving configs and visualizing topics.
Open lesson - 17
TF2 transforms
Frames, static and dynamic broadcasters, lookups and debugging the tree.
Open lesson - 18
URDF robot description
Links, joints, joint types, limits and validating a description.
Open lesson - 19
Xacro macros
Properties, macros, math and includes to avoid repeating URDF.
Open lesson - 20
robot_state_publisher
Publishing TF from a URDF and joint states, and /robot_description.
Open lesson - 21
joint_state_publisher
Fake joint values with the GUI, the /joint_states message and its fields.
Open lesson - 22
ros2_control basics
Controller manager, hardware interfaces, command and state interfaces.
Open lesson - 23
ros2_controllers: diff drive and joint trajectory
Configuring diff_drive_controller and joint_trajectory_controller.
Open lesson - 24
Diagnostics and monitoring
diagnostic_msgs, diagnostic_updater, rqt tools and ros2 topic monitoring.
Open lesson - 25
ros2 bag: recording and playback
Recording topics, playing them back, storage formats and using bags in tests.
Open lesson - Phase 3 — Simulation (Gazebo Harmonic / Ignition)
- 26
Installing Gazebo Harmonic
Gazebo Sim, ros_gz packages, checking the version pairing and running the first world.
Open lesson - 27
SDF vs URDF
What each format is for, what SDF adds and how Gazebo converts URDF.
Open lesson - 28
Spawning robots in Gazebo
ros_gz_sim create, spawning from robot_description and launch files.
Open lesson - 29
Gazebo plugins: sensors and controllers
System plugins, sensor plugins and the ros2_control Gazebo plugin.
Open lesson - 30
Simulated LiDAR
The gpu_lidar sensor, its parameters and bridging LaserScan to ROS 2.
Open lesson - 31
Simulated camera
Camera sensor, image and camera_info bridges and viewing in rqt_image_view.
Open lesson - 32
Simulated IMU
The imu sensor, noise models, frames and bridging sensor_msgs/Imu.
Open lesson - 33
Simulated differential drive
The diff-drive system plugin, cmd_vel and odometry in simulation.
Open lesson - 34
Teleoperation
teleop_twist_keyboard, joystick teleop, scaling and safety limits.
Open lesson - 35
Building custom worlds: warehouse, office and outdoor
Writing SDF worlds, including models, lights, physics and reusing model libraries.
Open lesson - Phase 4 — Robot Modeling & Kinematics
- 36
Kinematic chains
Links and joints as a chain, degrees of freedom, the base and the tool frame.
Open lesson - 37
Forward kinematics
From joint angles to the tool position with trigonometry for a planar arm.
Open lesson - 38
Inverse kinematics
From a target position to joint angles, multiple solutions and unreachable targets.
Open lesson - 39
DH parameters
The four Denavit–Hartenberg parameters, transform matrices and chaining them.
Open lesson - 40
TF tree design
One parent per frame, avoiding loops, where to attach sensors and naming conventions.
Open lesson - 41
Robot frames: map, odom, base_link and sensors
REP 105 frame conventions and who publishes each transform.
Open lesson - 42
URDF collision and visual geometry
Visual meshes vs simplified collision shapes, and performance trade-offs.
Open lesson - 43
Inertial modeling
Mass, centre of mass and the inertia tensor of boxes, cylinders and spheres.
Open lesson - 44
ros2_control hardware interfaces
Writing a SystemInterface: on_init, export interfaces, read and write.
Open lesson - 45
Joint trajectory controllers
Trajectory messages, the follow_joint_trajectory action, limits and tolerances.
Open lesson - Phase 5 — Perception (Sensors & Processing)
- 46
LiDAR data processing
LaserScan fields, invalid readings, filtering and finding the nearest obstacle.
Open lesson - 47
LaserScan to point cloud conversion
Polar to Cartesian conversion, PointCloud2 and the laser_geometry package.
Open lesson - 48
Depth camera basics
Depth images, intrinsics, projecting pixels to 3D and registered point clouds.
Open lesson - 49
RGB camera pipelines
Camera drivers, camera_info, rectification with image_proc and cv_bridge.
Open lesson - 50
Image transport
Compressed and theora transports, republish and bandwidth control.
Open lesson - 51
Point cloud processing (PCL)
PointCloud2 to PCL, voxel-grid downsampling, passthrough filtering and plane removal.
Open lesson - 52
IMU fusion
Gyro and accelerometer errors, complementary filter and robot_localization.
Open lesson - 53
Odometry estimation
Dead reckoning for a differential drive, drift and nav_msgs/Odometry.
Open lesson - 54
Object detection: YOLO and OpenCV
Running a detector on camera frames, bounding boxes, IoU and non-maximum suppression.
Open lesson - 55
ArUco markers for docking and alignment
Marker detection, pose estimation and a simple alignment controller.
Open lesson - Phase 6 — Navigation (Nav2 Stack)
- 56
Installing Nav2
Nav2 packages, the bringup launch files and running the simulation demo.
Open lesson - 57
Map server
Map YAML and image files, map_server, map_saver and the occupancy grid.
Open lesson - 58
Costmaps: global and local
Layers, inflation, robot footprint and cost values.
Open lesson - 59
SLAM Toolbox: mapping
Online async mapping, parameters, driving to map and saving the result.
Open lesson - 60
AMCL: localization
Particle filter localization on a known map, initial pose and tuning.
Open lesson - 61
Global planners: NavFn and Smac
Choosing a global planner, Dijkstra/A*, hybrid-A* and lattice planners.
Open lesson - 62
Local planners: DWB and TEB
Controllers that follow the path, DWB critics, and how TEB differs.
Open lesson - 63
Behavior Trees: BT Navigator
Behavior tree nodes, the navigate_to_pose tree and customizing behaviour.
Open lesson - 64
Obstacle avoidance
Costmap obstacle layers, the local planner's role and the collision monitor.
Open lesson - 65
Recovery behaviors
Spin, back up, wait, clear costmaps and recovery nodes in the tree.
Open lesson - 66
Docking behaviors
The docking server, dock plugins, staging poses and charging detection.
Open lesson - 67
Multi-floor navigation
One map per floor, switching maps, elevators and floor-aware goals.
Open lesson - 68
Multi-robot navigation
Namespaces, per-robot Nav2 instances, shared maps and avoiding conflicts.
Open lesson - 69
Path smoothing and constraints
The smoother server, path smoothing algorithms, speed limits and keepout zones.
Open lesson - 70
Full navigation launch system
A complete bringup: robot, sensors, localization, Nav2 and RViz in one launch.
Open lesson - Phase 7 — Advanced Robotics (Lyrical Luth Professional Level)
- 71
Lifecycle nodes
Managed states, transition callbacks and controlled start-up of hardware.
Open lesson - 72
Multi-threaded executors and callback groups
Designing concurrency: groups, executors and avoiding deadlocks.
Open lesson - 73
Real-time ROS 2
Real-time kernels, priorities, memory locking and avoiding allocation in the loop.
Open lesson - 74
DDS tuning
Cyclone and Fast DDS settings, network interfaces, multicast and large data.
Open lesson - 75
Distributed systems
Several computers in one ROS graph: networking, discovery server and time sync.
Open lesson - 76
Fleet management
Task queues, assignment, robot state tracking and open-source fleet tools.
Open lesson - 77
Multi-robot coordination
Shared resources, reservations, priorities and deadlock avoidance.
Open lesson - 78
Logging and metrics
Structured logs, latency and rate metrics, percentiles and dashboards.
Open lesson - 79
Safety systems
Watchdogs, emergency stop, safe velocities and failing safe.
Open lesson - 80
Deployment on real hardware: Jetson, NUC and Raspberry Pi
Choosing computers, installing, systemd services, containers and remote updates.
Open lesson - 81
Building a full AMR stack
Project: drive base, sensors, localization and Nav2 as one package set.
Open lesson - 82
Building a manipulator stack
Project: arm description, ros2_control, trajectory controller and motion planning.
Open lesson - 83
Building a warehouse simulation
Project: a warehouse world with shelves, aisles, docks and moving obstacles.
Open lesson - 84
Building a perception pipeline
Project: camera and lidar processing, detection, tracking and publishing results.
Open lesson - 85
Building a multi-robot fleet
Project: several namespaced robots with shared map, fleet manager and traffic rules.
Open lesson - 86
Building a full warehouse robot: AMR, perception and Nav2
Capstone: one warehouse robot that perceives, navigates, docks and reports.
Open lesson
Practice
Project examples
Navigation action
Build a cancellable action server with feedback and a C++ client.
Diagnosable robot stack
Launch multiple nodes, record a bag and trace an injected failure.
Documentation
Checked against primary sources
Verified September 2026. Links open the official documentation.