Répertoire d'articles
Un, getparam et param dans le programme
1. getparam (pas de valeur par défaut)
bool getParam (const std::string& key, parameter_type& output_value)；
//返回值判断是否获取参数成功
parmi eux:
- La clé est le nom du paramètre (équivalent à l'interface, similaire au sujet), référence à la méthode de dénomination: ros naming (reportez-vous à l'apprentissage de suivi)
- output_value est utilisé pour contenir la valeur du
paramètre. Le type parameter_type inclut bool, int, double, string ou un type XmlRpcValue spécifique. Le type XmlRpcValue inclut tous les types, même les listes / cartes
Par exemple:
std::string s;
n.getParam("my_param", s);
2. param (a une valeur par défaut)
int i;
n.param("my_num", i, 42);//默认参数为42
3. Supprimer les paramètres
n.deleteParam("my_param");
4. Réglez les paramètres dans le programme
n.setParam("my_param", "hello there");
5. Vérifiez les paramètres
Cette étape n'est pas obligatoire
if (!n.hasParam("my_param"))
{
ROS_INFO("No param named 'my_param'");
}
6. Paramètres de recherche
Par exemple: si le serveur de paramètres a un paramètre de / a / b et que votre NodeHandle est dans l'espace de travail / a / c, searchParam () obtiendra / a / b lors de la recherche de b. Si le paramètre de / a / c / b est augmenté, la recherche obtiendra les paramètres / a / c / b. Les exemples sont les suivants:
std::string param_name;
if (n.searchParam("b", param_name)) {
// Found parameter, can now query it using param_name
int i = 0;
n.getParam(param_name, i);
}
else {
ROS_INFO("No param 'b' found in an upward search");
}
2. Méthode de paramétrage au lancement
Il existe trois types: param, rosparam, arg
Param
Définissez les paramètres dans le fichier de lancement:
节点 内 ：
<node name = "node_keyboard_control" pkg = "keyboardControl" type = "node_keyboard_control" output = "screen">
<param name = "linear_min" value = "0.3" />
</ node>全局 ：
<param name = "use_gui" value = "$ (arg gui)" />
grogné
Définissez les paramètres dans le fichier de lancement:
<rosparam file = "param.yaml" command = "load" />
arg
Utilisé en interne lors du lancement, similaire à la syntaxe du lancement.
Définissez les paramètres dans le fichier de lancement:
<arg name = "gui" default = "false" />
<param name = "use_gui" value = "$ (arg gui)" />
// 一起 使用
Trois paramètres dynamiques
Parfois, les paramètres de ros seuls ne peuvent pas répondre à nos exigences de travail.Par exemple, lors du débogage des paramètres du robot, nous espérons modifier dynamiquement les paramètres pour observer la réponse correspondante du robot. Nous introduisons donc ensuite les paramètres dynamiques dans ros.
Les paramètres dynamiques de ros sont similaires aux formulaires de publication et d'abonnement des rubriques. Une fois le fichier de paramètres dynamiques configuré, il suffit de s'abonner aux paramètres correspondants dans le programme.
Créer des paramètres de configuration
- Créer un package ros
catkin_create_pkg dynamic_tutorials rospy roscpp dynamic_reconfigure
Si vous disposez déjà d'un package fonctionnel, il vous suffit d'ajouter dynamic_reconfigure dans CmakeList.txt et package.xml.
- Créer un fichier de configuration cfg
Créez un dossier cfg sous le même répertoire de niveau que le src du package de fonctions, et ajoutez un fichier nommé my_cfg.cfg dans cfg. Son contenu est:
#!/usr/bin/env python
PACKAGE = "dynamic_tutorials"
from dynamic_reconfigure.parameter_generator_catkin import *
gen = ParameterGenerator()
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)
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")
gen.add("size", int_t, 0, "A size parameter which is edited via an enum", 1, 0, 3, edit_method=size_enum)
exit(gen.generate(PACKAGE, "dynamic_tutorials", "my_cfg"))
On peut voir qu'il est implémenté sous forme python, et le contenu de la configuration est brièvement présenté ci-dessous.
Créez un générateur de paramètres:
gen = ParameterGenerator()
Paramètres de configuration dynamiques:
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)
La forme de réalisation des paramètres dynamiques : add (nom, type, niveau, description, par défaut, min, max).
- name: le nom du paramètre, qui est décrit par une chaîne;
- type: définit le type du paramètre, qui peut être int_t, double_t, str_t ou bool_t;
- niveau: Nécessité de passer des paramètres pour configurer dynamiquement le masque dans la fonction de rappel Le masque de tous les paramètres sera modifié dans la fonction de rappel, indiquant que les paramètres ont été modifiés;
- description: une chaîne décrivant le rôle du paramètre;
- default: définissez la valeur par défaut du paramètre;
- min: facultatif, définissez la valeur minimale du paramètre, elle ne prend pas effet pour les valeurs de chaîne et booléennes;
- max: facultatif, définissez la valeur maximale du paramètre, cela ne prend pas effet pour les valeurs de chaîne et booléennes;
La forme de réalisation des paramètres dynamiques de type énumération : 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," Une grande constante "),
gen.const (" ExtraLarge ", int_t, 3," An extra large constant ")]," Une énumération pour définir la taille ")gen.add ("size", int_t, 0, "Un paramètre de taille qui est édité via une énumération", 1, 0, 3, edit_method = size_enum)
Générez des fichiers liés à C ++ et python et quittez le programme:
exit(gen.generate(PACKAGE, "dynamic_tutorials", "my_cfg"))
- dynamic_tutorials: le nom du package
- my_cfg: Le nom du fichier de configuration créé (ce n'est peut-être pas le nom du fichier de configuration, mais il doit être cohérent avec le programme), qui est le fichier d'en-tête qui doit être inclus dans le programme
Créer un nœud de serveur
Le nœud du serveur, c'est-à-dire le nœud d'abonnement, le code est implémenté comme suit, voir les notes pour plus de détails:
#include <ros/ros.h>
#include <dynamic_reconfigure/server.h>//实现动态参数的头文件
#include <dynamic_tutorials/TutorialsConfig.h>//cfg生成的头文件
/****回调函数****/
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)
{
ros::init(argc, argv, "node_dy_param");
dynamic_reconfigure::Server<dynamic_tutorials::TutorialsConfig> server;//创建了一个参数动态配置的服务端
dynamic_reconfigure::Server<dynamic_tutorials::TutorialsConfig>::CallbackType f;
f = boost::bind(&callback, _1, _2);//绑定回调
server.setCallback(f);
ROS_INFO("Spinning node");
ros::spin();
return 0;
}
Augmentez le contenu de CmakeList.txt:
add_executable(node_dy_param src/main.cpp)
target_link_libraries(node_dy_param ${
catkin_LIBRARIES})
add_dependencies(node_dy_param ${
${
PROJECT_NAME}_EXPORTED_TARGETS} ${
catkin_EXPORTED_TARGETS})
add_dependencies(node_dy_param ${
PROJECT_NAME}_gencfg)
courir
Démarrez le nœud d'abonné:
$ roscore
$ rosrun dynamic_tutorials node_dy_param
Exécutez le nœud de fin de publication:
rosrun rqt_reconfigure rqt_reconfigure