Setting parameters from launch file in ROS - Deep Dive

Overview - Setting parameters from launch file

What is it?

Setting parameters from a launch file in ROS means defining configuration values that nodes can use when they start. These parameters can control how nodes behave without changing their code. Launch files are special XML or Python files that start nodes and set these parameters all at once. This makes it easy to manage and customize robot behavior.

Why it matters

Without setting parameters from launch files, you would have to change node code or manually set parameters every time you run your robot. This would be slow, error-prone, and hard to share with others. Using launch files to set parameters saves time, reduces mistakes, and helps teams work together by sharing consistent setups.

Where it fits

Before learning this, you should understand basic ROS concepts like nodes, topics, and parameters. After this, you can learn about dynamic reconfiguration of parameters and advanced launch file features like conditionals and grouping. This topic fits in the middle of learning how to control and customize ROS systems.

Mental Model

Core Idea

A launch file acts like a recipe that sets up all the ingredients (parameters) before cooking (running) the ROS nodes.

Think of it like...

Imagine you are baking a cake. The launch file is the recipe that tells you how much sugar, flour, and eggs to use (parameters) before you start baking (running nodes). Changing the recipe changes the cake without changing the oven or the baking process.

┌───────────────┐
│ Launch File   │
│  ┌─────────┐ │
│  │ Params  │ │
│  └─────────┘ │
│      │       │
│      ▼       │
│  ┌─────────┐ │
│  │  Nodes  │ │
│  └─────────┘ │
└───────────────┘
Parameters flow from launch file into nodes at startup.

Build-Up - 7 Steps

1

Foundation

Understanding ROS Parameters Basics

Concept: Learn what ROS parameters are and how nodes use them.

ROS parameters are like settings stored on a central server called the parameter server. Nodes can read these settings when they start or during runtime. Parameters can be simple values like numbers or strings, or complex structures like lists and dictionaries.

Result

You understand that parameters hold configuration data separate from node code.

Knowing parameters separate configuration from code helps you change behavior without rewriting programs.

2

Foundation

What Launch Files Do in ROS

Concept: Learn the purpose and structure of launch files.

Launch files are XML or Python files that start multiple ROS nodes together. They can also set parameters on the parameter server before nodes start. This lets you prepare the environment all at once.

Result

You see launch files as a way to organize and automate starting your robot system.

Understanding launch files as orchestrators helps you manage complex robot setups easily.

3

Intermediate

Setting Simple Parameters in XML Launch Files

🤔Before reading on: Do you think parameters set in launch files are available immediately to nodes when they start? Commit to yes or no.

Concept: Learn how to define parameters inside XML launch files using the tag.

In XML launch files, you use the tag with attributes like name and value to set parameters. For example: This sets a parameter named 'speed' to 1.5 on the parameter server before nodes start.

Result

Nodes started after this will see the 'speed' parameter with value 1.5.

Knowing parameters are set before node startup ensures nodes can read configuration immediately.

4

Intermediate

Passing Parameters to Nodes in Launch Files

🤔Before reading on: Do you think parameters set globally are automatically passed to all nodes, or do you need to specify them per node? Commit to your answer.

Concept: Learn how to assign parameters specifically to nodes or globally in launch files.

You can set parameters globally using tags outside nodes, or inside a tag to limit scope. For example: This sets 'threshold' only for 'node1'.

Result

Only 'node1' sees the 'threshold' parameter; other nodes do not.

Understanding parameter scope helps avoid conflicts and unexpected behavior.

5

Intermediate

Using YAML Files for Complex Parameters

🤔Before reading on: Do you think launch files can load parameters from external files? Commit to yes or no.

Concept: Learn how to load many parameters at once from YAML files in launch files.

Instead of listing many tags, you can load a YAML file with parameters: This loads all parameters defined in the YAML file onto the parameter server.

Result

All parameters from the YAML file become available to nodes started after loading.

Knowing how to use YAML files makes managing many parameters easier and cleaner.

6

Advanced

Overriding Parameters at Launch Time

🤔Before reading on: Can you override parameters set in YAML files by specifying them later in the launch file? Commit to yes or no.

Concept: Learn how parameter precedence works and how to override parameters when launching.

Parameters loaded later override earlier ones. For example, if you load a YAML file and then set a with the same name, the last value wins. This lets you provide defaults in files and customize per launch.

Result

You can customize parameters flexibly without changing YAML files.

Understanding parameter precedence prevents confusion about which value nodes see.

7

Expert

Dynamic Parameter Setting and Namespaces

🤔Before reading on: Do you think parameters can be set dynamically or grouped under namespaces in launch files? Commit to your answer.

