CarlosAlfredoMarin/Brazo_Robotico

Construcción de un Brazo Robótico mediante Código

Este tutorial describe los detalles de un objeto de modelo URDF y un ejemplo de la construcción de un brazo robótico de 3 articulaciones.

Brazo Robótico a construir

Enlaces: un enlace contiene las propiedades físicas de un cuerpo del modelo. Puede ser una rueda o un eslabón en una cadena conjunta. Cada enlace puede contener muchos elementos visuales y de colisión. Intente reducir la cantidad de enlaces en sus modelos para mejorar el rendimiento y la estabilidad. Por ejemplo, un modelo de mesa podría constar de 5 eslabones (4 para las patas y 1 para la parte superior) conectados mediante articulaciones. Sin embargo, esto es demasiado complejo, especialmente porque las articulaciones nunca se moverán. En su lugar, cree la tabla con 1 enlace y 5 elementos de colisión.

Colisión: un elemento de colisión encapsula una geometría que se utiliza para la comprobación de colisiones. Puede ser una forma simple (que se prefiere) o una malla triangular (que consume más recursos). Un enlace puede contener muchos elementos de colisión.

Visual: un elemento visual se utiliza para visualizar partes de un enlace. Un enlace puede contener 0 o más elementos visuales.

Inercial: el elemento inercial describe las propiedades dinámicas del enlace, como la masa y la matriz de inercia rotacional.

Sensor: un sensor recopila datos del mundo para usarlos en complementos. Un enlace puede contener 0 o más sensores.

Luz: un elemento de luz describe una fuente de luz adjunta a un enlace. Un enlace puede contener cero o más luces.

Articulaciones: una articulación conecta dos enlaces. Se establece una relación de padre e hijo junto con otros parámetros, como el eje de rotación y los límites de las articulaciones.

Complementos: un complemento es una biblioteca compartida creada por un tercero para controlar un modelo.

Crear el Espacio de Trabajo

Crear una carpeta en el usuario raíz

mkdir -p ~/Brazo_Robot/src 

Entramos a la carpeta

cd ~/Brazo_Robot/src 

Inicializamos el espacio de trabajo

catkin_init_workspace 

Salimos de la carpeta src

cd .. 

Compilamos el espacio de trabajo

catkin_make 

Observamos el listado de carpetas que se han creado

ls 

Siempre que abramos un terminal nuevo debemos ejecutar un fichero de inicialización

echo "source ~/Brazo_Robot/devel/setup.bash" >> ~/.bashrc 

Otra opción es crear un fichero de inicialización que ejecute ese comando automáticamente,

source ~/Brazo_Robot/devel/setup.bash 

Ahora, empezamos a construir el robot, dentro de la carpeta src:

cd ~/Brazo_Robot/src 

Construcción de las Partes de Robot

Creamos el paquete de desarrollo, el cual tiene un archivo con las librerías necesarias y la configuración. Las librerías que vamos a necesitar son std_msgs, rospy, roscpp yurdf, luego iremos añadiendo las librerías necesarias para construir el robot. El paquete tendrá el nombre robot1_description, este nombre debe estar todo en minúsculas para evitar futuros Warnings.

catkin_create_pkg robot1_description std_msgs rospy roscpp urdf

Si se genera un error, para arreglarlo actualizamos las herramientas de catkin

sudo apt-get install python3-osrf-pycommon python3-catkin-tools

Entramos a la carpeta robot1_description

cd robot1_description

Creamos una carpeta urdf

mkdir urdf

En la carpeta urdf es donde alojaremos los archivos de descripción del robot. El archivo robot1.urdf contiene la descripción de las siguientes partes del robot:

