7.1.6-Gestión de operación de ROS

Gestión de nodos ROS con archivos launch

Los archivos launch en ROS son archivos en formato XML que se utilizan para iniciar y gestionar de manera eficiente múltiples nodos ROS. Esta sección cubre las distintas etiquetas disponibles en los archivos launch, incluidos sus atributos y casos de uso.

La etiqueta <launch>

La etiqueta <launch> es la raíz de cada archivo launch y actúa como contenedor para todas las demás etiquetas.

1. Atributos

  • deprecated="declaración de obsolescencia"
    Indica al usuario que el archivo launch actual ha quedado obsoleto.

2. Etiquetas hijas

  • Todas las demás etiquetas en un archivo launch son elementos hijos de la etiqueta <launch>.

Ejemplo:

xml
<launch>
    <!-- Other tags go here -->
</launch>

La etiqueta <node>

La etiqueta <node> se usa para especificar un nodo ROS que se va a lanzar. Es una de las etiquetas más usadas en un archivo launch. Tenga en cuenta que el comando roslaunch no garantiza que los nodos se inicien en el orden en que se declaran, ya que el proceso de arranque de los nodos es multihilo.

1. Atributos

  • pkg="package_name"
    Especifica el paquete al que pertenece el nodo.

  • type="nodeType"
    Tipo de nodo, que corresponde al nombre del archivo ejecutable.

  • name="nodeName"
    Nombre del nodo dentro de la topología de la red ROS.

  • args="xxx xxx xxx" (opcional)
    Pasa argumentos al nodo.

  • machine="machine_name"
    Especifica la máquina en la que se debe lanzar el nodo.

  • respawn="true | false" (opcional)
    Determina si el nodo debe reiniciarse automáticamente al salir.

  • respawn_delay="N" (opcional)
    Si respawn está en true, define un retardo de N segundos antes de reiniciar el nodo.

  • required="true | false" (opcional)
    Indica si este nodo es crítico. Si es true, todo el proceso roslaunch se terminará cuando el nodo salga.

  • ns="namespace" (opcional)
    Lanza el nodo dentro del namespace especificado.

  • clear_params="true | false" (opcional)
    Limpia todos los parámetros del namespace privado del nodo antes de iniciarlo.

  • output="log | screen" (opcional)
    Determina dónde se envía la salida de log: a un archivo de log o a la pantalla. Por defecto es log.

2. Etiquetas hijas

  • env: Para definir variables de entorno.
  • remap: Para remapear nombres de tema o servicio.
  • rosparam: Para establecer parámetros.
  • param: Para establecer parámetros.

Ejemplo:

xml
<launch>
    <node name="node1" pkg="my_package" type="node_executable" output="screen" respawn="true" respawn_delay="5">
        <param name="param_name" value="param_value"/>
        <remap from="/old_topic" to="/new_topic"/>
    </node>
</launch>

La etiqueta <include>

La etiqueta <include> se utiliza para incluir otro archivo launch con formato XML dentro del archivo launch actual. Esto permite configuraciones modulares y reutilizables.

1. Atributos

  • file="$(find package_name)/path/to/file.launch"
    Especifica la ruta al archivo launch que se incluirá.

  • ns="namespace" (opcional)
    Incluye el archivo bajo el namespace especificado.

2. Etiquetas hijas

  • env: Para definir variables de entorno.
  • arg: Para pasar argumentos al archivo launch incluido.

Ejemplo:

xml
<launch>
    <include file="$(find my_package)/launch/another_launch_file.launch" ns="my_namespace"/>
</launch>

La etiqueta <remap>

La etiqueta <remap> se usa para remapear nombres de tema o servicio en ROS. Es útil para evitar conflictos de nombres o estandarizar nombres entre diferentes nodos.

1. Atributos

  • from="xxx"
    Nombre original del tema o servicio.

  • to="yyy"
    Nuevo nombre para el tema o servicio.

2. Etiquetas hijas

  • Ninguna

