Cómo usar Robot State Publisher – ROS Spanish Tutorial

Written by Jose Manuel Pacheco Garriazo



Spanish ROS Tutorials



25/02/2024

This tutorial is created by Rosbotics Ambassador 017 Jose

Rosbotics Ambassador Program https://www.theconstruct.ai/rosbotics-ambassador/)

Lo que vamos a aprender

Como iniciar Robot State Publisher
Como usar la herramienta rqt_tf_tree
Como visualizar el sistema robótico en RViz
Como visualizar el sistema robótico en Gazebo

Lista de recursos usados en esta publicación

Usa este rosject: https://app.theconstructsim.com/l/5e2843be/
The Construct: https://app.theconstructsim.com/
Cursos ROS: TF ROS: https://app.theconstructsim.com/courses/10

Resumen

ROS (Robot Operating System) se está convirtiendo en el “framework” estándar para programar robots. En esta publicación, aprenderemos a usar adecuadamente Robot State Publisher para publicar las transformaciones TF de los sistemas coordenados de nuestro robot. Así como, lo necesario para visualizar el robot en RViz y Gazebo.

Abriendo el rosject

Para seguir este tutorial, necesitamos tener instalado ROS en nuestro sistema, y lo ideal sería tener un catkin_ws (Espacio de Trabajo ROS). Para facilitarte la vida, ya hemos preparado un rosject para eso: https://app.theconstructsim.com/l/5e2843be/.

Simplemente copiando el rosject (haciendo clic en el enlace de arriba), tendrás una configuración ya preparada para ti.

Después de haber copiado el rosject a tu propia área de trabajo, deberías ver el botón RUN. Haz clic en ese botón para lanzar el rosject (abajo tienes un ejemplo de rosject).

Tras pulsar el botón RUN, deberías tener cargado el rosject. Ahora, pasemos a la siguiente sección para ponernos manos a la obra.

Iniciando Robot State Publisher y visualizando el robot en RViz

Para usar Robot State Publisher necesitamos de la descripción de un robot en archivos urdf o xacro. En este rosject usaremos archivos xacro de un robot móvil simple, los cuales están en la carpeta robot de nuestro paquete robot_tutorial.

Robot a usar en el tutorial – mobile_robot

Creamos un archivo launch robot_visualization.launch para iniciar robot_state_publisher. Para ello, en un nuevo terminal colocamos lo siguiente:
cd /home/user/catkin_ws/src/robot_tutorial mkdir launch touch launch/robot_visualization.launch

En ese archivo creado colocamos:

robot_visualization.launch
<launch>  <param name="robot_description" command="$(find xacro)/xacro $(find robot_tutorial)/robot/mobile_robot.urdf.xacro" />  <node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" output="screen"> <param name="publish_frequency" type="double" value="5.0" /> </node> </launch>

Con esto:

Cargamos la descripción del robot en el parámetro robot_description.

Iniciamos el nodo robot_state_publisher que tomará la descripción del robot para publicar las transformaciones con una frecuencia de 5Hz.

Previamente, antes de iniciar el launch nos aseguramos de compilar nuestro paquete, para ello, en un terminal colocamos:

cd /home/user/catkin_ws catkin_make source devel/setup.bash rospack profile

Con ello, ya podemos iniciar nuestro archivo launch:
roslaunch robot_tutorial robot_visualization.launch

Al iniciar el launch y visualizar el árbol TF usando rosrun rqt_tf_tree rqt_tf_tree obtenemos que no están presentes las transformaciones de las juntas no fijas, es decir, de las ruedas.

Árbol de tf publicado por robot_state_publisher – incompleto

Esto se debe a que robot_state_publisher necesita que se publiquen los valores de las juntas no fijas para hacer las transformaciones, de lo contrario solo publicará las trasformaciones estáticas (juntas fijas).

Por ello debemos añadir un nodo que publique los valores de las juntas de alguna manera. Usaremos para ello joint_state_publisher_gui. Añadimos lo siguiente al archivo recién creado:

robot_visualization.launch
 <node pkg="joint_state_publisher_gui" type="joint_state_publisher_gui" name="joint_state_publisher_gui" output="screen" />  <node name="rviz" pkg="rviz" type="rviz" args="-d $(find robot_tutorial)/launch/robot.rviz" />

Con esto:

Iniciamos el nodo joint_state_publisher_gui para que publique los valores de las juntas de las ruedas.
Iniciamos RViz con una configuración que guardaremos en launch/robot.rviz

Con ello ya vemos las transformaciones faltantes al usar rqt_tf_tree y también podemos ver el robot en RViz.

Árbol de tf publicado por robot_state_publisher – completo

Robot en RViz – completo

cd /home/user/catkin_ws/src/robot_tutorial mkdir config touch config/robot_control.yaml

