Uso del servidor de parámetros ROS

Others 2021-01-24 22:17:21 views: null

1. Importancia del uso

El uso del servidor de parámetros está diseñado para mejorar la flexibilidad y configurabilidad de los nodos ROS, y su significado se puede entender desde dos aspectos:

        En el sistema de robot, la transmisión de parámetros es muy importante.Cuando el robot está funcionando, debemos configurar los parámetros del robot (como los parámetros del sensor y los parámetros del algoritmo). Algunos parámetros (como el contorno del robot, la altura del sensor) se pueden configurar cuando se inicia el robot, y algunos parámetros deben cambiarse dinámicamente (especialmente durante la depuración). Ya se trate de la configuración del sensor o el ajuste de los parámetros de control, se debe reservar una interfaz de depuración de parámetros conveniente. ROS proporciona un servidor de parámetros para cumplir con este requisito. Podemos establecer los parámetros en el servidor de parámetros y obtenerlos del servidor de parámetros cuando los parámetros sean necesarios. El uso del servidor de parámetros para configurar los parámetros del sistema es globalmente visible, lo que nos resulta conveniente para recuperar y cambiar el estado de configuración del sistema.

        El servidor de parámetros proporciona otra forma de intercambio de información entre los nodos ROS (los métodos comúnmente utilizados también son mensajes y servicios). La idea principal es utilizar un servidor de parámetros centralizado (servidor de parámetros) para mantener el valor de un conjunto de variables, y el nodo puede consultar activamente el valor del parámetro de interés.

El comando rosparam puede operar los parámetros en el servidor de parámetros ROS. A través del comando rosparam -h, puede ver los siguientes métodos:

Commands:
    rosparam set	set parameter 设置参数
    rosparam get	get parameter 获得参数值
    rosparam load	load parameters from file 从文件中加载参数到参数服务器
    rosparam dump       dump parameters to file 将参数服务器中的参数写入到文件
    rosparam delete     delete parameter 删除参数
    rosparam list       list parameter names 列出参数服务器中的参数

2. Usa puntos

ROS nos proporciona la interfaz roslaunch .launch, la interfaz de línea de comandos, la interfaz roscpp y la interfaz rospy para los parámetros operativos. Los principales puntos de uso son los siguientes:
2.1 interfaz roslaunch .launch

Esta interfaz se utiliza para configurar los parámetros al inicio. Las ventajas de usar el archivo de lanzamiento para configurar los parámetros: 1. Puede conocer los parámetros usados ​​por el nodo y el valor inicial dado sin ver el programa fuente; 2. Para modificar el valor inicial del parámetro, puede guardarlo en el archivo de inicio sin modificar y Recompilar el programa fuente.
    2.1.1 Utilice <param>etiquetas para definir directamente parámetros

<param name="publish_frequency" type="double" value="10.0" />

Utilice etiquetas para <rosparam>configurar parámetros

    2.1.2 Lectura de parámetros del archivo YAML:

         Generalmente, podemos guardar los parámetros que necesitan ser configurados en un archivo yaml y usar el comando rosparam load [ruta de archivo \ nombre de archivo] para cargar múltiples parámetros al servidor de parámetros a la vez.

Por ejemplo, un archivo de parámetros llamado param.yaml, el contenido es:

#There are some params which will be loaded
yaml_param_string1: abcd123
yaml_param_string2: 567efg
 
yaml_param_num1: 123.123
yaml_param_num2: 1234567
 
yaml_param_set:
  param_set_string1: zzzzz
  param_set_num1: 999
  param_set_string2: a6666
  param_set_num2: 2333
 
  param_subset:
    param_set_string1: qwer
    param_set_num1: 5432
    param_set_string2: a12s3
    param_set_num2: 1111

Cargar parámetros en el terminal:

$ rosparam load param.yaml

Luego, ingrese el comando:

$ rosparam list

Como puede ver, se han cargado todos los parámetros:

