Conditional launching in ROS - Deep Dive

Overview - Conditional launching

What is it?

Conditional launching in ROS means starting certain parts of a robot program only if specific conditions are true. Instead of running everything all the time, you tell the system to check some rules first. If the rules pass, then the program piece runs. This helps make robot programs smarter and more efficient.

Why it matters

Without conditional launching, robot programs would always run all parts, wasting time and resources. This could slow down the robot or cause errors if some parts run when they shouldn't. Conditional launching lets the robot only start what it really needs, making it faster, safer, and easier to manage.

Where it fits

Before learning conditional launching, you should know how to write basic ROS launch files and understand nodes and parameters. After mastering conditional launching, you can explore advanced launch features like event handlers and dynamic reconfiguration to build flexible robot systems.

Mental Model

Core Idea

Conditional launching is like setting a gate that only opens to start a program part when certain rules are met.

Think of it like...

Imagine a smart home where lights turn on only if someone is in the room and it's dark outside. The lights don't waste energy by always being on. Conditional launching works the same way for robot programs.

╔════════════════════╗
║   Launch File      ║
╠════════════════════╣
║ Condition Check    ║───No──▶ Skip Node
║ (e.g., param true?)║
║        │           ║
║       Yes          ║
║        │           ║
║   Start Node       ║
╚════════════════════╝

Build-Up - 7 Steps

1

Foundation

Understanding ROS launch files

Concept: Learn what a ROS launch file is and how it starts nodes.

A ROS launch file is an XML or Python file that tells ROS which nodes to start and with what settings. It helps run many nodes together easily. For example, you can start a camera node and a robot controller node with one command.

Result

You can start multiple robot parts with a single command using a launch file.

Knowing launch files is essential because conditional launching builds on controlling which nodes start and when.

2

Foundation

Basics of ROS parameters

Concept: Learn how parameters store values that nodes can read to decide behavior.

ROS parameters are like settings stored on a server. Nodes can ask for these values to know how to behave. For example, a parameter can say if the robot is in simulation or real mode.

Result

You can change node behavior by changing parameters without rewriting code.

Parameters are the common way to pass conditions that control launching decisions.

3

Intermediate

Using <if> tags in XML launch files

🤔Before reading on: do you think tags can start nodes only when a parameter is true or do they always start nodes?

Concept: Learn how to use the tag to conditionally include nodes in launch files.

In ROS XML launch files, you can wrap nodes inside tags that check a parameter. If the parameter is true, the node starts; if false, it doesn't. Example:

Result

Nodes only start if the condition inside is true.

Using tags lets you control which nodes run without changing the launch file structure.

4

Intermediate

Conditional launching with Python launch files

🤔Before reading on: do you think Python launch files can use normal Python if statements to control node launching?

Concept: Learn how Python launch files use real Python code to decide which nodes to start.

ROS 2 supports Python launch files where you write Python code. You can use if statements to check conditions and add nodes only when needed. Example: from launch import LaunchDescription from launch_ros.actions import Node def generate_launch_description(): use_camera = True ld = LaunchDescription() if use_camera: ld.add_action(Node(package='camera_pkg', executable='camera_node')) return ld

Result

Nodes start only if Python conditions are true, giving more flexibility.

Python launch files allow complex logic for conditional launching beyond simple parameters.

5

Intermediate

Using launch arguments for conditions

🤔Before reading on: do you think launch arguments can be changed at runtime or only before launching?

Concept: Learn how launch arguments let users pass conditions when starting the launch file.

Launch arguments are like input options you give when running a launch file. You can define arguments and use them in conditions. For example, you can run: ros2 launch my_launch.py use_camera:=true and inside the launch file, check this argument to decide if the camera node starts.

Result

Users can control which nodes start without editing launch files.

Launch arguments make conditional launching flexible and user-friendly.

6

Advanced

Combining conditions with event handlers

🤔Before reading on: do you think event handlers can start nodes only at launch or also during runtime?

Concept: Learn how event handlers can start or stop nodes based on events and conditions during launch or runtime.

Event handlers in ROS launch let you react to events like node start or exit. You can combine them with conditions to launch nodes only after certain events happen. For example, start a sensor node only after the robot controller node is ready.