En este archivo nuevo, colocaremos el controlador joint_state_controller, que será el encargado de publicar los valores de las juntas no fijas del robot simulado en Gazebo.

robot_control.yaml

# Publicar todos los estados de las juntas (/joint_states) ----------------------------------- joint_state_controller: type: joint_state_controller/JointStateController publish_rate: 50

Posteriormente, creamos otro archivo launch donde colocaremos lo necesario para la simulación.
cd /home/user/catkin_ws/src/robot_tutorial touch launch/spawn_robot.launch

En este archivo, colocamos lo siguiente:
<launch> <arg name="x" default="0.0" /> <arg name="y" default="0.0" /> <arg name="z" default="0.2" /> <arg name="robot_name" default="mobile_robot" />  <param name="robot_description" command="$(find xacro)/xacro $(find robot_tutorial)/robot/mobile_robot.urdf.xacro" />

<!– Cargamos los controladores –>
<rosparam file=”$(find robot_tutorial)/config/robot_control.yaml” command=”load”/>
<!– Iniciamos robot_state_publisher para publicar las tranformaciones tf –>
<node name=”robot_state_publisher” pkg=”robot_state_publisher” type=”robot_state_publisher”
output=”screen”>
<param name=”publish_frequency” type=”double” value=”5.0″ />
</node>
<!– Iniciamos un mundo vacio en gazebo –>
<include file=”$(find gazebo_ros)/launch/empty_world.launch”/>
<!– Iniciamos los controladores –>
<node name=”controller_spawner” pkg=”controller_manager” type=”spawner” respawn=”false”
output=”screen” ns=”/” args=”joint_state_controller”/>
<!– Hacer aparecer el robot –>
<node name=”urdf_spawner” pkg=”gazebo_ros” type=”spawn_model” respawn=”false” output=”screen”
args=”-urdf -x $(arg x) -y $(arg y) -z $(arg z) -model $(arg robot_name) -param robot_description”/>
<!– Iniciamos rviz –>
<node name=”rviz” pkg=”rviz” type=”rviz” args=”-d $(find robot_tutorial)/launch/robot.rviz” />
</launch>

Lo que hace este archivo launch es:

- Establecer una posición de aparición del robot en el mundo de Gazebo.
- Asignamos un nombre al robot (mobile_robot).

Cargar la descripción del robot en el parámetro robot_description.

Cargamos el controlador joint_state_controller que definimos previamente.
Iniciar el nodo robot_state_publisher con una frecuencia de publicación de 5Hz.
Iniciamos un mundo vacío en Gazebo.
Iniciamos el controlador usando el nodo controller_spawner.
Hacemos aparecer el robot en el mundo de Gazebo usando el nodo urdf_spawner pasándole los parámetros de posición, nombre y descripción del robot que previamente definimos.
Iniciamos RViz con la configuración que ya guardamos en launch/robot.rviz

Iniciamos este launch con:
roslaunch robot_tutorial spawn_robot.launch

Al iniciar el launch y visualizar el árbol TF usando rosrun rqt_tf_tree rqt_tf_tree observamos el mismo problema anterior, esto se debe a que, para gazebo, es necesario colocar las transmisiones a todas las juntas no fijas al final del archivo xacro de nuestro robot.

Árbol de tf publicado por robot_state_publisher – incompleto

Robot en RViz – incompleto

Para ello nos dirigimos al archivo xacro principal de nuestro robot para añadir en la parte final lo siguiente:

mobile_robot.urdf.xacro

<gazebo> <plugin name="gazebo_ros_control" filename="libgazebo_ros_control.so"> </plugin> </gazebo> <transmission name="tran1"> <type>transmission_interface/SimpleTransmission</type> <joint name="left_wheel_joint"> <hardwareInterface>hardware_interface/EffortJointInterface</hardwareInterface> </joint> <actuator name="motor1"> <hardwareInterface>hardware_interface/EffortJointInterface</hardwareInterface> <mechanicalReduction>1</mechanicalReduction> </actuator> </transmission> <transmission name="tran2"> <type>transmission_interface/SimpleTransmission</type> <joint name="right_wheel_joint"> <hardwareInterface>hardware_interface/EffortJointInterface</hardwareInterface> </joint> <actuator name="motor2"> <hardwareInterface>hardware_interface/EffortJointInterface</hardwareInterface> <mechanicalReduction>1</mechanicalReduction> </actuator> </transmission>

Con esto:

Añadimos el plugin gazebo_ros_control.
Añadimos la transmisión a la junta left_wheel_joint (debe ser el mismo nombre de la junta usada en la definición del joint).
Añadimos la transmisión a la junta right_wheel_joint (debe ser el mismo nombre de la junta usada en la definición del joint).

Con ello ya se visualizan las transformaciones de todas las juntas del robot y ya tenemos el robot tanto en RVIZ como en Gazebo listo para añadir los controladores y sensores que se requieran.