/rosdistro
/roslaunch/uris/host_clp_virtual_machine__46453
/rosversion
/run_id
/yaml_param_num1
/yaml_param_num2
/yaml_param_set/param_set_num1
/yaml_param_set/param_set_num2
/yaml_param_set/param_set_string1
/yaml_param_set/param_set_string2
/yaml_param_set/param_subset/param_set_num1
/yaml_param_set/param_subset/param_set_num2
/yaml_param_set/param_subset/param_set_string1
/yaml_param_set/param_subset/param_set_string2
/yaml_param_string1
/yaml_param_string2

El valor del parámetro se puede establecer mediante rosparam set [nombre del parámetro] [valor del parámetro];

Puede ver el valor del parámetro mediante rosparam get [nombre del parámetro];

También se puede cargar en el servidor de parámetros a través de la etiqueta rosparam en el archivo de inicio:

Puede consultar el proceso de navegación de turtlebot para iniciar el nodo move_base.Los parámetros guardados en el archivo yaml se cargan en el servidor de parámetros a través de la etiqueta rosparam.

<node pkg="move_base" type="move_base" respawn="false" name="move_base" output="screen">
    <rosparam file="$(find turtlebot_navigation)/param/costmap_common_params.yaml" command="load" ns="global_costmap" />
    <rosparam file="$(find turtlebot_navigation)/param/costmap_common_params.yaml" command="load" ns="local_costmap" />   
    <rosparam file="$(find turtlebot_navigation)/param/local_costmap_params.yaml" command="load" />   
    <rosparam file="$(find turtlebot_navigation)/param/global_costmap_params.yaml" command="load" />
    <rosparam file="$(find turtlebot_navigation)/param/dwa_local_planner_params.yaml" command="load" />
    <rosparam file="$(find turtlebot_navigation)/param/move_base_params.yaml" command="load" />
    <rosparam file="$(find turtlebot_navigation)/param/global_planner_params.yaml" command="load" />
    <rosparam file="$(find turtlebot_navigation)/param/navfn_global_planner_params.yaml" command="load" />
    <!-- external params file that could be loaded into the move_base namespace -->
    <rosparam file="$(arg custom_param_file)" command="load" />
    
    <!-- reset frame_id parameters using user input data -->
    <param name="global_costmap/global_frame" value="$(arg global_frame_id)"/>
    <param name="global_costmap/robot_base_frame" value="$(arg base_frame_id)"/>
    <param name="local_costmap/global_frame" value="$(arg odom_frame_id)"/>
    <param name="local_costmap/robot_base_frame" value="$(arg base_frame_id)"/>
    <param name="DWAPlannerROS/global_frame_id" value="$(arg odom_frame_id)"/>

    <remap from="cmd_vel" to="navigation_velocity_smoother/raw_cmd_vel"/>
    <remap from="odom" to="$(arg odom_topic)"/>
    <remap from="scan" to="$(arg laser_topic)"/>
</node>

    2.1.3 Eliminar parámetros

<rosparam command="delete" param="my/param" />

    2.1.4 Asignación directa de parámetros

<rosparam param="a_list">[1, 2, 3, 4]</rosparam>

o

<rosparam>
  a: 1
  b: 2
</rosparam>

2.2 Interfaz de línea de comandos

Esta interfaz nos permite ver y configurar parámetros de manera flexible a través de parámetros de línea de comando.

ejemplo

$ rosparam list /namespace
$ rosparam get parameter_name
$ rosparam set parameter_name value
$ rosparam delete parameter_name

2.3 interfaz de parámetros roscpp

