Le serveur de paramètres est principalement utilisé pour réaliser le partage de données entre différents nœuds dans ROS. Le serveur de paramètres équivaut à un conteneur commun indépendant de tous les nœuds. Les données peuvent être stockées dans le conteneur et appelées par différents nœuds. Bien entendu, différents nœuds peuvent également y stocker des données. Les scénarios d'application typiques du serveur de paramètres sont les suivants :
Lorsque la navigation est mise en œuvre, la planification du chemin sera effectuée, comme: la planification globale du chemin, pour concevoir un chemin approximatif du point de départ au point cible. Planification locale des chemins, basée sur les conditions routières actuelles pour générer la trajectoire actuelle
Dans le scénario ci-dessus, le serveur de paramètres sera utilisé dans la planification globale du chemin et la planification locale du chemin:
-
Lors de la planification d'un chemin, vous devez faire référence à la taille de la voiture. Nous pouvons stocker les informations de taille dans le serveur de paramètres. Le nœud de planification de chemin global et le nœud de planification de chemin local peuvent appeler ces paramètres à partir du serveur de paramètres.
Le serveur de paramètres est généralement applicable à certains scénarios d'application où le partage de données existe.
concept
Le mode de communication de l'interaction des données entre différents nœuds est réalisé de manière partagée.
effet
Stockez certaines données partagées par plusieurs nœuds, similaires aux variables globales.
Étude de cas
Réaliser les opérations d'ajout, de suppression, de modification et de vérification de paramètres.
Veuillez également vous référer à:
1 Modèle théorique du serveur de paramètres
L'implémentation du serveur de paramètres est la plus simple. Le modèle est illustré dans la figure ci-dessous. Trois rôles sont impliqués dans le modèle:
-
Maître ROS (Manager)
-
Talker (régleur de paramètres)
-
Listener (appelant de paramètre)
En tant que conteneur public, ROS Master enregistre les paramètres, Talker peut définir des paramètres dans le conteneur et Listener peut obtenir des paramètres.
L'ensemble du processus est réalisé par les étapes suivantes:
(1) Paramètres de réglage de l'émetteur
Talker envoie les paramètres (y compris les noms de paramètres et les valeurs de paramètres) au serveur de paramètres via RPC, et ROS Master enregistre les paramètres dans la liste de paramètres.
(2). L'écouteur obtient les paramètres
Le récepteur envoie une demande de recherche de paramètres au serveur de paramètres via RPC. La demande contient le nom du paramètre à rechercher.
(3) Le maître ROS envoie les valeurs des paramètres à l'auditeur
Le maître ROS trouve la valeur du paramètre en fonction du nom de paramètre fourni dans la requête de l'étape 2 et envoie le résultat de la requête à l'écouteur via RPC.
Les paramètres peuvent utiliser des types de données:
-
Entiers 32 bits
-
booléens
-
cordes
-
double
-
dates iso8601
-
listes
-
données binaires encodées en base64
-
dictionnaire
Remarque: le serveur de paramètres n'est pas conçu pour des performances élevées, il est donc préférable de l'utiliser pour stocker des données simples non binaires statiques
2 Opération de paramètre A (C ++)
Condition: réaliser l'ajout, la suppression, la modification et la vérification du fonctionnement des paramètres du serveur de paramètres.
L'ajout, la suppression, la modification et la vérification des données du serveur de paramètres en C ++ peuvent être réalisés via deux ensembles d'API:
-
ros :: NodeHandle
-
ros :: param
Ce qui suit est une démonstration de fonctionnement spécifique
(1). Nouveaux paramètres (modifiés) du serveur de paramètres
#include "ros/ros.h"
/*
实现参数的新增和修改
需求：设置机器人的共享参数：类型和半径(0.15)
再修改半径(0.2)
实现：
ros::NodeHandle setParam
ros::Param set
*/
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"");
//初始化ros节点
ros::init(argc,argv,"set_param");
//创建节点句柄
ros::NodeHandle nh;
//参数增---------------------------------
//方式1：nh
nh.setParam("type","小黄车");
nh.setParam("radius",0.15);
//方式2：ros::Param
ros::param::set("type_param","小黑车");
ros::param::set("type_radius",0.15);
//参数改---------------------------------
//方式1：nh
//方式2：ros::Param
return 0;
}Fichier de configuration
test
roscore
source ./devel/setup.bash
rosrun plumbing_param_server demo01_param_set
rosparam list
modifier
Assurez-vous que la clé doit être modifiée, la valeur sera écrasée
//参数改---------------------------------
//方式1：nh
nh.setParam("radius",0.2);
//方式2：ros::Param
ros::param::set("type_radius",0.25);
(2) Le serveur de paramètres obtient les paramètres
#include "ros/ros.h"
/*
演示参数查询
实现：
ros::NodeHandle --------------------------------------------------
param(键,默认值)
存在，返回对应结果，否则返回默认值
getParam(键,存储结果的变量)
存在,返回 true,且将值赋值给参数2
若果键不存在，那么返回值为 false，且不为参数2赋值
getParamCached键,存储结果的变量)--提高变量获取效率
存在,返回 true,且将值赋值给参数2
若果键不存在，那么返回值为 false，且不为参数2赋值
getParamNames(std::vector<std::string>)
获取所有的键,并存储在参数 vector 中
hasParam(键)
是否包含某个键，存在返回 true，否则返回 false
searchParam(参数1，参数2)
搜索键，参数1是被搜索的键，参数2存储搜索结果的变量
ros::Param -----------------------------------------------------------
*/
int main(int argc, char *argv[])
{
//设置编码吗
setlocale(LC_ALL,"");
//初始化ros节点
ros::init(argc,argv,"get_param");
//创建节点句柄
ros::NodeHandle nh;
// ros::NodeHandle --------------------------------------------------
//1 param
double radius = nh.param("radius",0.5);
ROS_INFO("radius = %f",radius);
return 0;
}
getParam(键,存储结果的变量)
存在,返回 true,且将值赋值给参数2
若果键不存在，那么返回值为 false，且不为参数2赋值
//2 getParam
double radius2 = 0.0;
bool result = nh.getParam("radius",radius2);
if(result)
{
ROS_INFO("获取的半径是%f",radius2);
}
else
{
ROS_INFO("被查询的变量不存在");
}
getParamCached键,存储结果的变量)--提高变量获取效率
存在,返回 true,且将值赋值给参数2
若果键不存在，那么返回值为 false，且不为参数2赋值
//3 getParamCached
double radius3 = 0.0;
result = nh.getParamCached("radius",radius3);
if(result)
{
ROS_INFO("3获取的半径是%f",radius3);
}
else
{
ROS_INFO("被查询的变量不存在");
}
getParamNames(std::vector<std::string>)
获取所有的键,并存储在参数 vector 中
//4 getParamNames(std::vector<std::string>)
std::vector<std::string> names;
nh.getParamNames(names);
//遍历
for(auto &&name:names)
{
ROS_INFO("遍历到的元素是：%s",name.c_str());
}
hasParam(键)
是否包含某个键，存在返回 true，否则返回 false
//5 hasParam(键)
result = nh.hasParam("radius");
if(result)
{
ROS_INFO("radius存在");
}
else
{
ROS_INFO("radius不存在");
}
searchParam(参数1，参数2)
搜索键，参数1是被搜索的键，参数2存储搜索结果的变量
//6 searchParam(参数1，参数2)
std::string key;
nh.searchParam("radius",key);
ROS_INFO("搜索结果是：%s",key.c_str());
La fonction de ros :: param est similaire à ros :: NodeHandle
(3) Le serveur de paramètres supprime les paramètres
参数服务器操作之删除_C++实现:
ros::NodeHandle
deleteParam("键")
根据键删除参数，删除成功，返回 true，否则(参数不存在)，返回 false
ros::param
del("键")
根据键删除参数，删除成功，返回 true，否则(参数不存在)，返回 false#include "ros/ros.h"
/*
参数服务器操作之删除_C++实现:
ros::NodeHandle
deleteParam("键")
根据键删除参数，删除成功，返回 true，否则(参数不存在)，返回 false
ros::param
del("键")
根据键删除参数，删除成功，返回 true，否则(参数不存在)，返回 false
*/
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"");
//初始化ros节点
ros::init(argc,argv,"param_del");
//创建节点句柄
ros::NodeHandle nh;
//删除，使用NodeHandle----------------------------------------
bool flag1 = nh.deleteParam("radius");
if(flag1)
{
ROS_INFO("删除成功");
}
else
{
ROS_INFO("删除失败");
}
//删除，使用param-------------------------------------------------
bool flag2 = ros::param::del("type_radius");
if(flag2)
{
ROS_INFO("type_radius删除成功");
}
else
{
ROS_INFO("type_radius删除失败");
}
return 0;
}
Ne peut être supprimé qu'une seule fois