Ros2 Parameter Tuning

Step-by-Step Workflows

Workflow 1: Create Parameter YAML File

Create a parameter configuration file for node initialization.

1. Create config directory in package:

   mkdir -p <workspace_root>/packages/runtime/<package_name>/config
   

2. Create parameter file (e.g., config/robot_params.yaml):

   # Node name with double wildcard for namespace flexibility
   /**:
     ros__parameters:
       # Robot identification
       robot_name: "Dr.QP"
       robot_id: 1
       
       # Control parameters
       control_frequency: 50.0
       max_velocity: 1.5
       max_acceleration: 0.5
       
       # Safety limits
       enable_safety: true
       emergency_stop_enabled: true
       
       # Communication settings
       serial_port: "/dev/ttyUSB0"
       baudrate: 115200
       timeout_ms: 1000
       
       # Arrays
       joint_names: ["joint1", "joint2", "joint3", "joint4"]
       position_limits: [0.0, 180.0, 0.0, 180.0]
   

3. Install config directory in CMakeLists.txt:

   install(DIRECTORY config
     DESTINATION share/${PROJECT_NAME}
   )
   

4. Rebuild package:

   colcon build --packages-select <package_name> --symlink-install
   

5. Load parameters in launch file:

   import os
   from ament_index_python.packages import get_package_share_directory
   
   params_file = os.path.join(
       get_package_share_directory('<package_name>'),
       'config',
       'robot_params.yaml'
   )
   
   node = Node(
       package='<package_name>',
       executable='<node_name>',
       parameters=[params_file]
   )
   

When to use: Initial node configuration, environment-specific settings

Workflow 2: View and List Node Parameters

Inspect current parameter values of running nodes.

1. List all running nodes:

   ros2 node list
   

2. List all parameters for a specific node:

   ros2 param list /<node_name>
   

3. Get value of a specific parameter:

   ros2 param get /<node_name> <parameter_name>
   

4. Get all parameters in YAML format:

   ros2 param dump /<node_name>
   

5. Save parameters to file:

   ros2 param dump /<node_name> --output-dir ./config/
   

When to use: Inspecting runtime configuration, debugging parameter issues

Workflow 3: Update Parameters at Runtime

Change node parameters dynamically without restarting.

1. Set a single parameter:

   ros2 param set /<node_name> <parameter_name> <value>
   

   Examples:

   ros2 param set /controller max_velocity 2.0
   ros2 param set /serial_driver baudrate 115200
   ros2 param set /robot enable_safety true
   

2. Verify parameter was updated:

   ros2 param get /<node_name> <parameter_name>
   

3. Load multiple parameters from file:

   ros2 param load /<node_name> <params_file>.yaml
   

4. Monitor parameter changes in real-time (if node publishes them):

   ros2 topic echo /parameter_events
   

Important: Not all parameters support runtime updates. Some nodes require restart for changes to take effect.

When to use: Tuning control parameters, testing different configurations

Workflow 4: Parameter Namespace Management

Organize parameters using namespaces for multi-robot systems.

1. Create namespaced parameter file (config/robot1_params.yaml):

   /robot1/**:
     ros__parameters:
       robot_name: "robot1"
       max_velocity: 1.5
       
   /robot2/**:
     ros__parameters:
       robot_name: "robot2"
       max_velocity: 2.0
   

2. Launch nodes with namespaces:

   robot1_node = Node(
       package='<package>',
       executable='<node>',
       name='controller',
       namespace='robot1',
       parameters=[params_file]
   )
   
   robot2_node = Node(
       package='<package>',
       executable='<node>',
       name='controller',
       namespace='robot2',
       parameters=[params_file]
   )
   

3. Access namespaced parameters:

   ros2 param get /robot1/controller max_velocity
   ros2 param get /robot2/controller max_velocity
   

4. Update namespaced parameters:

   ros2 param set /robot1/controller max_velocity 1.8
   

When to use: Multi-robot systems, component reuse with different configs

Workflow 5: Validate Parameter File Syntax

Check parameter files for syntax errors before using them.

1. Attempt to parse YAML file with Python:

   python3 -c "import yaml; yaml.safe_load(open('config/params.yaml'))"
   

2. Check for common YAML errors:

   • Consistent indentation (use spaces, not tabs)
   • Proper quoting of strings with special characters
   • Correct list syntax [item1, item2] or multi-line
   • Boolean values: true/false (lowercase)

3. Test parameter file by loading into a running node:

   ros2 param load /<node_name> config/params.yaml
   

4. Check for parameter type mismatches in node logs:

   ros2 run <package> <executable> --ros-args --log-level debug
   

When to use: Before committing parameter files, debugging load issues

Workflow 6: Declare and Use Parameters in Node Code

Define parameters in your ROS 2 node implementation.

C++ Example:

class MyNode : public rclcpp::Node
{