Launching multiple nodes in ROS - Deep Dive

Overview - Launching multiple nodes

What is it?

Launching multiple nodes in ROS means starting several small programs, called nodes, that work together to perform a task. Each node runs independently but communicates with others to share information. This helps break complex robot software into manageable parts that can run at the same time. Using launch files, you can start many nodes with one command instead of running each manually.

Why it matters

Without the ability to launch multiple nodes easily, managing robot software would be slow and error-prone. You would have to start each program one by one, risking mistakes and wasted time. Launching multiple nodes together ensures all parts start correctly and can communicate, making robot systems reliable and easier to develop. This saves time and reduces frustration during testing and deployment.

Where it fits

Before learning to launch multiple nodes, you should understand what ROS nodes are and how they communicate using topics and services. After mastering launching nodes, you can learn about advanced launch file features like parameters, remapping, and grouping nodes for complex robot systems.

Mental Model

Core Idea

Launching multiple nodes is like pressing one button to start all the small robot programs that work together, instead of starting each one separately.

Think of it like...

Imagine a band where each musician plays a different instrument (node). Instead of calling each musician individually to start playing, the conductor (launch file) signals everyone at once to begin the performance together.

┌───────────────┐
│ Launch File   │
│ (Conductor)   │
└──────┬────────┘
       │ starts
       ▼
┌──────┴───────┐   ┌─────────────┐   ┌─────────────┐
│ Node 1       │   │ Node 2      │   │ Node 3      │
│ (Musician 1) │   │ (Musician 2)│   │ (Musician 3)│
└──────────────┘   └─────────────┘   └─────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding ROS Nodes Basics

Concept: Learn what a ROS node is and how it acts as a small program in a robot system.

A ROS node is a single executable that performs computation. Nodes communicate by sending messages over topics. For example, one node might read sensor data, while another controls motors. Each node runs independently but works together to achieve complex tasks.

Result

You understand that nodes are the building blocks of ROS robot software.

Knowing that nodes are independent programs helps you see why launching multiple nodes together is important for coordination.

2

Foundation

Running Nodes Manually

Concept: Learn how to start nodes one by one using command line tools.

You can start a node by running its executable with the rosrun command, for example: rosrun turtlesim turtlesim_node. To run multiple nodes, you open several terminals and run each command separately.

Result

You can start individual nodes but must manage many terminals for multiple nodes.

Manually running nodes shows the pain of managing many programs, motivating the need for launch files.

3

Intermediate

Introduction to ROS Launch Files

Concept: Learn what launch files are and how they automate starting multiple nodes.

A launch file is an XML file that lists nodes to start together. For example: You run it with roslaunch package_name file.launch, and it starts all nodes listed.

Result

You can start multiple nodes with one command using a launch file.

Launch files simplify managing many nodes and ensure they start in a controlled way.

4

Intermediate

Using Arguments and Parameters in Launch Files

🤔Before reading on: Do you think launch files can pass settings to nodes? Commit to yes or no.

Concept: Learn how to customize node behavior by passing parameters through launch files.

Launch files can include parameters that nodes read at startup. For example: Nodes can access these parameters to change how they work without changing code.

Result

You can control node settings centrally in launch files.

Passing parameters through launch files makes your robot software flexible and easier to configure.

5

Intermediate

Remapping Topics in Launch Files

🤔Before reading on: Can launch files change which topics nodes use? Commit to yes or no.

Concept: Learn how to change topic names nodes use by remapping them in launch files.

Sometimes nodes expect topics with certain names, but you want to connect them differently. Launch files let you remap topics: This connects nodes flexibly without changing code.

Result

You can connect nodes in different ways by remapping topics at launch time.

Remapping topics allows reuse of nodes in different setups without rewriting them.

6

Advanced

Grouping Nodes and Managing Lifecycles

🤔Before reading on: Do you think launch files can control groups of nodes as one? Commit to yes or no.

