ROS 2 Tutorial for Beginners 2026 — Complete Getting Started Guide

A node is a single executable process that performs a specific task. A robot system is made of many nodes communicating with each other.

# List running nodes
ros2 node list

# Get info about a node
ros2 node info /talker

Topics implement a publish/subscribe pattern. Nodes publish messages to a topic; any number of nodes can subscribe to receive them.

# List active topics
ros2 topic list

# Echo messages on a topic
ros2 topic echo /chatter

# Publish manually
ros2 topic pub /chatter std_msgs/msg/String   '{"data": "Hello from terminal"}'

Services implement request/response. One node calls a service; the server node processes and returns a response synchronously.

# List services
ros2 service list

# Call a service
ros2 service call /add_two_ints   example_interfaces/srv/AddTwoInts   "{a: 5, b: 3}"
# Response: sum: 8

Actions extend services with feedback during execution and the ability to cancel. Perfect for long-running tasks like navigation.

# List action servers
ros2 action list

# Send a Fibonacci action goal
ros2 action send_goal /fibonacci   action_tutorials_interfaces/action/Fibonacci   "{order: 10}" --feedback

Parameters let you configure node behavior at runtime without recompiling. They're stored per-node and type-safe.

# List parameters for a node
ros2 param list /my_node

# Get a parameter value
ros2 param get /my_node robot_name

# Set a parameter at runtime
ros2 param set /my_node max_speed 1.5

Launch files start multiple nodes with parameters in one command. Written in Python (ROS 2) for full programmability.

# my_robot_launch.py
from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        Node(
            package='my_robot',
            executable='robot_controller',
            parameters=[{'max_speed': 1.0}]
        ),
        Node(
            package='my_robot',
            executable='lidar_processor',
        ),
    ])

# Create workspace
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src

# Create a Python package
ros2 pkg create --build-type ament_python --node-name my_node my_first_robot

# Build
cd ~/ros2_ws && colcon build
source install/setup.bash

# ~/ros2_ws/src/my_first_robot/my_first_robot/publisher.py
import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class RobotPublisher(Node):
    def __init__(self):
        super().__init__('robot_publisher')
        self.pub = self.create_publisher(String, 'robot_status', 10)
        self.timer = self.create_timer(1.0, self.timer_callback)
        self.count = 0

    def timer_callback(self):
        msg = String()
        msg.data = f'Robot status: cycle {self.count}'
        self.pub.publish(msg)
        self.get_logger().info(f'Publishing: {msg.data}')
        self.count += 1

def main(args=None):
    rclpy.init(args=args)
    node = RobotPublisher()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()

# ~/ros2_ws/src/my_first_robot/my_first_robot/subscriber.py
import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class RobotSubscriber(Node):
    def __init__(self):
        super().__init__('robot_subscriber')
        self.sub = self.create_subscription(
            String, 'robot_status', self.callback, 10)

    def callback(self, msg):
        self.get_logger().info(f'Received: {msg.data}')

def main(args=None):
    rclpy.init(args=args)
    node = RobotSubscriber()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()

# In setup.py, add entry_points:
entry_points={
    'console_scripts': [
        'publisher = my_first_robot.publisher:main',
        'subscriber = my_first_robot.subscriber:main',
    ],
},

# Rebuild and run
cd ~/ros2_ws && colcon build --symlink-install
source install/setup.bash

# Terminal 1:
ros2 run my_first_robot publisher

# Terminal 2:
ros2 run my_first_robot subscriber