• Base (base_link)
• Rueda 1 (wheel_1)
• Rueda 2 (wheel_2)
• Rueda 3 (wheel_3)
• Rueda 4 (wheel_4)
• Juntura Base-Rueda 1 (base_to_wheel1)
• Juntura Base-Rueda 2 (base_to_wheel2)
• Juntura Base-Rueda 3 (base_to_wheel3)
• Juntura Base-Rueda 4 (base_to_wheel4)
• Base de los eslabones (arm_base)
• Juntura Base-Base de los eslabones (basse_to_arm_base)
• Eslabón 1 (arm_1)
• Eslabón 2 (arm_2)
• Juntura Base-Eslabón 1 (arm_1_to_base)
• Juntura Eslabón 1 - Eslabón 2 (arm_1_to_arm_2)
• Pinza izquierda (left_gripper)
• Pinza derecha (right_gripper)
• Juntura Eslabón 2 - Pinza izquierda (left_gripper_joint)
• Juntura Eslabón 2 - Pinza derecha (right_gripper_joint)
• Punta izquierda (left_tip)
• Punta derecha (right_tip)
• Juntura Pinza izquierda - Punta izquierda (left_tip_joint)
• Juntura Pinza derecha - Punta derecha (right_tip_joint)

Esta forma de describir el robot es ineficiente, ya que se repiten las estructuras de código varias veces, por ejemplo, para el código para crear la rueda 1 es casi el mismo que para las ruedas 2, 3 y 4. Por este motivo, resulta conveniente describir el robot de una forma más eficiente reutilizando bloques de código, esto se logra por medio de la etiqueta xacro, la cual funciona se manera semejante una función que recibe parámetros como entradas.

<xacro:macro name=" params="">
	...
</xacro:macro>

El archivo robot1_reduced.xacro contiene el nuevo código reducido, el cual contiene:

• Base (base_link)
• Rueda (wheel)
• Juntura Base-Rueda (base_to_wheel)
• Base de los eslabones (arm\_base)
• Juntura Base-Base de los eslabones (basse_to_arm_base)
• Eslabón (arm)
• Juntura Base-Eslabón 1 (arm_1_to_arm_base)
• Juntura Eslabón 1 - Eslabón 2 (arm_1_to_arm_2)
• Pinza (lr_gripper)
• Punta (lr_tip)
• Juntura Eslabón - Pinza (gripper_joint)
• Juntura Pinza - Punta (lr_tip_joint)

Existe una herramienta que permite ver el diagrama de conexiones del robot, usamos el siguiente comando para instalarla:

sudo apt install liburdfdom-tools

ejecutamos la herramienta (debemos estar primero ubicados en la carpeta que contiene el archivo .urdf)

cd urdf
urdf_to_graphiz robot1.urdf

Ahora, tenemos 2 archivos nuevos creados, en los cuales está la visualización gráfica de los link y joint, abrimos el archivo nuevo de extensión .pdf:

Diagrama de conexiones

Para revisar si el archivo URDF tiene errores:

check_urdf robot1.urdf

Es importante entrar a la carpeta donde se encuentra el archivos .urdf, de lo contrario, genera error.

Ahora, vamos a crear un archivo lanzador, con solo llamar este archivo por consola, se ejecutará automáticamente el roscore y se ejecutará Gazebo con nuestro robot en pantalla. Creamos una carpeta llamada launch:

/robot1_description/
mkdir launch

Copiar el archivo display.launch, compilamos el espacio de trabajo, abrimos terminal en Brazo_Robot:

catkin_make

Ejecutamos el archivo lanzador con el siguiente comando:

roslaunch robot1_description display.launch

Para agregar un mesh, se descargan los archivos l_finger.daey y l_finger_tip.dae a la carpeta meshes, que contiene los meshes de un un efector final basado en 2 pinzas. Ahora que ya tenemos los meshes disponibles para su uso, solo queda agregar la línea de código para llamar al mesh, esto se hace dentro de la etiqueta <geometry>

<geometry>
    <mesh filename="package://robot1_description/meshes/l_finger.dae"/>
</geometry>

Esto se realiza para las 2 pinzas y para las 2 puntas de las pinzas.

Después compilamos el espacio de trabajo nuevamente