Concept: Learn how to group nodes and control their startup and shutdown behavior together.

Launch files support grouping nodes with tags and can manage node lifecycles. For example, you can start a group of nodes with shared parameters or namespaces. You can also specify if nodes should respawn if they crash: This helps keep your system robust.

Result

You can organize nodes logically and improve system reliability.

Grouping and lifecycle management in launch files help build stable, maintainable robot systems.

7

Expert

Using ROS2 Launch with Python for Flexibility

🤔Before reading on: Do you think launch files can be written in code, not just XML? Commit to yes or no.

Concept: Learn that ROS2 uses Python-based launch files for more powerful and flexible node launching.

In ROS2, launch files are Python scripts. This lets you use programming logic to decide which nodes to start, set parameters dynamically, and handle complex conditions. Example snippet: from launch import LaunchDescription from launch_ros.actions import Node def generate_launch_description(): return LaunchDescription([ Node(package='demo_nodes_cpp', executable='talker', name='talker'), Node(package='demo_nodes_cpp', executable='listener', name='listener') ]) This approach is more powerful than static XML.

Result

You can create dynamic, programmable launch configurations in ROS2.

Using code for launch files unlocks advanced automation and customization for complex robot systems.

Under the Hood

When you run a launch file, the ROS launch system reads the file and starts each node as a separate process on your computer. It sets up communication channels between nodes using ROS middleware, which handles message passing over topics and services. The launch system also manages node lifecycles, monitors if nodes crash, and can restart them if configured. In ROS2, the launch system uses Python scripts to create and control nodes dynamically, allowing conditional logic and parameter setting before nodes start.

Why designed this way?

ROS was designed to support modular robot software where many small programs work together. Launch files were created to simplify starting and managing these programs as a group. XML was chosen initially for its simplicity and readability. ROS2 moved to Python launch files to allow more flexibility and power, as robot systems grew more complex and needed dynamic configuration. This design balances ease of use with the ability to handle complex setups.

┌───────────────┐
│ Launch File   │
│ (XML or Py)   │
└──────┬────────┘
       │ parses
       ▼
┌───────────────┐
│ Launch System │
│ (roslaunch)   │
└──────┬────────┘
       │ starts
       ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│ Node Process 1│   │ Node Process 2│   │ Node Process 3│
└──────┬────────┘   └──────┬────────┘   └──────┬────────┘
       │                  │                  │
       └───────┬──────────┴──────────┬───────┘
               ▼                     ▼
          ┌───────────┐         ┌───────────┐
          │ ROS Topic │◄───────►│ ROS Topic │
          └───────────┘         └───────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does a launch file run nodes sequentially, waiting for one to finish before starting the next? Commit to yes or no.

Common Belief: Launch files start nodes one after another, waiting for each to finish before starting the next.

Reality: Launch files start all nodes almost simultaneously, each in its own process, so they run in parallel.

Why it matters: Believing nodes start sequentially can cause confusion about timing and communication, leading to incorrect assumptions about system behavior.

Quick: Can you only launch nodes from the same package in one launch file? Commit to yes or no.

Common Belief: A launch file can only start nodes from a single ROS package.

Reality: Launch files can start nodes from multiple packages, allowing integration of diverse components.

Why it matters: Thinking launch files are limited to one package restricts system design and integration possibilities.

Quick: Does remapping topics in a launch file change the node's internal code? Commit to yes or no.

Common Belief: Remapping topics requires changing the node's source code to use new topic names.

Reality: Remapping is done externally in the launch file without modifying node code.

Why it matters: Misunderstanding remapping leads to unnecessary code changes and reduces node reusability.

Quick: Are ROS1 launch files and ROS2 launch files the same format? Commit to yes or no.

Common Belief: ROS1 and ROS2 use the same XML launch file format.

Reality: ROS1 uses XML launch files; ROS2 uses Python scripts for launch files.

Why it matters: Confusing the two can cause errors and frustration when migrating or working across ROS versions.

