RobotnixAcademy
← Courses

Robotics

ROS 2: For Students

A self-paced beginner ROS 2 course for students working on Ubuntu 24.04 with ROS 2 Jazzy. Across 78 lessons, learners install and source ROS 2, run Turtlesim, inspect nodes and the ROS graph, work with topics, services, parameters and actions, create a workspace and Python package, build with colcon, write a small publisher/subscriber system, use launch files, and diagnose common setup and runtime failures. The course intentionally stops before advanced navigation, SLAM, MoveIt, control theory, DDS tuning, or robot-specific stacks.

Structure
9 units
Audience
Grades 9-12
Entries
87
NJ standards
8.1.12.AP.4 · 8.1.12.AP.5 · 8.1.12.AP.9 · 8.1.12.CS.1 · 8.1.12.CS.2 · 9.4.12.CT.1 · 9.4.12.TL.1
Pacing
Self-paced

Unit 01

  1. overviewUnit 1: What ROS 2 IsBefore you install anything, you need a map.
  2. Lesson 1Robots Need Software SystemsA robot is not one program.
  3. Lesson 2What ROS 2 Actually ProvidesROS 2 gives you more than one library and less than an entire robot.
  4. Lesson 3Packages, Nodes, Graphs, and InterfacesNow connect the nouns.
  5. Lesson 4ROS 2 Distributions and Why This Course Uses JazzyROS 2 changes over time.
  6. Lesson 5Unit Check: Explain the ROS 2 StackNo installation yet.

Unit 02

  1. overviewUnit 2 — Ubuntu 24.04 and Jazzy SetupThis Unit turns a fresh Ubuntu 24.04 machine into a verified ROS 2 Jazzy workstation.
  2. Lesson 1Prove the Ubuntu BaselineBefore installing ROS 2, prove what machine you are actually standing on.
  3. Lesson 2Prepare a UTF-8 LocaleROS 2's Jazzy installation guide tells Ubuntu learners to make sure the system has a locale that supports UTF-8.
  4. Lesson 3Add the ROS 2 Apt RepositoryUbuntu's normal package repositories do not automatically know where ROS 2 packages come from.
  5. Lesson 4Prepare Development Tools and UpdatesThe Jazzy installation documentation separates the ROS runtime from development tooling.
  6. Lesson 5Install ROS 2 Jazzy DesktopNow the operating-system prerequisites and ROS repository should be ready.
  7. Lesson 6Source and Inspect the ROS EnvironmentROS 2 relies on shell environment setup files.
  8. Lesson 7Verify Jazzy With Talker and ListenerA successful package installation is useful evidence.
  9. Lesson 8Setup Recovery: Diagnose Before ReinstallingWhen a beginner ROS install fails, the fastest emotional reaction is often:

Unit 03

  1. overviewUnit 3 — Turtlesim and the ROS GraphYou have ROS 2 running. Now stop treating it like a pile of terminal commands.
  2. Lesson 1Start Turtlesim and Prove the Package ExistsTurtlesim is a lightweight simulator designed to make beginner ROS 2 concepts visible.
  3. Lesson 2`ros2 run`: Package, Executable, NodeThe syntax is simple:
  4. Lesson 3Discover Nodes With `ros2 node list`A live ROS 2 system can change while you watch it.
  5. Lesson 4Interrogate a Node With `ros2 node info`Listing a node tells you it exists.
  6. Lesson 5See the Graph With `rqt_graph`CLI output is precise. A graph can make relationships easier to see.
  7. Lesson 6Names, Namespaces, and RemappingReusable software becomes much more useful when names can change without rewriting the program.
  8. Lesson 7Run Reusable Nodes More Than OnceThis lesson is about a design idea hidden inside a fun simulator.
  9. Lesson 8Unit Mission: Map the Running SystemYour job is to start a small ROS 2 system and explain it without reading Turtlesim source code.

Unit 04

  1. overviewUnit 4 — Topics and MessagesNodes are useful because they can exchange information.
  2. Lesson 1Streaming Data: Why Topics ExistA topic is not a storage box that permanently holds the latest value.
  3. Lesson 2List Topics and Their TypesStart Turtlesim and teleop in sourced terminals:
  4. Lesson 3Echo Live MessagesA topic can exist without you seeing its data.
  5. Lesson 4Inspect Topic Endpointsecho answers "what messages are arriving?"
  6. Lesson 5Read Message InterfacesYou know /turtle1/cmd_vel uses:
  7. Lesson 6Publish From the Command LineYou do not need to write a Python node to test every topic.
  8. Lesson 7Diagnose Topic FailuresTopic problems are easier when you separate name, type, endpoint, and data.
  9. Lesson 8Unit Mission: Command Turtlesim With EvidenceStart Turtlesim without teleop.

