ROS learning (26) dynamic parameter configuration

---

Preface

   In the previous study , Have known ROS Communication mechanism of parameter server , If Listenner Do not actively query parameter values , You can't get Talker Whether it has been submitted to Master Updated parameter values .
   In many cases , We need to update parameters dynamically , Such as parameter debugging ,ROS Provides dynamic_reconfigure Function pack , Realize dynamic parameter configuration .

One 、 principle

  ROS The dynamic parameters of are modified by C/S framework , At run time , The client does not need to restart after modifying parameters , Instead, send a request to the server ; The server confirms through the callback function , You can complete the dynamic configuration of parameters .

Two 、 Realization

1、 Create Feature Pack

Create a dynamic_tutorials Function pack , The order is as follows ：

catkin_create_pkg dynamic_tutorials rospy roscpp dynamic_reconfigure

2、 create profile

Under function pack cfg Under the folder , Create a Tutorials.cfg The file of , The contents are as follows ：

#!/usr/bin/env python
PACKAGE = "dynamic_tutorials"
# Import parameter generator 
from dynamic_reconfigure.parameter_generator_catkin import *
# Create a parameter generator 
gen = ParameterGenerator()
# Define parameters that need dynamic configuration , Parameters respectively represent parameter names 、 type 、 Parameter dynamically configure the mask in the callback 、 describe 、 The default value is 、 Min and Max （ The latter two are optional , And invalid for string and Boolean types ）
gen.add("int_param",    int_t,    0, "An Integer parameter", 50,  0, 100)
gen.add("double_param", double_t, 0, "A double parameter",    .5, 0,   1)
gen.add("str_param",    str_t,    0, "A string parameter",  "Hello World")
gen.add("bool_param",   bool_t,   0, "A Boolean parameter",  True)
# Define an enumeration , The parameters respectively represent the enumeration value name 、 type 、 Value and description 
size_enum = gen.enum([ gen.const("Small",      int_t, 0, "A small constant"),
                       gen.const("Medium",     int_t, 1, "A medium constant"),
                       gen.const("Large",      int_t, 2, "A large constant"),
                       gen.const("ExtraLarge", int_t, 3, "An extra large constant")], "An enum to set size")
# Define an integer value , It can be listed by enumeration 
gen.add("size", int_t, 0, "A size parameter which is edited via an enum", 1, 0, 3, edit_method=size_enum)
# Generate all and C++ and python Related documents , And exit the program , The second parameter represents the node name of the runtime , The third parameter is the prefix used by the generated file , It needs to be the same as the configuration file name 
exit(gen.generate(PACKAGE, "dynamic_tutorials", "Tutorials"))

The real runtime , Need to remove the Chinese Notes . When the configuration is complete , Add executable permissions to the file .

3、 modify CMakeLists.txt file

Add Compilation Rules , The contents are as follows ：

generate_dynamic_reconfigure_options(
  cfg/Tutorials.cfg
)
add_dependencies(dynamic_reconfigure_node ${
    PROJECT_NAME}_gencfg)

4、 establish dynamic_reconfigure_node node

4、1 Create a server node

stay src Under the table of contents , establish server.cpp file , The contents are as follows ：

#include <ros/ros.h>

#include <dynamic_reconfigure/server.h>
// This header file is generated by the configuration file during compilation 
#include <dynamic_tutorials/TutorialsConfig.h>
// Callback function , Parameters respectively represent the configuration values of parameter updates 、 Mask of parameter modification 
void callback(dynamic_tutorials::TutorialsConfig &config, uint32_t level) {
    
  ROS_INFO("Reconfigure Request: %d %f %s %s %d", 
            config.int_param, config.double_param, 
            config.str_param.c_str(), 
            config.bool_param?"True":"False", 
            config.size);
}

int main(int argc, char **argv) 
{
    
    // initialization ROS node 
    ros::init(argc, argv, "dynamic_tutorials");
    // Create a server instance , Listen to the parameter configuration request of the client 
    dynamic_reconfigure::Server<dynamic_tutorials::TutorialsConfig> server;
    // Define callback function 
    dynamic_reconfigure::Server<dynamic_tutorials::TutorialsConfig>::CallbackType f;
    // The callback function is bound to the server , When the client requests to modify parameters , The server jumps to the callback function for processing 
    f = boost::bind(&callback, _1, _2);
    server.setCallback(f);

    ROS_INFO("Spinning node");
    ros::spin();
    return 0;
}

4、2 modify CMakeLists.txt file

Add Compilation Rules , The contents are as follows ：

# for dynamic reconfigure 
add_executable(dynamic_reconfigure_node src/server.cpp) 

# make sure configure headers are built before any node using them
add_dependencies(dynamic_reconfigure_node ${
    PROJECT_NAME}_gencfg)

# for dynamic reconfigure 
target_link_libraries(dynamic_reconfigure_node ${
    catkin_LIBRARIES})  

After completing the above configuration , Compile function packs .

5、 Parameter dynamic configuration

function roscore and dynamic_reconfigure_node node , The order is as follows ：

roscore
rosrun dynamic_tutorials dynamic_reconfigure_node

here , The server with dynamic parameter configuration starts to run , Next use ROS Provide visual parameter configuration tools to modify parameters , The order is as follows ：

rosrun rqt_reconfigure rqt_reconfigure

Pictured ：

   You can drag 、 Input 、 Drop down box and other methods to modify parameters , It is worth noting that , The different input methods here are related to the parameter settings in the configuration file , For example, the maximum value is set / minimum value , There will be a drag bar ; Enumeration set , A drop-down box will appear .
   With the change of parameter value , In the output of the server node , You will see the modified information , Pictured ：