Ejemplo:

xml
<launch>
    <node name="node1" pkg="my_package" type="node_executable">
        <remap from="/old_topic" to="/new_topic"/>
    </node>
</launch>

La etiqueta <param>

La etiqueta <param> se utiliza para establecer parámetros en el servidor de parámetros de ROS. La fuente del parámetro puede especificarse directamente en la etiqueta o cargarse desde un archivo externo. Cuando se usa dentro de una etiqueta <node>, el parámetro se establece en el namespace privado del nodo.

1. Atributos

  • name="namespace/parameter_name"
    Nombre del parámetro, que puede incluir un namespace.

  • value="xxx" (opcional)
    Define el valor del parámetro. Si se omite, debe especificarse un archivo externo como fuente del parámetro.

  • type="str | int | double | bool | yaml" (opcional)
    Especifica el tipo del parámetro. Si no se especifica, roslaunch intentará inferir el tipo a partir del valor:

    • Los números con un . se analizan como punto flotante (double).
    • Las cadenas "true" y "false" se analizan como valores booleanos (sin distinguir mayúsculas).
    • El resto se analiza como cadena.

2. Etiquetas hijas

  • Ninguna

Ejemplo:

xml
<launch>
    <node name="node1" pkg="my_package" type="node_executable">
        <param name="namespace/param_name" value="param_value" type="str"/>
    </node>
</launch>

La etiqueta <rosparam>

La etiqueta <rosparam> permite cargar parámetros desde un archivo YAML, exportarlos a un archivo YAML o eliminarlos. Cuando se usa dentro de una etiqueta <node>, los parámetros se consideran privados.

1. Atributos

  • command="load | dump | delete" (opcional, por defecto load)
    Especifica la operación a realizar: cargar parámetros desde un archivo, exportarlos a un archivo o eliminarlos.

  • file="$(find package_name)/path/to/file.yaml"
    Especifica el archivo YAML para cargar o exportar parámetros.

  • param="parameter_name"
    Nombre del parámetro.

  • ns="namespace" (opcional)
    Especifica el namespace para los parámetros.

2. Etiquetas hijas

  • Ninguna

Ejemplo:

xml
<launch>
    <rosparam file="$(find my_package)/config/params.yaml" command="load" ns="my_namespace"/>
</launch>

La etiqueta <group>

La etiqueta <group> se utiliza para agrupar nodos y otras etiquetas, y permite aplicar un namespace u otras configuraciones a todo el grupo.

1. Atributos

  • ns="namespace" (opcional)
    Aplica un namespace a todos los nodos y parámetros dentro del grupo.

  • clear_params="true | false" (opcional)
    Limpia todos los parámetros del namespace del grupo antes de iniciarlo. Úselo con precaución, ya que puede eliminar parámetros críticos.

2. Etiquetas hijas

  • Cualquier etiqueta excepto <launch> puede ser hija de <group>.

Ejemplo:

xml
<launch>
    <group ns="my_namespace" clear_params="true">
        <node name="node1" pkg="my_package" type="node_executable"/>
        <node name="node2" pkg="my_package" type="node_executable"/>
    </group>
</launch>

La etiqueta <arg>

La etiqueta <arg> se usa para definir argumentos dinámicos que se pueden pasar al archivo launch en tiempo de ejecución, similar a los parámetros de una función. Esto aumenta la flexibilidad de los archivos launch.

1. Atributos

  • name="argument_name"
    Nombre del argumento.

  • default="default_value" (opcional)
    Especifica el valor por defecto del argumento.

  • value="value" (opcional)
    Especifica el valor del argumento. No puede usarse simultáneamente con default.

  • doc="description"
    Proporciona una descripción del argumento.

2. Etiquetas hijas

  • Ninguna

3. Ejemplo

Archivo launch con sintaxis de argumentos, hello.launch:

xml
<launch>
    <arg name="robot_name" default="my_robot"/>
    <param name="robot_name" value="$(arg robot_name)"/>
