roscpp/Overview/Parameter Server

Contents

Getting Parameters
1. Cached Parameters
Setting Parameters
Checking Parameter Existence
Deleting Parameters
Accessing Private Parameters
Searching for Parameter Keys
Retrieving Lists

The ROS Parameter Server can store strings, integers, floats, booleans, lists, dictionaries, iso8601 dates, and base64-encoded data. Dictionaries must have string keys.

roscpp's parameter API supports all of these, though it is only easy to use strings, integers, floats and booleans. Support for the other options is done using the XmlRpc::XmlRpcValue class

roscpp has two different parameter APIs: the "bare" versions which live in the ros::param namespace, and the "handle" versions which are called through the ros::NodeHandle interface. Both versions will be explained for each operation below.

Getting Parameters

Fetch a value from the parameter server. Each version supports strings, integers, doubles, booleans and XmlRpc::XmlRpcValues. false is returned if the parameter does not exist, or is not of the right type. There is also a version that returns a default value.

ros::NodeHandle::getParam()

Parameters retrieved through the NodeHandle version are resolved relative to that NodeHandle's namespace. See the roscpp NodeHandles overview for more information.
```
   1 ros::NodeHandle nh;
   2 std::string global_name, relative_name, default_param;
   3 if (nh.getParam("/global_name", global_name))
   4 {
   5   ...
   6 }
   7 
   8 if (nh.getParam("relative_name", relative_name))
   9 {
  10 ...
  11 }
  12 
  13 // Default value version
  14 nh.param<std::string>("default_param", default_param, "default_value");
```

ros::param::get()

Parameters retrieved through the "bare" version are resolved relative to the node's namespace.

   1 std::string global_name, relative_name, default_param;
   2 if (ros::param::get("/global_name", global_name))
   3 {
   4   ...
   5 }
   6 
   7 if (ros::param::get("relative_name", relative_name))
   8 {
   9 ...
  10 }
  11 
  12 // Default value version
  13 ros::param::param<std::string>("default_param", default_param, "default_value");

Cached Parameters

ros::NodeHandle::getParamCached() and ros::param::getCached() provide local caching of parameter data. Using these versions informs the Parameter Server that this node would like to be notified when the parameter is changed, and prevents the node from having to re-lookup the value with the parameter server on subsequent calls.

Cached parameters are a significant speed increase (after the first call), but should be used sparingly to avoid overloading the master. Cached parameters are also currently less reliable in the case of intermittent connection problems between your node and the master.

Setting Parameters

Similar to getting parameters, each version supports strings, integers, doubles, booleans and XmlRpc::XmlRpcValues.

ros::NodeHandle::setParam()

Parameters retrieved through the NodeHandle version are resolved relative to that NodeHandle's namespace. See the roscpp NodeHandle overview for more information.
```
   1 ros::NodeHandle nh;
   2 nh.setParam("/global_param", 5);
   3 nh.setParam("relative_param", "my_string");
   4 nh.setParam("bool_param", false);
```

ros::param::set()

Parameters retrieved through the "bare" version are resolved relative to the node's namespace.
```
   1 ros::param::set("/global_param", 5);
   2 ros::param::set("relative_param", "my_string");
   3 ros::param::set("bool_param", false);
```

Checking Parameter Existence

ros::NodeHandle::hasParam()

```
   1 ros::NodeHandle nh;
   2 if (nh.hasParam("my_param"))
   3 {
   4   ...
   5 }
```

ros::param::has()

```
   1 if (ros::param::has("my_param"))
   2 {
   3   ...
   4 }
```

Deleting Parameters

ros::NodeHandle::deleteParam()

```
   1 ros::NodeHandle nh;
   2 nh.deleteParam("my_param");
```

ros::param::del()

```
   1 ros::param::del("my_param");
```

Accessing Private Parameters

Accessing private parameters is done differently depending on whether you're using the "handle" or "bare" interfaces. In the handle interface you must create a new ros::NodeHandle with the private namespace as its namespace:

   1 ros::NodeHandle nh("~");
   2 std::string param;
   3 nh.getParam("private_name", param);

In the bare interface you can access private parameters with the same notation used to describe them, e.g.:

   1 std::string param;
   2 ros::param::get("~private_name", param);

Searching for Parameter Keys

There are times where you want to get a parameter from the closest namespace. For example, if you have a "robot_name" parameter, you just want to search upwards from your private namespace until you find a matching parameter. Similarly, if you have a group of camera nodes, you may wish to set some parameters commonly in a shared namespace but override others by setting them in a private (~name) namespace.

Note: in order to use search effectively, you should use it with relative names instead of /global and ~private names.

ros::NodeHandle::searchParam()

```
   1 std::string key;
   2 if (nh.searchParam("bar", key))
   3 {
   4   std::string val;
   5   nh.getParam(key, val);
   6 }
```

ros::param::search()

```
   1 std::string key;
   2 if (ros::param::search("bar", key))
   3 {
   4   std::string val;
   5   ros::param::get(key, val);
   6 }
```

Retrieving Lists

Lists on the parameter server are retreived through the use of the XmlRpc::XmlRpcValue class, which can represent any of the types on the parameter server.

   1 XmlRpc::XmlRpcValue my_list;
   2 nh.getParam("my_list", my_list);
   3 ROS_ASSERT(my_list.getType() == XmlRpc::XmlRpcValue::TypeArray);
   4 
   5 for (int32_t i = 0; i < my_list.size(); ++i) 
   6 {
   7   ROS_ASSERT(my_list[i].getType() == XmlRpc::XmlRpcValue::TypeDouble);
   8   sum += static_cast<double>(my_list[i]);
   9 }

Wiki

Page

User