Concept: Learn advanced techniques like using namespaces and dynamic parameter setting in launch files.

You can group parameters under namespaces to organize them: Also, with Python launch files in ROS2, you can set parameters dynamically based on conditions or inputs.

Result

Parameters are organized and can adapt to different robot parts or situations.

Knowing namespaces and dynamic setting helps build scalable and flexible robot systems.

Under the Hood

When a launch file runs, it sends parameter data to the ROS parameter server before starting nodes. The parameter server stores these values centrally. Nodes query this server when they start to get their configuration. If parameters change during runtime, nodes can update their behavior if programmed to watch for changes.

Why designed this way?

ROS uses a central parameter server to separate configuration from code, allowing multiple nodes to share settings easily. Launch files automate setting these parameters to avoid manual errors and to coordinate complex systems. Alternatives like hardcoding parameters would reduce flexibility and increase maintenance.

┌───────────────┐       ┌───────────────────┐
│ Launch File   │──────▶│ Parameter Server  │
└───────────────┘       └───────────────────┘
                               ▲
                               │
                       ┌───────────────┐
                       │    Nodes      │
                       └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think parameters set in launch files can be changed by nodes during runtime? Commit to yes or no.

Common Belief: Parameters set in launch files are fixed and cannot be changed by nodes once running.

Reality: Nodes can read parameters at startup but can also update or read parameters dynamically during runtime if programmed to do so.

Why it matters: Believing parameters are fixed limits the design of adaptable nodes that can react to changing conditions.

Quick: Do you think parameters set globally in a launch file automatically apply to all nodes? Commit to yes or no.

Common Belief: Global parameters in launch files always apply to every node started.

Reality: Global parameters apply unless overridden or scoped by namespaces or node-specific parameters.

Why it matters: Misunderstanding scope can cause nodes to use wrong parameters, leading to bugs.

Quick: Do you think you must write all parameters inside launch files manually? Commit to yes or no.

Common Belief: All parameters must be typed out in launch files using tags.

Reality: You can load parameters from external YAML files, making management easier for many parameters.

Why it matters: Not using YAML files leads to cluttered launch files and harder maintenance.

Quick: Do you think parameters set in launch files override parameters set on the parameter server before launch? Commit to yes or no.

Common Belief: Parameters set in launch files cannot override existing parameters on the server.

Reality: Parameters set later in the launch process override earlier ones, including those already on the server.

Why it matters: Not knowing this can cause confusion about which parameter value nodes actually use.

Expert Zone

1

Parameters can be namespaced to isolate configurations for different robot parts or multiple robots running simultaneously.

2

Parameter precedence depends on the order of loading and scoping, which can cause subtle bugs if misunderstood.

3

In ROS2, launch files can be written in Python, allowing conditional and dynamic parameter setting based on environment or user input.

When NOT to use

Setting parameters from launch files is not ideal for parameters that must change frequently during runtime; use dynamic reconfigure or parameter services instead. Also, for very large parameter sets, consider using configuration management tools outside ROS.

Production Patterns

In real systems, launch files load default parameters from YAML files and override critical ones per deployment using command-line arguments or environment variables. Namespaces organize parameters for multi-robot systems. Python launch files enable conditional logic for flexible deployments.

Connections

Configuration Management

Builds-on

Understanding how launch files set parameters helps grasp broader configuration management practices in software systems.

Dependency Injection

Similar pattern

Setting parameters externally to nodes is like injecting dependencies, allowing flexible and testable code.

Cooking Recipes

Metaphorical parallel

Just as recipes specify ingredients before cooking, launch files specify parameters before running nodes, showing how preparation controls outcomes.

Common Pitfalls

#1 Setting parameters inside a node tag but expecting them to be global.

Wrong approach:

Correct approach:

Root cause:

Misunderstanding parameter scope causes parameters to be invisible to other nodes.

#2 Loading a YAML file with parameters but forgetting to specify the correct file path.

Wrong approach:

Correct approach:

Root cause:

Incorrect file paths cause parameters not to load, leading to missing configuration.

#3 Trying to change parameters by editing launch files while nodes are running.

Wrong approach:

Editing launch file and expecting running nodes to update parameters immediately.

Correct approach:

Use dynamic reconfigure or parameter services to change parameters at runtime.

Root cause:

Confusing static launch-time parameter setting with dynamic runtime configuration.

Key Takeaways

Launch files in ROS let you set parameters before nodes start, separating configuration from code.

Parameters can be set globally, per node, or loaded from YAML files for better organization.