</launch>

Invocación desde la línea de comandos pasando el argumento:

bash
roslaunch hello.launch robot_name:=robot_value

Superposición de espacios de trabajo de ROS

Imagine que tiene dos espacios de trabajo personalizados, Workspace A y Workspace B, ambos con un paquete llamado turtlesim. Además, el espacio de trabajo integrado del sistema también tiene un paquete llamado turtlesim. Cuando invoque el paquete turtlesim, ¿cuál se usará?

Pasos de implementación

Paso 0: Crear los espacios de trabajo A y B

Primero, cree dos espacios de trabajo separados, A y B. Dentro de cada espacio de trabajo, cree un paquete llamado turtlesim.

Paso 1: Modificar el archivo ~/.bashrc

Añada las siguientes líneas a su archivo ~/.bashrc para sourcear los archivos setup de ambos espacios de trabajo:

bash
source /home/user/path/to/workspaceA/devel/setup.bash
source /home/user/path/to/workspaceB/devel/setup.bash

Reemplace /home/user/path/to/ por las rutas reales de sus espacios de trabajo.

Paso 2: Cargar variables de entorno

Abra una nueva terminal y ejecute el siguiente comando para cargar las variables de entorno actualizadas:

bash
source ~/.bashrc

Paso 3: Comprobar las variables de entorno de ROS

Para verificar las rutas de los paquetes ROS, ejecute:

bash
echo $ROS_PACKAGE_PATH

Resultado: La salida mostrará las rutas en este orden: Workspace B → Workspace A → Espacio de trabajo integrado del sistema.

Paso 4: Invocar el paquete turtlesim

Ahora, ejecute el siguiente comando para navegar al paquete turtlesim:

bash
roscd turtlesim

Resultado: Será dirigido al paquete turtlesim dentro de Workspace B.

Manejo de conflictos de nombres de nodos en ROS

Escenario

En ROS, cada nodo tiene un nombre, que se define durante la inicialización del nodo. En C++, esto se hace mediante la API ros::init(argc, argv, "node_name");, mientras que en Python se hace con rospy.init_node("node_name"). En la topología de la red ROS, los nodos deben tener nombres únicos porque, si varios nodos comparten el mismo nombre, puede causar confusión durante la invocación. Concretamente, si se inicia un nodo con un nombre duplicado, el nodo existente con ese nombre se cerrará automáticamente. Pero, ¿qué pasa si necesita ejecutar varias instancias del mismo nodo o lidiar con conflictos de nombres?

ROS proporciona dos estrategias para manejar tales situaciones: namespaces y remapeo de nombres.

  • Los namespaces añaden un prefijo a los nombres de los nodos.
  • El remapeo de nombres asigna un alias a un nombre de nodo.

Ambas estrategias pueden resolver los conflictos de nombres de nodos y pueden implementarse de varias formas:

  1. Usando el comando rosrun.
  2. A través de archivos launch.
  3. En el código del nodo.

Esta sección demostrará cómo usar estos tres métodos para evitar conflictos de nombres de nodos.

Escenario de ejemplo

Vamos a iniciar dos nodos turtlesim_node. Si abre dos terminales y arranca los nodos directamente sin cambios, el primer nodo se cerrará al iniciar el segundo. Verá un mensaje de advertencia:

plaintext
[ WARN] [1578812836.351049332]: Shutdown request received.
[ WARN] [1578812836.351207362]: Reason given for shutdown: [new node registered with same name]

Dado que los nodos no pueden compartir el mismo nombre, exploraremos varias estrategias para resolver este problema.

Uso de rosrun para namespaces y remapeo

1. Establecer un namespace con rosrun

Puede establecer un namespace para un nodo con la siguiente sintaxis:

bash
rosrun package_name node_name __ns:=/new_namespace

Ejemplo:

bash
rosrun turtlesim turtlesim_node __ns:=/xxx
rosrun turtlesim turtlesim_node __ns:=/yyy