Unit 05

  1. overviewUnit 5 — Services, Parameters, and ActionsTopics are not the answer to every ROS 2 interaction.
  2. Lesson 1Choose the Communication PatternROS 2 gives nodes several ways to interact.
  3. Lesson 2Discover Services and Their TypesStart Turtlesim in a sourced terminal.
  4. Lesson 3Read and Call Service InterfacesBefore calling a service with data, inspect the request/response contract.
  5. Lesson 4Diagnose Service CallsService failures become easier if you inspect name → type → interface → server in that order.
  6. Lesson 5Read and Change ParametersThe beginner parameter tutorial calls parameters node settings.
  7. Lesson 6Save and Reload Parameter ConfigurationA runtime change disappears when a node exits unless you preserve and reapply configuration.
  8. Lesson 7Actions: Goal, Feedback, ResultServices are request/response.
  9. Lesson 8Inspect Action Clients and ServersWith Turtlesim and teleop running, ask the graph about actions.
  10. Lesson 9Send and Observe Action GoalsNow send an action goal yourself.
  11. Lesson 10Unit Mission: Control Turtlesim Without GuessingYou will demonstrate all four beginner interaction patterns around one running Turtlesim system.

Unit 06

  1. overviewUnit 6 — Workspaces and `colcon`Up to this point you have mostly used ROS packages installed under /opt/ros/jazzy.
  2. Lesson 1Underlays, Overlays, and Why Workspaces ExistYour installed Jazzy system already contains packages.
  3. Lesson 2Create the Workspace StructureThe official beginner workspace tutorial recommends a separate workspace directory with source packages inside src.
  4. Lesson 3Put Source Packages in `src`A workspace becomes useful when src contains ROS packages.
  5. Lesson 4Resolve Dependencies With `rosdep`A package can declare dependencies on other packages.
  6. Lesson 5Build With `colcon`From the workspace root:
  7. Lesson 6Read `build`, `install`, and `log`After a successful colcon build, inspect:
  8. Lesson 7Source the Overlay and Prove ItA successful build does not automatically change every terminal.
  9. Lesson 8Diagnose Workspace and Build FailuresMost beginner workspace failures fit a small number of boundaries.

Unit 07

  1. overviewUnit 7 — Packages and Python NodesUntil now, you have mostly operated other people's ROS 2 nodes.
  2. Lesson 1A ROS Package Is a Deployable UnitA Python file can run by itself.
  3. Lesson 2Create an `ament_python` PackageWork inside the workspace source directory:
  4. Lesson 3Read the Generated Package TreeBefore adding code, understand what already exists.
  5. Lesson 4`package.xml`: Declare What the Package IsOpen:
  6. Lesson 5`setup.py`, `setup.cfg`, and Entry PointsA Python file existing in your source tree does not automatically make this work:
  7. Lesson 6Write the First `rclpy` NodeBefore publisher/subscriber behavior, build the smallest useful node mental model.
  8. Lesson 7Build a Publisher NodeCreate:
  9. Lesson 8Build a Subscriber NodeCreate:
  10. Lesson 9Declare Dependencies and ExecutablesYour Python files now exist. ROS still needs package/install metadata.
  11. Lesson 10Build, Source, Run, and InspectNow close the loop.
  12. Lesson 11Diagnose Python Package FailuresThis is where the layers you learned earlier pay off.
  13. Lesson 12Unit Mission: Modify and Defend Your SystemYou have a working publisher/subscriber system. Now prove you understand it by changing it intentionally.

Unit 08

  1. overviewUnit 8 — Launch and Reproducible StartupManually opening terminal after terminal is fine while learning one node at a time.
  2. Lesson 1Why Launch ExistsYour Unit 7 system probably needs at least two terminals:
  3. Lesson 2Read a Python Launch DescriptionA basic ROS 2 Python launch file usually returns a LaunchDescription containing actions.
  4. Lesson 3Launch Your Talker and Listener TogetherCreate a launch directory inside the ROS package:
  5. Lesson 4Install Launch Files With the Python PackageRunning a launch file from its directory proves the file works.
  6. Lesson 5Namespaces and Remappings at StartupThe pinned launch tutorial uses namespaces and remappings to run reusable nodes in different graph positions.
  7. Lesson 6Parameters and Arguments at StartupLaunch files can carry node configuration that would otherwise need to be typed separately every time.
  8. Lesson 7Inspect a Launched SystemLaunching successfully means processes started.
  9. Lesson 8Diagnose Launch FailuresLaunch adds configuration power and therefore new failure boundaries.
  10. Lesson 9Unit Mission: Start the Same System TwiceA repeatable startup should produce the intended system from a clean shell more than once.

Unit 09

  1. overviewUnit 9 — Run, Inspect, and TroubleshootYou know enough ROS 2 now.
  2. Lesson 1The Clean-Terminal Startup ChecklistA clean terminal removes hidden assumptions.
  3. Lesson 2Prove the Environment Before Running AnythingMany ROS errors are actually shell-environment errors.
  4. Lesson 3Inspect the System Before Touching ItWhen a running system behaves strangely, collect a baseline before changing it.
  5. Lesson 4Build a Failure-Layer ModelRandom troubleshooting feels difficult because every symptom looks like "ROS is broken."
  6. Lesson 5Diagnose Package, Executable, and Node FailuresThree symptoms sound similar but live at different boundaries.
  7. Lesson 6Diagnose Topic and Communication FailuresAssume both nodes are alive but messages do not arrive.
  8. Lesson 7Diagnose Configuration and Launch FailuresNot every failure is a broken executable.
  9. Lesson 8Rebuild and Re-source From a Known StateSometimes the fastest controlled recovery is a clean rebuild/re-source loop.
  10. Lesson 9Readiness Dry RunDo the final check once before the final demonstration.
  11. Lesson 10Final Demo: Install, Run, ExplainThis is the stopping point for ROS 2: For Students.