The Robotic Nervous System: ROS 2 Fundamentals
For the full course overview and capstone description, see the Physical AI & Humanoid Robotics — Course Specification.
Chapter Overview
Duration: Weeks 3-5
Focus: Middleware for robot control and inter-process communication
Chapter 2 introduces Robot Operating System 2 (ROS 2) as the middleware layer that connects sensors, perception algorithms, planners, and motor controllers. Students will learn ROS 2 architecture, core concepts (nodes, topics, services, actions), and practical implementation using Python (rclpy). By the end, students will design and build a multi-node ROS 2 system that simulates a humanoid robot's control pipeline.
ROS 2 serves as the "nervous system" of your humanoid robot—the communication infrastructure that allows distributed components to work together seamlessly. Unlike monolithic robot code where everything runs in a single process, ROS 2 enables a distributed architecture where perception nodes can run on one computer, planning on another, and control on the robot itself, all communicating through standardized message interfaces.
Learning Outcomes
Conceptual Understanding
- Understand ROS 2 architecture and why middleware is essential for robotics
- Grasp the difference between topics (streams), services (RPC), and actions (goals)
- Understand the publish-subscribe pattern and its advantages for distributed systems
- Learn why ROS 2 is superior to ROS 1 for real-time and deterministic systems
- Understand URDF (Unified Robot Description Format) and kinematic chains
- Learn how to describe humanoid robot morphology in machine-readable format
Practical Skills
- Install and configure ROS 2 (Humble/Iron) on Ubuntu 22.04
- Create ROS 2 packages with proper structure and dependencies
- Write ROS 2 nodes in Python using rclpy
- Create custom message and service definitions
- Implement publish-subscribe communication between nodes
- Implement request-response (service) communication
- Use ROS 2 launch files to orchestrate multi-node systems
- Use parameter servers and dynamic parameter reconfiguration
- Parse and validate URDF files for humanoid robots
- Visualize robot morphology using RViz
- Debug ROS 2 systems using ros2 command-line tools
Capstone Relevance
- Students will use ROS 2 nodes to coordinate their capstone system
- Perception pipeline (sensors → fusion) will run as ROS 2 nodes
- Motion planning will be a ROS 2 service
- Motor commands will be published as ROS 2 topics
Chapter Structure
This chapter is organized into three modules:
Module 1: ROS 2 Architecture & Core Concepts (Weeks 3-4)
Covers the fundamental building blocks of ROS 2: nodes, topics, services, actions, and parameters. You'll learn why distributed architectures matter and how ROS 2 solves the middleware problem in robotics.
Module 2: Practical ROS 2 Development (Weeks 4-5)
Focuses on practical development skills: launch files, message definitions, debugging tools, URDF modeling, and visualization with RViz.
Module 3: Integration & Capstone Preparation (Week 5)
Brings everything together with sensor drivers, motor controllers, and a comprehensive integration challenge that prepares you for the capstone project.
Prerequisites
Before starting this chapter, you should have:
- Completed Chapter 1 (Foundations of Physical AI)
- Ubuntu 22.04 LTS installed (or accessible via VM)
- Basic Python programming experience
- Familiarity with command-line tools (Linux terminal)
- Understanding of basic robotics concepts (sensors, actuators, control loops)
Technical Requirements
Software Stack
- ROS 2 Humble or Iron (Ubuntu 22.04 LTS)
- Python 3.10+
- RViz (visualization)
- rqt tools (debugging)
- Visual Studio Code with ROS 2 extension (recommended)
Hardware
- Linux PC with Ubuntu 22.04 (dual-boot or VM acceptable)
- 4+ GB RAM minimum, 8+ GB recommended
- 100 GB free disk space
- No specialized hardware needed for Chapter 2 (simulation only)
External Dependencies
- rclpy (Python ROS 2 client library)
- std_msgs, geometry_msgs, sensor_msgs (standard message types)
- tf2, tf2_ros (coordinate transformation library)
- OpenCV (optional, for visualizations)
Reading Materials
Primary Resources
Secondary Resources
- Real-Time Robotics: Time and Determinism - Research paper on ROS 2 real-time capabilities
- Message Design in ROS: Best practices for custom messages
- Robot Architecture: From Design to Deployment - Chapter on middleware
Reference Materials
- ROS 2 Command Cheat Sheet
- URDF Validator and Tools
- rqt Tools User Guide
Common Mistakes to Avoid
Mistake: Ignoring QoS settings. Result: Data loss or latency.
Prevention: Always specify QoS explicitly. Use 'reliable' for critical data (commands), 'best-effort' for high-frequency data (camera).
Mistake: Creating monolithic nodes. Result: Debugging nightmare, poor reusability.
Prevention: Each node should have single responsibility. Separate perception, planning, control.
Mistake: Not handling dynamic reconnection. Result: System hangs if a node crashes.
Prevention: Implement timeout handling, graceful degradation, lifecycle management.
Mistake: URDF with incorrect inertia. Result: Physics simulation diverges from reality.
Prevention: Use actual CAD properties or estimate conservatively. Always validate in Gazebo.
Mistake: Mixing real-time and non-real-time in same node. Result: Control jitter, motion instability.
Prevention: Keep control loop in separate, dedicated thread. Use timers for periodic tasks.
Mistake: Assuming simulated time = real time. Result: Code works in sim, fails on real robot.
Prevention: Always be explicit about time. Use ros_time. Test timing on actual hardware.
Chapter Summary
Duration: 3 weeks (Weeks 3-5)
Modules: 3
Subsections: 16
Hands-on Projects: 3
Total Estimated Reading: 120-150 pages
Total Estimated Coding: 30-40 hours
Key Takeaways
- ROS 2 is a distributed middleware that enables complex robot software
- Nodes communicate via topics (streaming), services (RPC), and actions (goals)
- Proper system architecture is essential: separate perception, planning, control
- URDF describes robot morphology; RViz visualizes it
- Launch files orchestrate multi-node systems
- Debugging tools (ros2 CLI, rqt) are essential for system integration
- Real-time constraints must be respected: control loop frequency matters
- Sim-to-real requires careful time management and sensor driver abstraction
Next Chapter Prerequisites
By the end of Chapter 2, you should have:
- Working ROS 2 installation
- Ability to write, launch, and debug multi-node systems
- Understanding of URDF and robot kinematics
- Comfort with publish-subscribe and request-response patterns
- Capstone system architecture designed in Chapter 2
These skills form the foundation for Chapter 3, where you'll integrate perception, planning, and advanced control systems.