Con estos comandos, ambos nodos se ejecutarán sin problemas.

Resultados:

Use rosnode list para comprobar los nodos:

plaintext
/xxx/turtlesim
/yyy/turtlesim

2. Remapear nombres de nodo con rosrun

También puede remapear el nombre de un nodo, dándole efectivamente un alias, con la siguiente sintaxis:

bash
rosrun package_name node_name __name:=new_name

Ejemplo:

bash
rosrun turtlesim turtlesim_node __name:=t1
rosrun turtlesim turtlesim_node __name:=t2

Con estos comandos, ambos nodos se ejecutarán con sus nuevos nombres.

Resultados:

Use rosnode list para comprobar los nodos:

plaintext
/t1
/t2

3. Combinar namespace y remapeo de nombres con rosrun

Puede combinar ambas técnicas, estableciendo un namespace y remapeando el nombre del nodo simultáneamente:

bash
rosrun package_name node_name __ns:=/new_namespace __name:=new_name

Ejemplo:

bash
rosrun turtlesim turtlesim_node __ns:=/xxx __name:=tn

Resultados:

Use rosnode list para comprobar el nodo:

plaintext
/xxx/tn

Alternativamente, puede establecer el namespace usando una variable de entorno antes de iniciar el nodo:

bash
export ROS_NAMESPACE=xxxx

Uso de archivos launch para namespaces y remapeo

En los archivos launch, la etiqueta <node> incluye dos atributos importantes: name y ns. Se utilizan para el remapeo de nombres y para establecer namespaces, respectivamente. Manejar namespaces y remapeo de nombres con un archivo launch es sencillo.

1. Ejemplo de archivo launch

Aquí se muestra cómo establecer namespaces y remapeo de nombres en un archivo launch:

xml
<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="t1" />
    <node pkg="turtlesim" type="turtlesim_node" name="t2" />
    <node pkg="turtlesim" type="turtlesim_node" name="t1" ns="hello"/>
</launch>

En este ejemplo, el atributo name es obligatorio, mientras que ns es opcional.

2. Ejecutar el archivo launch

Ejecute el archivo launch y luego use rosnode list para ver los resultados:

plaintext
/t1
/t2
/hello/t1

Establecer namespaces y remapeo en código

Si está implementando nodos personalizados, dispone de mayor flexibilidad para establecer namespaces y remapeo de nombres directamente en su código.

1. Implementación en C++: remapeo de nombres

Puede establecer un alias de nombre con el siguiente código:

cpp
ros::init(argc, argv, "zhangsan", ros::init_options::AnonymousName);

Ejecución:

Esto añadirá una marca de tiempo al nombre del nodo, garantizando su unicidad.

2. Implementación en C++: establecer un namespace

Puede establecer un namespace directamente en el código de la siguiente manera:

cpp
std::map<std::string, std::string> map;
map["__ns"] = "xxxx";
ros::init(map, "wangqiang");

Ejecución:

Esto establece un namespace para el nodo, permitiendo que se ejecute sin conflictos.

3. Implementación en Python: remapeo de nombres

En Python, puede lograr una funcionalidad similar con el siguiente código:

python
rospy.init_node("lisi", anonymous=True)

Remapeo de nombres de tema en ROS

En ROS, el remapeo de nombres de tema le permite cambiar el nombre de un tema al que un nodo se suscribe o publica sin modificar el código del nodo. Esto es particularmente útil al integrar varios nodos que necesitan comunicarse a través de distintos nombres de tema. Existen tres métodos principales para remapear nombres de tema en ROS:

  1. Usando el comando rosrun.
  2. A través de archivos launch.
  3. Modificando directamente el código en C++ o Python.

Usar rosrun para remapear temas

La sintaxis para remapear un nombre de tema con rosrun es:

bash
rosrun package_name node_name old_topic_name:=new_topic_name

Ejemplo: integración de teleop_twist_keyboard con turtlesim

