ROS 2 Parameters Guide 2026declare · YAML · Callbacks · CLI

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from rcl_interfaces.msg import ParameterDescriptor, ParameterType


class MyNode(Node):
    def __init__(self):
        super().__init__("my_node")

        # Declare with default value (type inferred from default)
        self.declare_parameter("speed", 0.5)
        self.declare_parameter("frame_id", "base_link")
        self.declare_parameter("use_sim_time", False)
        self.declare_parameter("sensor_list", ["lidar", "camera"])

        # Declare with descriptor (adds type enforcement + description)
        self.declare_parameter(
            "max_linear_vel",
            0.8,
            ParameterDescriptor(
                type=ParameterType.PARAMETER_DOUBLE,
                description="Maximum forward velocity in m/s",
                read_only=False,
            ),
        )

        # Declare read-only (cannot be changed at runtime)
        self.declare_parameter(
            "robot_name",
            "my_robot",
            ParameterDescriptor(read_only=True),
        )

        # Get parameter values
        speed = self.get_parameter("speed").value
        frame_id = self.get_parameter("frame_id").value
        sensor_list = self.get_parameter("sensor_list").value

        self.get_logger().info(f"speed={speed}, frame={frame_id}")
        self.get_logger().info(f"sensors={sensor_list}")

        # Get multiple parameters at once
        params = self.get_parameters(["speed", "frame_id", "use_sim_time"])
        for p in params:
            self.get_logger().info(f"  {p.name} = {p.value}")


def main():
    rclpy.init()
    node = MyNode()
    rclpy.spin(node)
    rclpy.shutdown()


if __name__ == "__main__":
    main()

from rclpy.node import Node
from rcl_interfaces.msg import SetParametersResult


class MyNode(Node):
    def __init__(self):
        super().__init__("my_node")
        self.declare_parameter("speed", 0.5)
        self.declare_parameter("enabled", True)

        # Register callback — fires on every parameter change
        self.add_on_set_parameters_callback(self._parameter_callback)

    def _parameter_callback(self, params):
        """Validate new parameter values before they take effect."""
        for param in params:
            if param.name == "speed":
                if param.value < 0.0 or param.value > 2.0:
                    return SetParametersResult(
                        successful=False,
                        reason=f"speed must be in [0.0, 2.0], got {param.value}"
                    )
                self.get_logger().info(f"Speed updated to {param.value}")

            if param.name == "enabled":
                self.get_logger().info(
                    f"Node {'enabled' if param.value else 'disabled'}"
                )

        return SetParametersResult(successful=True)

# config/my_robot_params.yaml
my_node:
  ros__parameters:
    speed: 0.5
    frame_id: "base_link"
    use_sim_time: false
    max_linear_vel: 0.8
    sensor_list:
      - "lidar"
      - "camera"
      - "imu"

    # Nested parameters (use dot notation at runtime)
    controller:
      kp: 1.0
      ki: 0.1
      kd: 0.05

nav2_controller:
  ros__parameters:
    controller_frequency: 20.0
    min_x_velocity_threshold: 0.001

# Wildcard — applies to ALL nodes in this YAML
/**:
  ros__parameters:
    use_sim_time: false

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.substitutions import LaunchConfiguration, PathJoinSubstitution
from launch_ros.actions import Node
from launch_ros.substitutions import FindPackageShare


def generate_launch_description():
    params_file = PathJoinSubstitution([
        FindPackageShare("my_robot_bringup"),
        "config",
        "my_robot_params.yaml",
    ])

    return LaunchDescription([
        # Allow overriding config at launch time
        DeclareLaunchArgument(
            "params_file",
            default_value=params_file,
            description="Path to parameter YAML file",
        ),

        Node(
            package="my_robot",
            executable="my_node",
            name="my_node",
            output="screen",
            parameters=[
                LaunchConfiguration("params_file"),
                # Inline overrides (applied after YAML)
                {"use_sim_time": False},
            ],
        ),
    ])

# List all parameters of a node
ros2 param list /my_node

# Get a specific parameter value
ros2 param get /my_node speed

# Set a parameter at runtime
ros2 param set /my_node speed 1.2

# Set multiple parameters
ros2 param set /my_node speed 1.2 frame_id base_footprint

# Dump all parameters to YAML
ros2 param dump /my_node

# Dump to a file
ros2 param dump /my_node --output-dir /tmp/

# Load parameters from a YAML file at runtime
ros2 param load /my_node /path/to/params.yaml

# Delete a parameter (if deletable)
ros2 param delete /my_node speed

# Override parameters at node launch
ros2 run my_robot my_node \
  --ros-args \
  -p speed:=1.5 \
  -p frame_id:=odom \
  -p use_sim_time:=true \
  -p sensor_list:="['lidar', 'imu']"

# Load YAML file and then override one value
ros2 run my_robot my_node \
  --ros-args \
  --params-file /path/to/params.yaml \
  -p speed:=0.2

# In a launch file, override with args
ros2 launch my_robot_bringup bringup.launch.py \
  params_file:=/custom/params.yaml \
  use_sim_time:=true