Result

You get dynamic control over node launching based on system state.

Event handlers extend conditional launching to reactive and sequential workflows.

7

Expert

Conditional launching internals and pitfalls

🤔Before reading on: do you think conditions are evaluated once at launch or continuously during runtime?

Concept: Understand when and how conditions are evaluated and common mistakes that cause unexpected behavior.

Conditions in launch files are evaluated once when the launch starts. They do not change during runtime unless you restart the launch. This means changing a parameter after launch won't start or stop nodes automatically. Also, mixing XML and Python launch files requires care to keep conditions consistent.

Result

You avoid bugs where nodes don't start or stop as expected after launch.

Knowing condition evaluation timing prevents common errors and helps design reliable launch systems.

Under the Hood

Conditional launching works by the launch system reading parameters or arguments before starting nodes. It evaluates conditions as boolean expressions. If true, the launch system creates and starts the node process; if false, it skips it. In Python launch files, conditions are normal Python code executed during launch file parsing. In XML, conditions are evaluated by substituting arguments and parameters before node creation.

Why designed this way?

ROS launch files were designed to simplify starting many nodes together. Adding conditional launching lets users avoid writing many separate launch files for different scenarios. The design balances simplicity (XML syntax) and flexibility (Python launch files). Alternatives like runtime node control were avoided to keep launch files declarative and predictable.

╔══════════════════════╗
║ Launch System        ║
╠══════════════════════╣
║ 1. Read launch file  ║
║ 2. Evaluate conditions║
║    - Parameters      ║
║    - Arguments       ║
║ 3. For each node:    ║
║    if condition true ║
║      start node      ║
║    else skip node    ║
╚══════════════════════╝

Myth Busters - 4 Common Misconceptions

Quick: do you think conditions in launch files can change after the launch starts? Commit yes or no.

Common Belief: Conditions in launch files are checked continuously during runtime, so nodes start or stop automatically when parameters change.

Reality: Conditions are evaluated only once at launch time. Changing parameters later does not affect running nodes.

Why it matters: Expecting dynamic behavior leads to confusion and bugs when nodes don't start or stop as expected after launch.

Quick: do you think you can use any Python code inside XML launch files? Commit yes or no.

Common Belief: You can write Python logic inside XML launch files to control node launching.

Reality: XML launch files only support limited substitution and simple conditions, not full Python code.

Why it matters: Trying to add complex logic in XML causes errors and limits flexibility.

Quick: do you think launch arguments can be changed inside a running launch file? Commit yes or no.

Common Belief: Launch arguments can be modified during runtime to change which nodes run.

Reality: Launch arguments are fixed at launch start and cannot be changed while running.

Why it matters: Misunderstanding this leads to attempts to dynamically control nodes via arguments, which fails.

Quick: do you think conditional launching can replace all runtime node management? Commit yes or no.

Common Belief: Conditional launching can fully control node lifecycle during robot operation.

Reality: Conditional launching only controls node start at launch time, not runtime lifecycle management.

Why it matters: Relying solely on conditional launching for runtime control limits robot flexibility and can cause failures.

Expert Zone

1

Conditions in Python launch files can use complex logic, including reading environment variables or files, enabling highly dynamic launches.

2

Combining multiple conditions with logical operators requires careful ordering to avoid unexpected node starts or skips.

3

Event handlers can be chained with conditions to create sophisticated launch sequences that react to node states.

When NOT to use

Conditional launching is not suitable for controlling nodes after launch. For runtime control, use node lifecycle management or dynamic reconfiguration tools instead.

Production Patterns

In real robots, conditional launching is used to select hardware drivers based on detected hardware, enable debug nodes only in development, and start simulation nodes only when running in simulation mode.

Connections

Feature Flags in Software Development

Conditional launching is similar to feature flags that enable or disable software features based on conditions.

Understanding feature flags helps grasp how conditional launching controls which parts of a system run, improving flexibility and testing.

Event-Driven Programming

Conditional launching combined with event handlers builds on event-driven principles to start nodes based on system events.

Knowing event-driven programming clarifies how launch files can react dynamically to robot state changes.