Existen dos formas de configurar la comunicación entre el nodo teleop_twist_keyboard y el nodo de visualización turtlesim:

1. Solución 1: remapear el tema de teleop_twist_keyboard

En este enfoque, remapeamos el tema del nodo teleop_twist_keyboard a /turtle1/cmd_vel.

  • Iniciar el nodo de control por teclado:

    bash
    rosrun teleop_twist_keyboard teleop_twist_keyboard.py /cmd_vel:=/turtle1/cmd_vel

  • Iniciar el nodo de visualización turtlesim:

    bash
    rosrun turtlesim turtlesim_node

Ambos nodos se comunicarán correctamente usando el tema /turtle1/cmd_vel.

2. Solución 2: remapear el tema de turtlesim

Alternativamente, podemos remapear el tema del nodo turtlesim a /cmd_vel.

  • Iniciar el nodo de control por teclado:

    bash
    rosrun teleop_twist_keyboard teleop_twist_keyboard.py

  • Iniciar el nodo de visualización turtlesim:

    bash
    rosrun turtlesim turtlesim_node /turtle1/cmd_vel:=/cmd_vel

Ambos nodos se comunicarán correctamente usando el tema /cmd_vel.

Usar archivos launch para remapear temas

También puede remapear temas en un archivo launch. La sintaxis para remapear un tema en un archivo launch es:

xml
<node pkg="package_name" type="node_type" name="node_name">
    <remap from="original_topic" to="new_topic" />
</node>

Ejemplo: integración de teleop_twist_keyboard con turtlesim usando archivos launch

De nuevo, hay dos soluciones:

1. Solución 1: remapear el tema de teleop_twist_keyboard

En este enfoque, remapeamos el tema del nodo teleop_twist_keyboard a /turtle1/cmd_vel.

xml
<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="t1" />
    <node pkg="teleop_twist_keyboard" type="teleop_twist_keyboard.py" name="key">
        <remap from="/cmd_vel" to="/turtle1/cmd_vel" />
    </node>
</launch>

Ambos nodos se comunicarán correctamente.

2. Solución 2: remapear el tema de turtlesim

En este enfoque, remapeamos el tema del nodo turtlesim a /cmd_vel.

xml
<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="t1">
        <remap from="/turtle1/cmd_vel" to="/cmd_vel" />
    </node>
    <node pkg="teleop_twist_keyboard" type="teleop_twist_keyboard.py" name="key" />
</launch>

Ambos nodos se comunicarán correctamente.

Remapeo de temas en código

El nombre del tema en ROS se ve influido por el namespace del nodo, el nombre del nodo y el propio nombre del tema. Los nombres de tema generalmente se pueden clasificar en tres tipos:

  1. Global: El nombre del tema es absoluto y empieza por /, lo que lo hace independiente del namespace del nodo.
  2. Relativo: El nombre del tema es relativo y no empieza por /, lo que significa que se interpreta dentro del namespace del nodo.
  3. Privado: El nombre del tema es privado y empieza por ~, lo que significa que se resuelve respecto al namespace privado del nodo.

Exploremos estos conceptos a través de ejemplos en C++ y Python.

1. Implementación en C++

Preparación del ejemplo:

  1. Inicialice el nodo con un nombre:

    cpp
    ros::init(argc, argv, "hello");

  2. Establezca distintos tipos de nombres de tema.

  3. Pase un argumento __ns:=xxx al iniciar el nodo.

  4. Tras iniciar el nodo, use rostopic para comprobar la información del tema.

Nombre de tema global

Los nombres de tema globales empiezan por / y son independientes del nombre o namespace del nodo.

  • Ejemplo 1:

    cpp
    ros::Publisher pub = nh.advertise<std_msgs::String>("/chatter", 1000);

    Resultado: /chatter

  • Ejemplo 2:

    cpp
    ros::Publisher pub = nh.advertise<std_msgs::String>("/chatter/money", 1000);

    Resultado: /chatter/money