Parameter scope and precedence determine which values nodes actually use, so understanding them prevents bugs.

Advanced launch files support namespaces and dynamic parameter setting for flexible robot systems.

Misunderstanding parameter setting can cause subtle errors, so always verify parameter visibility and loading order.

Practice

1. What is the main purpose of using <param> tags in a ROS launch file?

easy

A. To start multiple nodes at the same time

B. To set parameters that nodes can use when they start

C. To define the order in which nodes run

D. To stop nodes after they finish

Solution

1. Step 1: Understand the role of <param> in launch files

   The <param> tag is used to set parameters that nodes read when they start running.

2. Step 2: Differentiate from other launch file tags

   Tags like <node> start nodes, but <param> specifically sets values nodes use.

3. Final Answer:

   To set parameters that nodes can use when they start -> Option B

4. Quick Check:

   Setting parameters = A [OK]

Hint: Remember: <param> sets values, <node> starts nodes [OK]

Common Mistakes:

• Confusing <param> with <node> tag
• Thinking <param> controls node start/stop
• Assuming <param> sets node execution order

2. Which of the following is the correct syntax to set a string parameter named robot_name to "R2D2" in a ROS launch file?

easy

A.

B.

C.

D.

Solution

1. Step 1: Check the correct attribute names

   The <param> tag requires 'name' for the parameter name and 'value' for its value.

2. Step 2: Verify proper quoting of string values

   String values must be inside quotes, so value="R2D2" is correct.

3. Final Answer:

   <param name="robot_name" value="R2D2" /> -> Option C

4. Quick Check:

   Correct attributes and quotes = B [OK]

Hint: Use name="" and value="" with quotes for strings [OK]

Common Mistakes:

• Missing quotes around string values
• Swapping name and value attributes
• Using incorrect attribute names

3. Given this launch file snippet:

<launch>
  <param name="speed" value="2.5" />
  <node pkg="robot_pkg" type="move_node" name="mover" />
</launch>

What will be the value of the speed parameter inside the move_node when it starts?

medium

A. 2.5 (as a float)

B. 0, the default value

C. Undefined, because parameters must be set inside the node tag

D. "2.5" (as a string)

Solution

1. Step 1: Understand parameter value types in launch files

   Values in <param> tags are treated as strings by default unless explicitly converted in code.

2. Step 2: Check the launch file snippet

   The value is "2.5" in quotes, so the parameter is set as a string "2.5".

3. Final Answer:

   "2.5" (as a string) -> Option D

4. Quick Check:

   Parameter values are strings by default = D [OK]

Hint: Parameter values are strings unless converted in code [OK]

Common Mistakes:

• Assuming numeric values are auto-converted to float
• Thinking parameters must be inside <node> tag
• Believing default values apply if parameter is set

4. Identify the error in this launch file snippet:

<launch>
  <param name="use_sim" value=true />
  <node pkg="sim_pkg" type="sim_node" name="simulator" />
</launch>

medium

A. The value true should be in quotes: value="true"

B. The param tag should be inside the node tag

C. The node tag is missing the required args attribute

D. The launch tag is missing a closing slash

Solution

1. Step 1: Check the value attribute format

   Boolean values in <param> tags must be strings, so true should be "true" in quotes.

2. Step 2: Verify tag placement and syntax

   The <param> tag can be outside the <node> tag, and the <launch> tag is correctly closed.

3. Final Answer:

   The value true should be in quotes: value="true" -> Option A

4. Quick Check:

   Boolean values need quotes in <param> = C [OK]

Hint: Always put boolean values in quotes in <param> tags [OK]

Common Mistakes:

• Leaving boolean values unquoted
• Placing <param> tags only inside <node>
• Misunderstanding launch tag syntax

5. You want to set a parameter max_retries to 5 only if it is not already set by another launch file. Which launch file tag should you use to achieve this?

hard

A.

B. 5

C.

D.

Solution

1. Step 1: Understand conditional parameter setting

   The <param> tag supports the 'unless' attribute to set a parameter only if it is not already set.

2. Step 2: Check the options for correct usage

   <param unless="max_retries" name="max_retries" value="5" /> uses 'unless="max_retries"' with name and value, which is the correct syntax.

3. Final Answer:

   <param unless="max_retries" name="max_retries" value="5" /> -> Option A

4. Quick Check:

   Use 'unless' attribute to avoid overwriting = A [OK]

Hint: Use 'unless' attribute to set param only if unset [OK]

Common Mistakes:

• Omitting the 'name' attribute when using 'unless'
• Using <rosparam> without condition
• Misplacing 'unless' attribute