ROS 2

Practical

ROS 2 (Robot Operating System 2) is an open-source robotics middleware that provides tools, libraries, and conventions for building robot applications. Despite its name, it’s not an operating system but a framework that runs on top of Linux (primarily), Windows, and macOS.

Why ROS 2?

ROS 2 addresses limitations of ROS 1 for production robotics:

Aspect	ROS 1	ROS 2
Communication	Custom (TCPROS)	DDS (industry standard)
Real-time	Not supported	Supported
Security	None built-in	DDS Security
Multi-robot	Difficult	Native support
Platforms	Linux only	Linux, Windows, macOS, RTOS
Lifecycle	None	Managed node lifecycle

Core Concepts

Nodes

Independent processes that perform computation. A robot typically runs many nodes:

┌─────────┐  ┌──────────┐  ┌─────────┐  ┌──────────┐
│ Camera  │  │   SLAM   │  │ Planner │  │ Controller│
│  Node   │  │   Node   │  │  Node   │  │   Node   │
└─────────┘  └──────────┘  └─────────┘  └──────────┘

Topics

Publish/subscribe messaging for streaming data:

Camera Node ──► /camera/image ──► SLAM Node
                    ▲
                    │
              Image Viewer

Services

Request/response for synchronous operations:

Client ──► /get_map (Request) ──► Server
       ◄── Map Data (Response) ◄──

Actions

For long-running tasks with feedback:

Client ──► /navigate_to_pose ──► Action Server
       ◄── Progress Feedback ◄──
       ◄── Final Result ◄──────

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                     Your ROS 2 Application                      │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐ │
│  │   rclcpp    │  │   rclpy     │  │      Other Clients      │ │
│  │  (C++ API)  │  │(Python API) │  │  (Rust, Java, etc.)     │ │
│  └─────────────┘  └─────────────┘  └─────────────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│                         RCL (ROS Client Library)                │
├─────────────────────────────────────────────────────────────────┤
│                         RMW (ROS Middleware Interface)          │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐ │
│  │   FastDDS   │  │ CycloneDDS  │  │   Zenoh, Other Impls    │ │
│  │  (Default)  │  │             │  │                         │ │
│  └─────────────┘  └─────────────┘  └─────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘

Set up sources

sudo apt update && sudo apt install -y software-properties-common
sudo add-apt-repository universe
sudo apt update && sudo apt install curl -y
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null

Install ROS 2

sudo apt update
sudo apt install ros-jazzy-desktop  # Recommended LTS
# Or: ros-humble-desktop for legacy projects

Source the setup

source /opt/ros/jazzy/setup.bash
# Add to ~/.bashrc for persistence
echo "source /opt/ros/jazzy/setup.bash" >> ~/.bashrc

Verify installation

ros2 run demo_nodes_cpp talker
# In another terminal:
ros2 run demo_nodes_cpp listener

# Pull official ROS 2 image
docker pull ros:jazzy

# Run with GUI support (Linux)
docker run -it --rm \
  --env="DISPLAY" \
  --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" \
  ros:jazzy

Essential Commands

# List running nodes
ros2 node list

# List topics
ros2 topic list

# Echo topic data
ros2 topic echo /scan

# Get topic info
ros2 topic info /camera/image_raw

# Call a service
ros2 service call /get_map nav_msgs/srv/GetMap

# Launch a system
ros2 launch my_robot bringup.launch.py

# Record data
ros2 bag record -a

# Play back data
ros2 bag play my_recording

Creating a Simple Node

Python
C++

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class MinimalPublisher(Node):
    def __init__(self):
        super().__init__('minimal_publisher')
        self.publisher_ = self.create_publisher(String, 'topic', 10)
        self.timer = self.create_timer(0.5, self.timer_callback)

    def timer_callback(self):
        msg = String()
        msg.data = 'Hello, ROS 2!'
        self.publisher_.publish(msg)
        self.get_logger().info(f'Publishing: "{msg.data}"')

def main():
    rclpy.init()
    node = MinimalPublisher()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

#include <chrono>
#include <memory>
#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"

using namespace std::chrono_literals;

class MinimalPublisher : public rclcpp::Node {
public:
    MinimalPublisher() : Node("minimal_publisher") {
        publisher_ = this->create_publisher<std_msgs::msg::String>("topic", 10);
        timer_ = this->create_wall_timer(
            500ms, std::bind(&MinimalPublisher::timer_callback, this));
    }

private:
    void timer_callback() {
        auto message = std_msgs::msg::String();
        message.data = "Hello, ROS 2!";
        publisher_->publish(message);
        RCLCPP_INFO(this->get_logger(), "Publishing: '%s'", message.data.c_str());
    }

    rclcpp::Publisher<std_msgs::msg::String>::SharedPtr publisher_;
    rclcpp::TimerBase::SharedPtr timer_;
};

int main(int argc, char* argv[]) {
    rclcpp::init(argc, argv);
    rclcpp::spin(std::make_shared<MinimalPublisher>());
    rclcpp::shutdown();
    return 0;
}

Key Packages for Robotics

Package	Purpose
`nav2`	Navigation stack
`moveit2`	Motion planning for manipulation
`ros2_control`	Hardware abstraction
`tf2`	Coordinate transforms
`rviz2`	3D visualization
`rosbag2`	Data recording/playback
`gazebo_ros2`	Simulation integration

ROS 2 + NVIDIA

Isaac ROS

NVIDIA’s GPU-accelerated ROS 2 packages bring 10-100x speedups for perception tasks on Jetson.

NITROS

Zero-copy GPU memory sharing between ROS 2 nodes — no CPU bottleneck.

Isaac ROS GPU-accelerated ROS 2 packages

URDF Robot description format used with ROS

Nav2 ROS 2 navigation stack

MoveIt 2 Motion planning framework

Learn More

Sources

ROS 2 Distributions — Version and EOL information
REP 2000 — Official ROS 2 release schedule
ROS 2 Middleware — DDS vendor comparison
Isaac ROS NITROS — Zero-copy GPU transport