Nombre de tema relativo

Los nombres de tema relativos no empiezan por / y se resuelven respecto al namespace del nodo.

  • Ejemplo 1:

    cpp
    ros::Publisher pub = nh.advertise<std_msgs::String>("chatter", 1000);

    Resultado: xxx/chatter

  • Ejemplo 2:

    cpp
    ros::Publisher pub = nh.advertise<std_msgs::String>("chatter/money", 1000);

    Resultado: xxx/chatter/money

Nombre de tema privado

Los nombres de tema privados empiezan por ~ y se resuelven respecto al namespace privado del nodo.

  • Ejemplo 1:

    cpp
    ros::NodeHandle nh("~");
ros::Publisher pub = nh.advertise<std_msgs::String>("chatter", 1000);

    Resultado: /xxx/hello/chatter

  • Ejemplo 2:

    cpp
    ros::NodeHandle nh("~");
ros::Publisher pub = nh.advertise<std_msgs::String>("chatter/money", 1000);

    Resultado: /xxx/hello/chatter/money

  • Caso especial: Cuando se usa ~, si el nombre del tema empieza por /, se trata como absoluto.

    cpp
    ros::NodeHandle nh("~");
ros::Publisher pub = nh.advertise<std_msgs::String>("/chatter/money", 1000);

    Resultado: /chatter/money

Implementación en Python

Preparación del ejemplo:

  1. Inicialice el nodo con un nombre:

    python
    rospy.init_node("hello")

  2. Establezca distintos tipos de nombres de tema.

  3. Pase un argumento __ns:=xxx al iniciar el nodo.

  4. Tras iniciar el nodo, use rostopic para comprobar la información del tema.

Nombre de tema global

Los nombres de tema globales empiezan por / y son independientes del nombre o namespace del nodo.

  • Ejemplo 1:

    python
    pub = rospy.Publisher("/chatter", String, queue_size=1000)

    Resultado: /chatter

  • Ejemplo 2:

    python
    pub = rospy.Publisher("/chatter/money", String, queue_size=1000)

    Resultado: /chatter/money

Nombre de tema relativo

Los nombres de tema relativos no empiezan por / y se resuelven respecto al namespace del nodo.

  • Ejemplo 1:

    python
    pub = rospy.Publisher("chatter", String, queue_size=1000)

    Resultado: xxx/chatter

  • Ejemplo 2:

    python
    pub = rospy.Publisher("chatter/money", String, queue_size=1000)

    Resultado: xxx/chatter/money

Nombre de tema privado

Los nombres de tema privados empiezan por ~ y se resuelven respecto al namespace privado del nodo.

  • Ejemplo 1:

    python
    pub = rospy.Publisher("~chatter", String, queue_size=1000)

    Resultado: /xxx/hello/chatter

  • Ejemplo 2:

    python
    pub = rospy.Publisher("~chatter/money", String, queue_size=1000)

    Resultado: /xxx/hello/chatter/money

Establecer parámetros en ROS

En ROS, los parámetros se utilizan para configurar nodos en tiempo de ejecución. Pueden establecerse de varias maneras: usando el comando rosrun, dentro de archivos launch o directamente en el código. Los parámetros pueden ser globales, relativos o privados, según cómo se definan.

Establecer parámetros con rosrun

Puede establecer parámetros al lanzar un nodo con el comando rosrun. La sintaxis para establecer parámetros es:

bash
rosrun package_name node_name _parameter_name:=parameter_value

Ejemplo: establecer un parámetro para el nodo Turtlesim

Iniciemos turtlesim_node y establezcamos un parámetro A = 100.

bash
rosrun turtlesim turtlesim_node _A:=100

Comprobar los parámetros

Puede usar el siguiente comando para listar todos los parámetros y comprobar los resultados:

bash
rosparam list

Salida:

plaintext
/turtlesim/A
/turtlesim/background_b
/turtlesim/background_g
/turtlesim/background_r

