Arguments, ROS Arguments and Node Parameters

A collection of my personal notes.

Content Outline

    This note can be condense in:

    ros2 run <package> <executable> <arguments> --ros-args <ros_arguments> -r <remap> -p <set parameter>

    Arguments

    user-defined arguments or executable arguments.

    ROS Arguments

    --ros-args:

    • --log-level LEVEL:
    • --remap or -r: name remapping. see Remapping Names - ROS 2 Design↗
      • __ns: changes the default namespace
      • __name or __node: changes node name
    • --param or -p: single parameter assignment.
      • param_name:=param_value
    • --params-file path/to/file.yaml

    Functional Demo

    parameters.py 
    import sys
import argparse

import rclpy
from rclpy.executors import ExternalShutdownException
from rclpy.node import Node
from rclpy.utilities import remove_ros_args
from demo_interfaces.msg import Counter

def parse_executable_args(argv):
    parser = argparse.ArgumentParser(description="Simple ROS 2 Parametrized node")
    parser.add_argument("--verbose", default=False, help="Show extra debugging information.", action='store_true')
    return parser.parse_args(remove_ros_args(argv)[1:])

class ParameterNode(Node):

    def __init__(self, verbose: bool = False):
        super().__init__("counter")

        self.declare_parameter("topic", "/counter")
        self.declare_parameter("initial_value", 0)
        self.declare_parameter("hz", 2)

        param_topic = str(self.get_parameter("topic").value)
        param_period_sec = 1/(float(self.get_parameter("hz").value))
        param_initial_value = float(self.get_parameter("initial_value").value)

        if verbose:
            self.get_logger().info(f"topic: {param_topic}")
            self.get_logger().info(f"initial_value: {param_initial_value}")
            self.get_logger().info(f"hz: {float(self.get_parameter('hz').value)}")

        # Note: Our Counter.msg is expecting a int64 value
        self.__count = int(param_initial_value)

        self.__pub = self.create_publisher(Counter, param_topic, 10)

        timer = self.create_timer(param_period_sec, self.callback)

    def callback(self):
        msg = Counter()
        msg.count = self.__count
        self.__pub.publish(msg)
        self.get_logger().info(f"Publishing count: {self.__count}")
        self.__count += 1

def main(argv=None):

    argv = sys.argv if argv is None else argv

    exec_args = parse_executable_args(argv)

    rclpy.init(args=argv)

    node = ParameterNode(exec_args.verbose)

    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        rclpy.try_shutdown()


if __name__ == "__main__":
    main()

    Parameters 

    NOT_SET
BOOL
INTEGER
DOUBLE
STRING
BYTE_ARRAY
BOOL_ARRAY
INTEGER_ARRAY
DOUBLE_ARRAY
STRING_ARRAY

ParameterDescriptor
ParameterType
FloatingPointRange
IntegerRange

Parameter(name, type_=None, value=None)

    Application of Parameters

    TODO: add list of real-world examples of parameters

    Declare, Get and Set Parameters

    node parameters

    declare_parameter(name, value=None, descriptor=None, ignore_override=False)
declare_parameters(namespace, parameters)

undeclare_parameter(name)
has_parameter(name)

get_parameter(name)
get_parameters(names)
get_parameters_by_prefix(prefix)
get_parameter_type(name)

describe_parameter(name)
describe_parameters(name)

set_parameters(parameter_list)
set_parameters_atomically(parameter_list) -> List[SetParametersResult]

    Parameters Callbacks 

    add_on_set_parameters_callback(callback)

def callback(params: List[Parameters]) -> SetParametersResult:

remove_on_set_parameters_callback(callback)

    Parameters Events

    Parameter Client

    Get parameters from other nodes

    AsyncParameterClient(node, remote_node_name)

get_parameters(names)
set_parameters(parameters)

list_parameters(prefixes, depth)
describe_parameters(names)
delete_parameters(names)

    External References