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>
<!-- Cargar el URDF en el servidor de parámetros de ROS -->
<param name="robot_description" command="$(find xacro)/xacro $(find robot_tutorial)/robot/mobile_robot.urdf.xacro" />
<!-- 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>
</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:
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" />
<!-- Cargar el URDF en el servidor de parámetros de ROS -->
<param name="robot_description" command="$(find xacro)/xacro $(find robot_tutorial)/robot/mobile_robot.urdf.xacro" />
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:
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.
ROS (Robot Operating System) se está convirtiendo en el “framework” estándar para programar robots. En este tutorial crearemos paso a paso el paquete de configuración de MoveIt usando Moveit Setup Assistant para tu robot. Ten encuesta que se usará ROS Noetic para este tutorial.
PASO 1: 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/5f3d5b06/.
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.
PASO 2: Iniciando MoveIt Setup Assistant
Para crear un paquete MoveIt para nuestro robot usando el asistente de configuración de MoveIt necesitamos solamente el paquete de descripción de este (que contenga los archivos urdf/xacro y los meshes de ser necesario).
El robot que se usará es el EDO (una paquete de descripción con una versión simplificada).
Para iniciar el asistente ejecutamos el siguiente comando en una terminal:
Con ello se iniciar el asistente y deberíamos ver esta interfaz:
PASO 3: Configurar el paquete con la ayuda del asistente
El asistente de MoveIt tiene múltiples pestañas de configuración. Recorreremos cada una de ellas en orden configurando lo necesario.
Inicio (Start)
En esta parte cargamos la descripción de nuestro robot mediante el archivo urdf/xacro principal.
Para seleccionamos la opción Create New Moveit Configuration Package, luego buscamos el xacro de nuestro robot dándole a Browse y luego le damos a Load Files para cargar nuestro robot.
Esperamos, y si todo esta correcto con nuestro archivo Xacro/URDF se mostrará nuestro robot en la parte derecha.
Autocolisiones (Self-collisions)
En esta parte le decimos a MoveIt que pares de juntas no necesita revisar por colisiones ya que siempre están en colisión, reduciendo así la carga computacional a este proceso.
Aquí solo pulsamos el botón Generate Collision Matrix y la matriz ya se genera automáticamente.
Juntas virtuales (Virtual Joints)
En esta parte creamos una junta virtual entre la base del robot y un sistema coordenado de referencia. Sirve para posicionar el robot en world o una plataforma móvil.
Esta configuración ya se puede hacer desde nuestro archivo xacro (como en este ejemplo), por lo que no se definirá ninguna junta virtual.
Grupos de planificación (Planning groups)
En esta parte se crea los grupos de planificación ya que MoveIt trabaja con grupos para la planificación de movimiento. Típicamente se configura un grupo para las juntas del brazo robótico y otro para el efector final.
Aquí le damos a Add Group, y configuramos las opciones que nos aparecen.
Group Name: Nombre del grupo a elección. Le colocaremos arm.
Kinematic Solver: El plugin encargado de resolver la cinemática del robot. Usaremos KDLKinematicsPlugin.
Group Default Planner: El algoritmo encargado de realizar la planificación de movimiento. Usaremos RRT.
Las demás opciones las dejamos con sus valores por defecto y ahora seleccionaremos las juntas que pertenecerán a este grupo, para ello le damos a Add Joints.
Seleccionamos las juntas que deseamos que pertenezcan al grupo, y le damos a Save.
Debido a que el robot del ejemplo no cuenta con un efector final solo creamos un grupo para el brazo robótico.
Poses del robot (Robot Poses)
En esta parte configuramos posiciones del robot según nuestras necesidades. Para ello asignamos un set de valores de juntas para la pose deseada y le asignamos un nombre.
Le damos a Add Pose, seleccionamos el grupo de planificación (solo tenemos a arm en este caso), le ponemos un nombre (home que siempre es conveniente definirlo) y le damos los valores correspondientes a las juntas moviendo los Sliders o colocando directamente los valores. Le damos a Save para guardar esta pose.
Añadimos otra pose al robot a la que llamaremos Inicio, al que le puedes dar los valores válidos que desees. En la parte derecha puedes ver la pose que robot adopta. Esta pestaña es importante para ver si las juntas de tu robot están correctamente definidas en la descripción.
Efectores final (End Effectors)
En esta parte se añaden los efectores finales definiendo el nombre, el grupo de planificación y el sistema coordenado padre.
Ya que en este ejemplo no contamos con un efector final no lo definiremos.
Juntas Pasivas (Passive Joints)
En esta parte se definen las juntas que no tiene un actuador. Ya que nuestro robot no tiene ese tipo de juntas no definiremos nada en esta pestaña.
Controladores (Controllers)
En esta parte se definen los controladores, los cuales deben ser los adecuados para nuestro robot.
Le damos a Add Controller, le ponemos un nombre a elección, seleccionamos el tipo de controlador y seleccionamos el grupo de planificación al que se aplicará este controlador.
Luego solo seleccionamos el grupos de planificación correspondiente y guardamos. Con ello ya tendríamos el controlador configurado.
Simulación (Simulation)
En esta parte se puede autogenerar los cambios necesarios en el URDF para que los controladores y MoveIt sea compatible con la simulación en Gazebo. Los cambios se muestran en verde luego de darle click a Generate URDF.
Básicamente se añaden inercias, transmisiones y el plugin gazebo_ros_control, sin embargo, todo ello ya esta definido en el xacro de nuestro robot así que no necesitaremos copiar y pegar este URDF generado.
Percepción 3D (3D Perception)
En esta parte se configura el sensor 3D con el cual trabaja nuestro robot. Podemos seleccionar entre 2 tipos de plugins para sensor 3D: PointCloud y Depth Map. Y luego configurar algunos parámetros y el tópico que se usará.
Ya que en este ejemplo el robot no cuenta con un sensor, no lo configuraremos.
Información del autor (Author Information)
En esta parte se inserta el nombre y el correo del creador del paquete.
Archivos de configuración (Configuration Files)
En esta parte se genera el paquete de configuración de MoveIt con todo lo que hemos definido previamente.
Para ello, primero le damos a Browse para seleccionar la carpeta en la que queremos guardar nuestro paquete, debemos elegir un nombre (es común usar la estructura nombreRobot_moveit_config), luego le damos a Generate Package, le damos Ok en la ventana de advertencia que nos aparece (Nos alerta que no definimos juntas virtuales ni efector final) y esperamos a que se genere nuestro paquete.
Una vez generado nuestro paquete le damos a Exit Setup Assistant. Con ello ya tenemos nuestro paquete MoveIt listo para usarse.
Los archivos del paquete los puedes encontrar en la ruta que especificaste anteriormente, esta compuesto de archivos de configuración y launch.
Ejecutar la demo en RViz
Listo! ya tenemos nuestro paquete MoveIt generado, para probarlo ejecutaremos el launch demo.launch con el siguiente comando:
roslaunch edo_moveit_config demo.launch
Con ello se iniciará RViz junto con todo lo necesario para realizar la planificación de movimiento a través de la interfaz que se carga en RViz. En la pestaña Planning de dicha interfaz podemos seleccionar un grupo de planificación, una pose inicial, una pose deseada y darle a planear y ejecutar.
Observarás como el robot se mueve por la ruta planificada. Y así de sencillo!, partiendo de un paquete de descripción de nuestro robot podemos realizar planificación de movimiento gracias al asistente de MoveIt.
PS: If you don’t have an account on the ROS Development Studio, you would need to create one. Once you create an account or log in, you will be able to follow the steps to setup MoveIt! for a Robot Arm. You will also get access to the robot arm in our remote real robot lab, among other features.
You might also want to try this on a local PC if you have ROS installed. However, please note that we cannot support local PCs and you will have to fix any errors you run into on your own.
Step 2: Watch the video to understand how to setup MoveIt! for a Robot Arm
Main point: you just need to have the URDF file for the robot arm and you feed that into MoveIt!
Here you go:
Step 3: Consolidate your learning
Do you understand how to setup MoveIt! for a Robot Arm? If not, have you gone over the video again? If you have any problems with setting up MoveIt! for the arm, please let us know in the comments.
Did you like this post? Do you have any questions about how to setup MoveIt! for a Robot Arm? Whatever the case, please leave a comment on the comments section below, so we can interact and learn from each other.
If you want to learn about other ROS topics, please let us know in the comments area and we will do a video or post about it.
Step 1. Create a project in ROS Development Studio(ROSDS)
ROSDS helps you follow our tutorial in a fast pace without dealing without setting up an environment locally. If you haven’t had an account yet, you can create a free account here. Let’s create a new project and call it moveit_qa.
Step 2. Use the moveit package
In this tutorial, we have already preconfigured the fetch robot and moveit package for it. If you want to know how to configure the moveit package, please check our ROS Manipulation in 5 days course. Then we create a file called execute_trajectories.py inside the fetch_moveit_config folder with the following content.
Then we run the script again. The robot should do several movements as we planned.
Want to learn more?
If you want to learn more about the motion planning with moveit package, please check our ROS Manipulation in 5 Days course.
Edit by: Tony Huang
Feedback
Did you like this video? Do you have questions about what is explained? Whatever the case, please leave a comment on the comments section below, so we can interact and learn from each other.
If you want to learn about other ROS topics, please let us know on the comments area and we will do a video about it.
In this video we’ll improve our URDF code of the robotic manipulator using XACRO. From the URDF model, finish the robot, creating all joints and links and visualize it using RViz. Up to the end of the video, we will have the model finished, a launch file to visualize it and a RViz and some MACROs to help you in the development of the robot.