Esta interfaz nos permite personalizar cómo el nodo ROS maneja los parámetros. Hay dos conjuntos de API de parámetros roscpp: un conjunto está en el espacio de nombres ros :: param, el otro conjunto está encapsulado en el identificador y se accede a través de la interfaz ros :: NodeHandle:

    1. 为 参数 设置 默认 值
        nh.param <<tipo_variable>> ("<nombre_param>", variable, <valor_predeterminado>);
        ros :: param :: param <<tipo_variable>> ("<nombre_param>", variable, <valor_predeterminado>);

    La función del código anterior es inicializar la variable variable con el parámetro llamado <param_name> y el valor <default_value>.

    2. Obtenga un valor de parámetro del servidor de parámetros.
        ros :: NodeHandle :: getParam ("<param_name>", variable)
        ros :: param :: get ("<param_name>", variable)

    La función del código anterior es obtener el valor del parámetro llamado <param_name> del servidor de parámetros y asignarlo al
        caché de variables para obtener
 

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.

Parámetro de configuración

ros::NodeHandle::setParam("<param_name>"，<param_value>)
ros::param::set("<param_name>"，<param_value>)

Asignar el parámetro <param_name> a <param_value>

Determine si el parámetro existe

ros::NodeHandle::hasParam("<param_name>")
ros::param::has("<param_name>")

Determine si existe el parámetro <param_name>

Eliminar parámetro

ros::NodeHandle::deleteParam("<param_name>")
ros::param::del("<param_name>")

Eliminar parámetro <param_name>


En el código ROS, también podemos realizar algunas operaciones de parámetros:

#include <ros/ros.h>
 
int main(int argc, char** argv)
{
	ros::init(argc, argv, "param_demo");
	ros::NodeHandle n;
	ros::NodeHandle pn("~my_namespce");
 
	std::string s;
	int num;
	
	n.param<std::string>("string_param", s, "haha");
	pn.param<int>("int_param", num, 666);
	
	//输出被初始化后的变量值
	ROS_INFO("string_param_init: %s", s.c_str());
	ROS_INFO("int_param_init: %d", num);
 
	//设置参数的值
	n.setParam("string_param", "hehe");
	pn.setParam("int_param", 222);
 
 
	//设置循环的频率为1Hz
	ros::Rate loop_rate(1);	
 
	while(ros::ok())
	{	
		//获取参数的值
		n.getParam("string_param", s);
		pn.getParam("int_param", num);
		
		//输出参数
		ROS_INFO("string_param: %s", s.c_str());
		ROS_INFO("int_param: %d", num);
		
		ros::spinOnce();
		loop_rate.sleep();
	}
	
	return 0;
}

Después de compilar, primero use roscore para iniciar ros y luego use rosrun para ejecutar el nodo. El resultado de la operación es:

[ INFO] [1508962647.123025215]: string_param_init: haha
[ INFO] [1508962647.123388114]: int_param_init: 666
[ INFO] [1508962647.126034003]: string_param: hehe
[ INFO] [1508962647.126118085]: int_param: 222
[ INFO] [1508962648.127348007]: string_param: hehe
[ INFO] [1508962648.127499096]: int_param: 222
[ INFO] [1508962649.129554752]: string_param: hehe
[ INFO] [1508962649.130092222]: int_param: 222
[ INFO] [1508962650.128275652]: string_param: hehe
[ INFO] [1508962650.128455601]: int_param: 222
[ INFO] [1508962651.127771182]: string_param: hehe
[ INFO] [1508962651.128003505]: int_param: 222
[ INFO] [1508962652.128101292]: string_param: hehe
[ INFO] [1508962652.128249473]: int_param: 222
[ INFO] [1508962653.127405633]: string_param: hehe
[ INFO] [1508962653.127529541]: int_param: 222
[ INFO] [1508962654.126999255]: string_param: hehe
[ INFO] [1508962654.127161917]: int_param: 222
[ INFO] [1508962655.129154583]: string_param: hehe
[ INFO] [1508962655.129287685]: int_param: 222
……

En este punto, ingrese el comando:

$ rosparam list

Como puede ver, el parámetro ya existe en el servidor de parámetros. Los resultados son los siguientes:

/param_demo/my_namespce/int_param
/rosdistro
/roslaunch/uris/host_clp_virtual_machine__33415
/rosversion
/run_id
/string_param

