Dynamic Params

The nav2_dynamic_params package implements a class for the validation of dynamic ROS2 parameters as well as a class which enables tracking and convenient access to dynamic parameters. This package was motivated by the lack of DynamicReconfigure in ROS2, which while not ported, remains an important tool for the handling of dynamic parameters during run-time. Thus, using current ROS2-supported parameter features, this package aims to fill the gap in functionality.

ROS2 Parameters

In ROS2, rather than on a parameter server, parameters are hosted on the nodes themselves. Nodes may get and set their own parameters via the node interface or may create a parameter client to any remote node hosting parameters. By default, any client to a node may get and set parameters to that node. A node, however, may register a callback for parameter change requests and choose to accept or deny such requests based on arbitrary criteria. In this vain, nodes are responsible for the validation of their own parameters. Parameter clients, on the other hand, may register a callback to parameter events from a remote node. Thus, all parameters could be considered by default to be dynamic in ROS2 as anyone can get or set them and receive callbacks.

Dynamic Params Overview

Two classes are implemented to support and extend the functionality of ROS2 parameters: DynamicParamsValidator and DynamicParamsClient

DynamicParamsValidator

• validates parameters against type (using rclcpp::ParameterType)
• validates parameters against specified upper/lower bounds
• allows for providing custom user validation callback
• option to add parameters as static and reject changes
• optional to reject all new parameters

DynamicParamsClient

• adds parameters from any node to be tracked
• registers internal callback to filter events and pass to user-defined callback
• keeps cached map of dynamic parameter changes
• provides interface function calls to access latest parameter change or default value within callback

Example Code

Below is an example of using the DynamicParamsValidator:

auto node = rclcpp::Node::make_shared("example_dynamic_params_validator");

// Create DynamicParamsValidator given node, rejecting new parameters
auto param_validator = new nav2_dynamic_params::DynamicParamsValidator(node, true);

// Add Parameters to Validator
param_validator->add_param("foo", rclcpp::ParameterType::PARAMETER_DOUBLE);
param_validator->add_param("bar", rclcpp::ParameterType::PARAMETER_INTEGER, {0, 10});

// Set Parameters on node
node->set_parameters({rclcpp::Parameter("foo", 2.0), rclcpp::Parameter("bar", 3)});

// Make "foo" a static parameter
param_validator->add_static_params({"foo"});

In the code sample above, the node will be able to validate parameters “foo” and “bar” from requests that violate their respective type and upper and lower bounds, whilst rejecting new parameters to be added. If a paremeter has already been set, either within code or from launch, setting the parameter as static prevents future changes.

For clients of parameters that exist on nodes, whether themselves, or remote, they can use the DynamicParamsClient as below:

```C++

auto node = rclcpp::Node::make_shared(“example_dynamic_params_client”);

// Create DynamicReconfigureClient dynamic_params_client = new nav2_dynamic_params::DynamicParamsClient(node);

// Add parameters by node. Note that there are different ways to add parameters // The namespace must be provided, if applicable dynamic_params_client->add_parameters(“example_node_A”, {“foo”});

// Add all existing parameter on node. If node is not available for service, // then none of its parameters will be registered dynamic_params_client->add_parameters_on_node(“example_node_B”);

// If a parameter is specified but not currently set or node is unavailable, // it will be registered as PARAMETER_NOT_SET. dynamic_params_client->add_parameters(“some_namespace”, “example_node_C”, {“baz”, “bar”});

// without node path, adding only parameters will grab parameters from member node dynamic_params_client->add_parameters({“foobar”, “foobaz”});

// Create a callback for parameter events std::function<void()> callback = this -> void { // Check if a parameter is part of the latest event if (dynamic_params_client->is_in_event(“example_node_B”, “bar”)) { RCLCPP_INFO(rclcpp::get_logger(“example_dynamic_params_client”), “‘example_node_B/bar’ is in this event!”); }

double foo;
dynamic_params_client->get_event_param("example_node_A", "foo", foo);

int bar_B;
dynamic_params_client->get_event_param_or("example_node_B", "bar", bar_B, 2);

int bar_C;
dynamic_params_client->get_event_param_or("some_namespace/example_node_C", "bar", bar_C, 3);

std::string baz;

File truncated at 100 lines see the full file