Traffic Light Control Systems

Both use conditions to decide actions: traffic lights change signals based on sensors and timers, just like launch files start nodes based on parameters.

Seeing conditional launching as a control system helps understand its role in managing complex robot behaviors.

Common Pitfalls

#1 Trying to change a parameter after launch to start a node that was skipped.

Wrong approach:

ros2 param set /launch use_camera true

Correct approach:

Restart the launch file with the parameter set to true before launch.

Root cause:

Misunderstanding that conditions are only checked once at launch time, not continuously.

#2 Using complex Python code inside an XML launch file's condition.

Wrong approach:

Correct approach:

Use simple parameter or argument substitution in XML, or switch to Python launch files for complex logic.

Root cause:

Confusing XML launch file syntax limitations with Python launch file capabilities.

#3 Assuming launch arguments can be changed during runtime to affect node launching.

Wrong approach:

ros2 launch my_launch.py use_camera:=false
Then later try to set use_camera to true without restart.

Correct approach:

Set launch arguments correctly before starting the launch file; restart to apply changes.

Root cause:

Not knowing launch arguments are fixed at launch start.

Key Takeaways

Conditional launching lets you start robot program parts only when needed, saving resources and improving control.

Conditions in launch files are evaluated once at launch time, so changes after launch do not affect running nodes.

XML launch files support simple conditional tags, while Python launch files allow full programming logic for flexible launches.

Launch arguments let users control conditions without editing launch files, but they must be set before launch.

For runtime node control, use other ROS tools; conditional launching is for launch-time decisions only.

Practice

1. What is the main purpose of using conditional launching in ROS launch files?

easy

A. To update ROS to the latest version

B. To speed up the robot's movement

C. To change the robot's hardware automatically

D. To start nodes only when certain conditions are met

Solution

1. Step 1: Understand conditional launching concept

   Conditional launching allows starting nodes only if specific conditions are true, saving resources.

2. Step 2: Identify the main purpose

   The main goal is to control which nodes run based on conditions, not to affect hardware or speed directly.

3. Final Answer:

   To start nodes only when certain conditions are met -> Option D

4. Quick Check:

   Conditional launching = start nodes conditionally [OK]

Hint: Think: conditional launching controls node start based on conditions [OK]

Common Mistakes:

• Confusing conditional launching with robot speed control
• Thinking it updates hardware automatically
• Assuming it updates ROS version

2. Which syntax correctly uses IfCondition in a ROS 2 Python launch file to conditionally start a node?

easy

A. Node(if='launch_arg == true', package='pkg', executable='node')

B. Node(condition=IfCondition(launch_arg == true), package='pkg', executable='node')

C. Node(condition=IfCondition('launch_arg == "true"'), package='pkg', executable='node')

D. Node(condition=IfCondition('launch_arg = true'), package='pkg', executable='node')

Solution

1. Step 1: Recall correct IfCondition usage

   IfCondition expects a string expression comparing launch arguments, e.g., 'launch_arg == "true"'.

2. Step 2: Check each option's syntax

   Node(condition=IfCondition('launch_arg == "true"'), package='pkg', executable='node') uses correct string comparison and quotes. Others have syntax errors or wrong operators.

3. Final Answer:

   Node(condition=IfCondition('launch_arg == "true"'), package='pkg', executable='node') -> Option C

4. Quick Check:

   IfCondition needs string expression with == [OK]

Hint: Use quotes around condition string and double equals for comparison [OK]

Common Mistakes:

• Using single equals (=) instead of double equals (==)
• Not quoting the condition expression
• Passing boolean directly instead of string

3. Given this launch snippet, what nodes will start if the launch argument use_camera is set to false?

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.conditions import IfCondition
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        DeclareLaunchArgument('use_camera', default_value='false'),
        Node(
            package='camera_pkg',
            executable='camera_node',
            condition=IfCondition('use_camera == "true"')
        ),
        Node(
            package='lidar_pkg',
            executable='lidar_node'
        )
    ])

medium

A. Only lidar_node starts

B. Both camera_node and lidar_node start

C. Only camera_node starts

D. No nodes start