Explicación del código:

El espacio de nombres global predeterminado se usa al definir el objeto NodeHandle n, y el espacio de nombres privado se usa al definir el objeto NodeHandle pn:

ros::init(argc, argv, "param_demo");
ros::NodeHandle n;
ros::NodeHandle pn("~my_namespce");

Por lo tanto, "string_param" es un parámetro global y "int_param" es un parámetro bajo el espacio de nombres my_namespace.

Hay dos líneas de código a continuación:

n.param<std::string>("string_param", s, "haha");
pn.param<int>("int_param", num, 666)

El documento oficial describe la función ros :: NodeHandle :: param () de la siguiente manera:

La función param () toma el valor del parámetro del servidor de parámetros a la variable. Si no se puede obtener, se asigna el valor predeterminado a la variable. La función de esta función es similar a la función getParam (), pero la diferencia es que la función param () también proporciona un valor predeterminado.

    //设置参数的值
    n.setParam("string_param", "hehe");
    pn.setParam("int_param", 222);

Establezca el valor del parámetro. Si comenta estas dos líneas de código, el comando rosparam list no verá "string_param" ni "int_param" porque el servidor de parámetros no establece estos dos parámetros.

n.getParam("string_param", s);
pn.getParam("int_param", num);

La función getParam () puede obtener valores de parámetros del servidor de parámetros. Si tiene éxito, los valores de las variables s y num se modificarán a los valores del parámetro, y la función devuelve verdadero; si no tiene éxito (por ejemplo, el servidor de parámetros no establece este parámetro), las variables sy num permanecerá con los valores originales y la función devolverá falso.

 

Apague el nodo que se ejecutó por primera vez (no apague roscore) y luego ejecute el nodo por segunda vez. El resultado es:

[ INFO] [1508962846.716579651]: string_param_init: hehe
[ INFO] [1508962846.716882790]: int_param_init: 222
[ INFO] [1508962846.719913219]: string_param: hehe
[ INFO] [1508962846.720229965]: int_param: 222
[ INFO] [1508962847.721341491]: string_param: hehe
[ INFO] [1508962847.721696804]: int_param: 222
[ INFO] [1508962848.724312549]: string_param: hehe
[ INFO] [1508962848.724606197]: int_param: 222
[ INFO] [1508962849.723765176]: string_param: hehe
[ INFO] [1508962849.724541585]: int_param: 222
[ INFO] [1508962850.721549217]: string_param: hehe
[ INFO] [1508962850.722647030]: int_param: 222
[ INFO] [1508962851.722353260]: string_param: hehe
[ INFO] [1508962851.722608120]: int_param: 222
[ INFO] [1508962852.725476354]: string_param: hehe
[ INFO] [1508962852.726797059]: int_param: 222
[ INFO] [1508962853.723994285]: string_param: hehe
[ INFO] [1508962853.724691083]: int_param: 222
……

Al comparar los resultados de la segunda ejecución con los resultados de la primera ejecución, los valores de string_param_init e int_param_init han cambiado. Esto se debe a que después de ejecutar el nodo por primera vez, los parámetros string_param y num_param ya existen en el servidor de parámetros, por lo que cuando el nodo se ejecuta por segunda vez, los valores predeterminados "jaja" y "666" no serán utilizado, por lo que el resultado de salida es "jeje" "Y 222.


Además, cuando el nodo se está ejecutando, usamos el comando rosparam set para modificar el valor del parámetro y podemos observar el cambio del valor de salida.

Enlace original:

https://blog.csdn.net/wanghuiquan0712/article/details/78763144

https://blog.csdn.net/u014695839/article/details/78348600

https://blog.csdn.net/wengge987/article/details/50620121

 

Supongo que te gusta

Origin blog.csdn.net/sunlin972913894/article/details/103556936
Recomendado
Clasificación
Diario
Más
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)

Code World

© 2018 codetd.com