catkin_make

Al ejecutar el lanzador, nuestro robot ya tendrá un efector final:

Efector final de brazo.

Colores para el Brazo

Para pintar el robot con distintos colores es necesario agregar la siguiente línea de código al archivo robot1_reduced.xacro:

<xacro:include filename="$(find robot1_description)/urdf/robot.gazebo"/>

Con esta nueva línea de código se está realizando una llamado al archivo robot.gazebo el cual contiene los colores para el robot. Vamos a observar una parte del contenido de este archivo:

<gazebo reference="base_link">
    <material>Gazebo/Orange</material>
</gazebo>

<gazebo reference="wheel_1">
    <material>Gazebo/Black</material>
</gazebo>	

A través de la etiqueta <gazebo> se indica cuál Link del robot se pintará, y posteriormente con la etiqueta <material> se indica el color. En Gazebo ya existen colores predefinidos qeu pueden ser vistos en la página http://wiki.ros.org/simulator_gazebo/Tutorials/ListOfMaterials.

Esta página contiene una lista de los materiales disponibles para Gazebo. Esta lista puede variar de lo que tenga en su instalación. Puede consultar la lista de materiales disponibles actualmente haciendo

gedit 'rospack find gazebo'/gazebo/share/gazebo/Media/materials/scripts/Gazebo.material

Controlador Básico para el Brazo

Es necesario instalar desde la terminal de comandos todos los tipos de controla- dores:

sudo apt-get install ros-noetic-position-controllers
sudo apt-get install ros-noetic-joint-state-controller
sudo apt-get install ros-noetic-effort-controllers
sudo apt-get install ros-noetic-velocity-controllers

Para que una articulación pueda ejercer algún movimiento es necesario asignar un controlador a cada articulación, posteriormente, se publica en el tópico correspondiente a la articulación que deseamos mover. Para lograr ello, se requieren 2 archivos nuevos:

robot1_gazebo_control_Position.yaml

Mover_Articulacion.py

Revisaremos el archivo robot1_gazebo_control_Position.yaml:

joint1_position_controller:
    type: effort_controllers/JointPositionController
    joint: base_to_arm_base
    pid: {p: 100.0, i: 0.01, d: 10.0}

En esta sección de código, se tiene 1 controlador para 1 articulación. El nombre del controlador es joint1_position_controller; el parámetro type indica el tipo de controlador, este controlador es de tipo effort o esfuerzo; el parámetro joint indica a qué juntura o articulación estará ligado el controlador, la articulación a la que está asignado este controlador es base_to_arm_base. El parámetro pid permite asignar ganancias al controlador.

De la misma forma se realiza para todas las junturas o joints del brazo robótico.

Ahora, revisaremos el archivo Mover_Articulacion.py:

pub = rospy.Publisher('/robot1/joint3_position_controller/
command', Float64, queue_size=10)
rospy.init_node('talker', anonymous=True)
rate = rospy.Rate(10)
position = 3.141592
pub.publish(position)

En este archivo se crea un publicador llamado pub, el cual publica en el tópico /robot1/joint3_position_controller/command un mensaje de tipo Float64. La variable position almacena la posición deseada, la cual debe estar en radianes, finalmente, con la línea de código pub.publish(position) se publica la posición deseada y la articulación correspondiente se mueve hasta el ángulo deseado.

La Figura muestra la posición alcanzada por el segundo eslabón del robot cuando la entrada de posición es $\pi/2$, donde el origen angular es sobre el eje vertical, es decir en $90^o$.

Posición alcanzada por el brazo.

Dado que las demás articulaciones ya tienen configurado un controlador de esfuerzo el robot mantiene su postura firme, antes de la implementación de los controladores, el robot se caía al suelo, porque no tenía firmeza, la cual se la otorgan los controladores de esfuerzo.

Para ejecutar la simulaciòn, abra una nueva terminal y ejecute el siguiente comando:

roslaunch robot1_description display.launch