What is Dynamic Reconfigure ?

Dynamic reconfigure provides a standard way to alter a node's parameters during runtime. It let's us make nodes who's properties can be adjusted during execution. Even better, it also provides a GUI to make these modifications.

Let's see how to make one of these configurations

Making a configuration file

These files tell how the GUI window must be made, what all it must consist of and options for all the things that it must consist of. This file has a ".cfg" extension, is stored in a directory named "cfg" inside the package and is programmed using Python (not C++). Here's how you go about making a configuration file:

1. Create a folder named cfg inside the package if there isn't one yet. Use the following commands on a terminal:
   • roscd intro_pkg1
   • mkdir cfg
   • cd cfg
2. Create a file named Sample.cfg in the cfg folder.
   • You can pick any name. We'll see later how to program it.
3. Make the ".cfg" file executable. Run the following on the terminal that we just opened:
   • chmod +x Sample.cfg
   • cd ../
4. Open the CMakeLists.txt file of the package and make the following amendments:
   • Add dynamic_reconfigure to the list inside function find_packages.
   • Scroll down to "Declare ROS dynamic reconfigure parameters" section and uncomment the function "generate_dynamic_reconfigure_options" and add the line "cfg/Sample.cfg" inside it (basically give the path and fullname of the configuration file).
5. Open the package.xml file of the package and add the following lines at appropriate places:
   • <build_depend>dynamic_reconfigure</build_depend>
   • <build_export_depend>dynamic_reconfigure</build_export_depend>
   • <exec_depend>dynamic_reconfigure</exec_depend>
6. Write the following in the file "Sample.cfg". There's a sample on GitHub, here. Here's how you code a configuration file:
   • Since it's written in python, write the first line that every ROS python script has ("#!/usr/bin/env python").
   • Create a variable named PACKAGE and assign it the package name. This is required for the header file that you're going to import in the next step.
   • Import all files from dynamic_reconfigure.parameter_generator_catkin. These contain code for parameter generators, they can be found locally on your system at the path "/opt/ros/melodic/lib/python2.7/dist-packages/dynamic_reconfigure".
   • Create a ParameterGenerator object
   • Use the add member function to add parameters. Pass it the following arguments:
     • name: Name of the parameter to be displayed. Do not use reserved keywords here, though it's a string.
     • paramtype: The data type of the parameter, this is either int_t, double_t, str_t, or bool_t
     • level: A bitmask which will later be passed to the dynamic reconfigure callback. When the callback is called all of the level values for parameters that have been changed are ORed together and the resulting value is passed to the callback. We keep it 0 for most uses.
     • description string: A description of the parameter
     • default value of the parameter
     • min and max values of the parameter. By default they're none and should be none for String and Bool parameters.
     • edit_method is the way we want to edit the parameter. List (dropdown) or standard. Don't assign it if not a dropdown.
   • To add dropdown menus, use the enum member function. Pass it the following arguments:
     • List of constants defined using const member function. Pass every entry the following parameters:
       • name
       • type
       • value
       • description
     • Description message for the entire list
     • After the enumerated list is created, use the add member function to add the list. Assign the list created to the edit method.
   • End the config file using the generate function. Pass it the following parameters:
     • pkgname: Package name
     • nodename: Node name of the configuration file
     • name: Name prefix to generate headers. It's suffixed with "Config" and a ".h" for C++ and ".py" for Python

Building the configuration file

1. Open a terminal
2. Build the package. Run the following commands:
   • cd ~/ROS_workspaces/ros_ws/
   • catkin_make

After the entire process has finished, you'll observe that the following files have been created:

• ros_ws/devel/include/intro_pkg1/SampleConfig.h
• ros_ws/devel/lib/python2.7/dist-packages/intro_pkg1/cfg/SampleConfig.py

These are header file used by nodes that want to use these particular dynamic reconfiguration parameters.

Dynamic Configuration for a C++ Node

Coding the node

Follow the following steps to make a C++ node for using the dynamic reconfiguration window:

1. Include all header files
   • For ROS
   • "dynamic_reconfigure/server.h" for the dynamic reconfiguration server
   • The generated configuration file
2. Create a callback function that will be called whenever any parameters change. It must have two arguments, a reference of configuration class and an unsigned 32 bit integer as the level.
3. In the main function
   • Initialize the node
   • Declare a server object from dynamic reconfigure header file
   • Create a callback type of the server
     • Create a separate server callback object
     • bind the callback using boost::bind, pass it the reference to the callback function and '_1' and '_2' as placeholders for the two arguments
   • Spin the node or go into spinning mode periodically to scan the reconfigurations

Building the node

Make the following amendments to the CMakeLists.txt file:

• Add an executable for the C++ file that we created: add_executable(cpp_config src/DynamicConfig.cpp)
• Add the following dependencies to the executable using add_dependencies:
  • ${catkin_EXPORTED_TARGETS}
  • ${PROJECT_NAME}_gencfg
• Link the ${catkin_LIBRARIES} using target_link_libraries.

Next, catkin_make the workspace:

• Open a terminal and run the following commands:
  • cd ~/ROS_workspaces/ros_ws/
  • catkin_make

Running the nodes

1. Run the roscore on a terminal
2. Run the following commands
   • rosrun intro_pkg1 cpp_config
     • This will run the C++ node
   • rosrun rqt_reconfigure rqt_reconfigure
     • This opens a window where you can select the C++ node (that's hosting a dynamic reconfiguration server) and alter the properties in real time.

Alter values of the reconfiguration window and see the results on the running terminal session (for the cpp_config node)

Dynamic Configuration for a Python Node

Coding the node

Follow the following steps to make a Python node for using the dynamic reconfiguration window:

1. Import the following files
   • rospy
   • Server from dynamic_reconfigure.server
   • The config file generated in the devel folder of the workspace
2. Create a callback function that takes two arguments, one configuration state and other a number (level). It must also return the config object.
3. Initialize the node
4. Use the Server class to create a server instance. Pass it the configuration class and the callback function
5. Spin the node

Running the node

1. Run roscore
2. Make the python file executable
   • roscd intro_pkg1/scripts/
   • chmod +x *.py
3. Run the node and the GUI for rqt_reconfigure
   • rosrun intro_pkg1 python_config.py
   • rosrun rqt_reconfigure rqt_reconfigure

After running these nodes, you're highly suggested to check the communication graph using rqt_graph and check out the topics that are actually exchanging information between nodes.