Expert Zone

1

Launch files can include conditional logic in ROS2 Python scripts, enabling dynamic node launching based on runtime parameters or environment variables.

2

Node respawn settings in launch files help maintain system robustness by automatically restarting crashed nodes without manual intervention.

3

Namespaces in launch files allow grouping nodes logically, preventing topic name collisions and enabling modular system design.

When NOT to use

If your system only needs to run a single node or very simple setups, using launch files might be overkill; running nodes manually or using scripts might suffice. For very complex systems, consider using container orchestration tools like Kubernetes alongside ROS for better scaling and management.

Production Patterns

In real-world robots, launch files are organized hierarchically, with base launch files including others to compose complex systems. Parameters are loaded from YAML files for easy configuration. Launch files also manage lifecycle nodes to ensure safe startup and shutdown sequences.

Connections

Microservices Architecture

Both involve running many small independent programs that communicate to form a larger system.

Understanding how microservices coordinate helps grasp why ROS uses multiple nodes and launch files to manage them.

Operating System Process Management

Launching nodes is similar to how an OS starts and manages processes.

Knowing OS process control clarifies how ROS launch manages node lifecycles and restarts.

Orchestration in Music Ensembles

Launch files act like conductors coordinating musicians (nodes) to perform together.

Seeing launch files as conductors helps appreciate the importance of timing and coordination in complex systems.

Common Pitfalls

#1 Trying to start multiple nodes by running rosrun commands in one terminal separated by &&.

Wrong approach:

rosrun turtlesim turtlesim_node && rosrun turtlesim turtle_teleop_key

Correct approach:

Use a launch file to start both nodes together: roslaunch turtlesim turtlesim.launch

Root cause:

Misunderstanding that rosrun runs one node per terminal and that && waits for the first command to finish before starting the next.

#2 Editing node source code to change topic names instead of using remapping in launch files.

Wrong approach:

Changing publisher topic name inside node code to match another node.

Correct approach:

Use tags in launch files to connect nodes without code changes.

Root cause:

Not knowing that launch files can remap topics externally, leading to unnecessary code duplication.

#3 Using ROS1 XML launch files syntax in ROS2 environment.

Wrong approach:

Trying to run roslaunch with XML files in ROS2, expecting them to work.

Correct approach:

Write launch files as Python scripts using ROS2 launch API.

Root cause:

Confusing ROS1 and ROS2 launch file formats and tools.

Key Takeaways

Launching multiple nodes lets you start many small robot programs together, making complex systems manageable.

Launch files automate node startup, configuration, and communication setup, saving time and reducing errors.

ROS1 uses XML launch files, while ROS2 uses Python scripts for more flexible and dynamic launching.

Remapping topics and passing parameters in launch files allow nodes to be reused and configured without code changes.

Understanding launch files is essential for building reliable, maintainable, and scalable robot software systems.

Practice

1. What is the main purpose of a ROS launch file when working with multiple nodes?

easy

A. To debug a single ROS node

B. To write the source code of ROS nodes

C. To start several ROS nodes together with one command

D. To stop all running ROS nodes automatically

Solution

1. Step 1: Understand the role of launch files and compare options

   Launch files are used to start multiple ROS nodes at once, simplifying the process. Only "To start several ROS nodes together with one command" correctly describes starting multiple nodes together; others describe unrelated tasks.

2. Final Answer:

   To start several ROS nodes together with one command -> Option C

3. Quick Check:

   Launch file = start multiple nodes [OK]

Hint: Launch files group nodes to run with one command [OK]

Common Mistakes:

• Thinking launch files write node code
• Confusing launch files with debugging tools
• Assuming launch files stop nodes

2. Which of the following is the correct XML tag to define a node in a ROS launch file?

easy

A.

B.

C.

D.

Solution