Solution

1. Step 1: Analyze the condition for camera_node

   camera_node starts only if 'use_camera' equals 'true'. Here, 'use_camera' is 'false', so it won't start.

2. Step 2: Check lidar_node launch condition

   lidar_node has no condition, so it always starts.

3. Final Answer:

   Only lidar_node starts -> Option A

4. Quick Check:

   Condition false skips camera_node, lidar_node always runs [OK]

Hint: Nodes without conditions always start; check condition expressions carefully [OK]

Common Mistakes:

• Assuming camera_node starts when use_camera is false
• Thinking no nodes start if condition fails
• Ignoring unconditional nodes

4. Identify the error in this ROS 2 launch file snippet that prevents conditional launching from working:

Node(
    package='my_pkg',
    executable='my_node',
    condition=IfCondition(use_sensor == 'true')
)

medium

A. IfCondition cannot be used with Node

B. use_sensor should be a string inside quotes

C. Missing package name

D. Executable name must be capitalized

Solution

1. Step 1: Check IfCondition argument type

   IfCondition expects a string expression, but here use_sensor is used as a variable without quotes.

2. Step 2: Confirm correct syntax

   The condition should be written as IfCondition('use_sensor == "true"') with quotes around the expression.

3. Final Answer:

   use_sensor should be a string inside quotes -> Option B

4. Quick Check:

   IfCondition needs string condition expression [OK]

Hint: Always quote condition expressions in IfCondition [OK]

Common Mistakes:

• Passing variable without quotes to IfCondition
• Thinking IfCondition is invalid with Node
• Ignoring case sensitivity in executable

5. You want to launch either sim_node or real_node based on a launch argument use_sim. Which launch snippet correctly implements this conditional launching in ROS 2 Python launch file?

hard

A. Node(package='robot_pkg', executable='sim_node', condition=IfCondition('use_sim == "true"'))
Node(package='robot_pkg', executable='real_node', condition=IfCondition('use_sim == "false"'))

B. Node(package='robot_pkg', executable='sim_node', condition=IfCondition(use_sim == true))
Node(package='robot_pkg', executable='real_node', condition=IfCondition(use_sim == false))

C. Node(package='robot_pkg', executable='sim_node')
Node(package='robot_pkg', executable='real_node')

D. Node(package='robot_pkg', executable='sim_node', condition=IfCondition('use_sim = true'))
Node(package='robot_pkg', executable='real_node', condition=IfCondition('use_sim = false'))

Solution

1. Step 1: Check condition syntax for sim_node

   Node(package='robot_pkg', executable='sim_node', condition=IfCondition('use_sim == "true"')) Node(package='robot_pkg', executable='real_node', condition=IfCondition('use_sim == "false"')) uses correct string expressions with double equals and quotes for 'use_sim == "true"'.

2. Step 2: Check condition syntax for real_node

   Node(package='robot_pkg', executable='sim_node', condition=IfCondition('use_sim == "true"')) Node(package='robot_pkg', executable='real_node', condition=IfCondition('use_sim == "false"')) also correctly uses 'use_sim == "false"' for real_node, ensuring only one node launches.

3. Step 3: Verify other options

   Node(package='robot_pkg', executable='sim_node', condition=IfCondition(use_sim == true)) Node(package='robot_pkg', executable='real_node', condition=IfCondition(use_sim == false)) lacks quotes and uses booleans incorrectly; Node(package='robot_pkg', executable='sim_node') Node(package='robot_pkg', executable='real_node') launches both nodes unconditionally; Node(package='robot_pkg', executable='sim_node', condition=IfCondition('use_sim = true')) Node(package='robot_pkg', executable='real_node', condition=IfCondition('use_sim = false')) uses single equals (=) which is invalid.

4. Final Answer:

   Option A correctly uses IfCondition with string expressions and double equals -> Option A

5. Quick Check:

   Use quotes and == for conditions to launch nodes selectively [OK]

Hint: Use '==' inside quotes for conditions; avoid single '=' [OK]

Common Mistakes:

• Using single equals (=) instead of double equals (==)
• Not quoting the condition expression
• Launching both nodes without conditions