Explicación: El parámetro A lleva como prefijo el nombre del nodo (/turtlesim/), lo que indica que cuando se utiliza rosrun para establecer un parámetro, se hace en modo namespace privado.

Establecer parámetros en archivos launch

Como se ha comentado anteriormente, los parámetros pueden establecerse en los archivos launch usando las etiquetas <param> o <rosparam>. Los parámetros establecidos fuera de la etiqueta <node> son globales, mientras que los establecidos dentro de la etiqueta <node> son privados y relativos al namespace del nodo.

Ejemplo: establecer parámetros con la etiqueta <param>

A continuación se muestra un ejemplo donde establecemos un parámetro global y otro privado:

xml
<launch>
    <param name="p1" value="100" />
    <node pkg="turtlesim" type="turtlesim_node" name="t1">
        <param name="p2" value="100" />
    </node>
</launch>

Comprobar los parámetros

Tras ejecutar el archivo launch, puede comprobar los parámetros con:

bash
rosparam list

Salida:

plaintext
/p1
/t1/p2

Explicación: El parámetro p1 es global, mientras que p2 es privado al nodo t1, como indica el namespace.

Establecer parámetros en código

Establecer parámetros en código proporciona mayor flexibilidad, permitiendo definir parámetros globales, relativos y privados de forma programática.

1. Implementación en C++

En C++, los parámetros pueden establecerse mediante la API ros::param o a través de un objeto ros::NodeHandle.

1.1 Usar ros::param para establecer parámetros

La función ros::param::set se utiliza para establecer parámetros. El primer argumento es el nombre del parámetro y el segundo es su valor. Si el nombre del parámetro empieza por /, es un parámetro global. Si empieza por ~, es privado. En caso contrario, es un parámetro relativo.

Ejemplo:

cpp
ros::param::set("/set_A", 100); // Global, independent of namespace and node name
ros::param::set("set_B", 100);  // Relative, dependent on namespace
ros::param::set("~set_C", 100); // Private, dependent on namespace and node name

Suponiendo que el namespace es xxx y el nombre del nodo es yyy, comprobar los parámetros con rosparam list mostraría:

plaintext
/set_A
/xxx/set_B
/xxx/yyy/set_C

Usar ros::NodeHandle para establecer parámetros

Para establecer parámetros con ros::NodeHandle, primero cree un objeto NodeHandle y luego invoque el método setParam. Si el nombre del parámetro empieza por /, es global. Si no empieza por /, que sea relativo o privado depende de cómo se haya creado el objeto NodeHandle.

Ejemplo:

cpp
ros::NodeHandle nh;
nh.setParam("/nh_A", 100); // Global, independent of namespace and node name

nh.setParam("nh_B", 100);  // Relative, dependent on namespace

ros::NodeHandle nh_private("~");
nh_private.setParam("nh_C", 100); // Private, dependent on namespace and node name

Suponiendo que el namespace es xxx y el nombre del nodo es yyy, comprobar los parámetros con rosparam list mostraría:

plaintext
/nh_A
/xxx/nh_B
/xxx/yyy/nh_C

2. Implementación en Python

En Python, establecer parámetros es ligeramente más sencillo que en C++. La función rospy.set_param se utiliza para establecer parámetros. El primer argumento es el nombre del parámetro y el segundo es su valor. Como en C++, si el nombre del parámetro empieza por /, es global. Si empieza por ~, es privado. En caso contrario, es relativo.

Ejemplo:

python
rospy.set_param("/py_A", 100)  # Global, independent of namespace and node name
rospy.set_param("py_B", 100)   # Relative, dependent on namespace
rospy.set_param("~py_C", 100)  # Private, dependent on namespace and node name

Suponiendo que el namespace es xxx y el nombre del nodo es yyy, comprobar los parámetros con rosparam list mostraría:

plaintext
/py_A
/xxx/py_B
/xxx/yyy/py_C