1. Step 1: Recall ROS launch file syntax and check options

   The correct tag to start a node is <node> with attributes pkg, type, and name. Only <node pkg="package_name" type="node_type" name="node_name" /> uses the correct <node> tag; others use invalid tags like <launch>, <start>, <run>.

2. Final Answer:

   <node pkg="package_name" type="node_type" name="node_name" /> -> Option A

3. Quick Check:

   Node tag = <node> [OK]

Hint: Use <node> tag with pkg, type, and name attributes [OK]

Common Mistakes:

• Using <launch> or <start> instead of <node>
• Forgetting to close the tag properly
• Mixing up attribute names

3. Given this launch file snippet:

<launch>
  <node pkg="turtlesim" type="turtlesim_node" name="sim1" />
  <node pkg="turtlesim" type="turtlesim_node" name="sim2" />
</launch>

What happens when you run roslaunch with this file?

medium

A. The launch file causes a syntax error and no nodes start

B. Only one turtlesim node starts named sim1

C. Two nodes start but both have the same name sim1 causing a conflict

D. Two turtlesim nodes named sim1 and sim2 start simultaneously

Solution

1. Step 1: Analyze node definitions and ROS naming rules

   Two nodes are defined with different names: sim1 and sim2, both from turtlesim package. Nodes with unique names can run simultaneously without conflict.

2. Final Answer:

   Two turtlesim nodes named sim1 and sim2 start simultaneously -> Option D

3. Quick Check:

   Unique node names = both run [OK]

Hint: Different node names allow multiple nodes to run [OK]

Common Mistakes:

• Assuming same package means one node only
• Thinking duplicate names cause silent errors
• Believing launch files always cause syntax errors

4. You wrote this launch file snippet:

<launch>
  <node pkg="demo_pkg" type="demo_node" name="node1">
</launch>

What is the error and how to fix it?

medium

A. Missing closing tag for <node>, fix by adding </node>

B. Wrong attribute name 'type', fix by changing to 'exec'

C. Missing package name, fix by adding pkg attribute

D. Extra closing tag needed for <launch>, fix by adding </launch>

Solution

1. Step 1: Check XML tag completeness and verify attributes

   The <node> tag is opened but not closed properly; it needs a closing </node> tag. Attributes pkg and type are correct; <launch> tag is closed properly.

2. Final Answer:

   Missing closing tag for <node>, fix by adding </node> -> Option A

3. Quick Check:

   Unclosed node tag = add </node> [OK]

Hint: Every opened tag must be closed properly [OK]

Common Mistakes:

• Confusing 'type' with 'exec' attribute
• Ignoring missing closing tags
• Assuming launch tag is not closed

5. You want to launch three nodes from different packages in one launch file:

<launch>
  <node pkg="pkg1" type="node1" name="node1" />
  <node pkg="pkg2" type="node2" name="node2" />
  <node pkg="pkg3" type="node3" name="node3" />
</launch>

How can you modify this launch file to add a parameter use_sim_time set to true for all nodes?

hard

A. Add <param name="use_sim_time" value="true" /> inside each <node> tag

B. Add <param name="use_sim_time" value="true" /> directly inside <launch> tag

C. Add <arg name="use_sim_time" default="true" /> inside each <node> tag

D. Add <env name="use_sim_time" value="true" /> inside each <node> tag

Solution

1. Step 1: Understand parameter scope in launch files and compare options

   Parameters placed directly inside <launch> apply globally to all nodes. Adding <param name="use_sim_time" value="true" /> directly inside <launch> sets it once for all; inside each <node> repeats unnecessarily; options B and C use wrong tags (<env>, <arg>).

2. Final Answer:

   Add <param name="use_sim_time" value="true" /> directly inside <launch> tag -> Option B

3. Quick Check:

   Global param inside <launch> = all nodes get it [OK]

Hint: Put common params inside <launch> for all nodes [OK]

Common Mistakes:

• Adding param inside each node causing repetition
• Using <arg> or <env> instead of <param>
• Placing param outside launch tag