Profesor: Alejandro Castellanos
Para el trabajo en el Laboratorio (RoboLab, Sala 2.B.03, Edificio Departamental Oeste 2) relacionadas con el robot UR3e de Universal usaremos la modalidad de Laboratorio Abierto.
-- TABLÓN DE ANUNCIOS --
Las clases de Prácticas de Laboratorio comienzan el viernes 19/09/2025.
Durante las prácticas nos será útil esta información con materiales oficiales de Universal sobre el robot UR3e: (link) documentación.
El objetivo de esta primera práctica es familiarizarnos en el uso del cobot (collaborative robot) UR3e - la imagen inferior permite navegar por la web oficial del fabricante Universal Robots (link).
Resultado final de esta práctica: saber encender el robot UR3e, y manejarlo en modo manual en sus diferentes modalidades.
Podemos seguir los siguientes pasos para aprender a trabajar con el robot UR3e:
Tareas hardware
Comandar el robot en "Modo Manual" hacia varias posiciones estáticas.
** Documentación para encender/apagar el brazo robótico: página 96/203 del Manual de Usuario (link).
** En la página 99/203 del Manual de Usuario (link) tenemos información sobre los modos de funcionamiento del robot.
** Ayuda sobre el estado de liberación de los frenos del robot: página 123/203 del Manual de Usuario (link).
* Ante cualquier duda que tengamos durante el manejo del cobot UR3e, el Manual de Usuario (link) del robot resulta de gran utilidad. Es interesante consultar dicho documento (disponible en el enlace subrayado y la ventana interactiva que se recoge en este apartado).
Tareas software
Instalación del software de simulación RoboDK: https://robodk.com/es/download. Tras finalizar la instalación, podemos activar la licencia del software utilizando las instrucciones recogidas en el documento "RoboDK license Setup - Instructions.pdf" (link).
Primeros pasos con RoboDK.
Opción 1: Vamos a desarrollar un pequeño programa para mover el efector final del robot entre dos puntos del espacio cartesiano tridimensional. Se puede emplear Python, o cualquier otro lenguaje de programación en el que tengas interés (C, C++, MatLab, etc.), así como la propia API visual que ofrece RoboDK.
** Ayuda sobre la programación offline y online (usando Python) del robot UR3e: API de Python en RoboDK (link).
Opción 2: Los tutoriales que se listan a continuación nos ayudarán a implementar nuestros primeros programas para el robot UR3e (cada tutorial posee un enlace al vídeo de ayuda):
Tutorial 2.1. (link)- Introducción al software RoboDK y exploración de la principal documentación disponible.
Tutorial 2.2. (link)- Creación de un nuevo proyecto en RoboDK.
Tutorial 2.3. (link)- Aprendizaje sobre los grados de libertad y movimientos del robot disponibles, según su espacio de configuración.
Tutorial 2.4. (link)- Programación de posiciones y orientaciones objetivo en el espacio de trabajo del robot.
Tutorial 2.5. (link)- Creación y ejecución de varios programas para el robot UR3e.
Resultado final de este bloque: haber instalado RoboDK y saber crear programas sencillos para el robot UR3e.
Esta segunda sección la centraremos en la creación y la puesta en marcha de programas para el robot UR3e, enlazando con el bloque temático anterior. Emplearemos directamente la Teach Pendant (tablet) del UR3e, utilizando una memoria USB para poder cargar los programas en el controlador del robot.
Empleo de archivos ".urp" ya generados previamente
Podemos seguir estos pasos para diseñar y ejecutar nuestros programas:
Crear nuestro fichero ".urp", a partir de un programa desarrollado en RoboDK. Inicialmente, podemos emplear este archivo ".urp" de ejemplo: (link) programa coger dejar.
Añadir el archivo ".urp" a una memoria USB y conectarla al Teach Pendant de Universal Robots.
A través del menú de Teach Pendant, acceder a la carpeta de la memoria USB y seleccionar el programa ".urp" que deseamos cargar.
Lanzar el programa seleccionado y observar el funcionamiento físico en el robot UR3e.
Enlace a documentación de ayuda: (link) Ejecutar un programa en el controlador UR.
En esta ruta tenemos otro programa ".urp" de ejemplo para ejecutarlo en el robot: (link) Movimientos básicos con UR3e.
Creación de archivos ".urp" desde un programa de RoboDK
Una vez que hemos programado en el entorno gráfico de RoboDK una secuencia de movimientos para el robot UR3e, podemos generar el programa del robot (formatos ".script" y ".urp") según la información recogida en: (link) generación de ficheros ".script" y ".urp" desde RoboDK.
Si no tienes un programa desarrollado en RoboDK, podemos usar este fichero ".rdk" de ejemplo: (link) primer_ejemplo_rdk.
Enlace para descargar el modelo gráfico del robot UR3e: (link) modelo gráfico robot UR3e.
Nota 1: Es posible que los archivos ".script" y ".urp" generados se guarden en la ruta: "... /Documentos/RoboDK/Programs/".
Nota 2: Durante la generación del fichero ".urp" es importante emplear la utilidad "Generar programa como...", con la finalidad de exportar correctamente la configuración de nuestros sistemas de coordenadas.
Es interesante visualizar este vídeo sobre la generación de programas para el controlador del robot: (link) Tutorial Export Simulations. Son importantes los pasos que se indican desde el minuto 3:38 en adelante.
Resultado final de este bloque: saber generar un fichero ".urp" desde un programa de RoboDK y transferirlo al controlador del robot UR3e vía USB.
Esta sección la dedicaremos a revisar los Bloques 1 y 2. Podemos seguir trabajando en los dos bloques anteriores si no los hemos completado. Si ya los hemos terminado, vamos a programar en RoboDK estos pequeños retos:
Ayuda sobre la configuración del tiempo de simulación.- (link) establecimiento de la velocidad de ejecución de la simulación en RoboDK.
Problema 1.- Movimientos circular y lineal a velocidad variable
Implementar mediante la API gráfica de RoboDK las instrucciones necesarias para que el robot UR3e desarrolle el siguiente funcionamiento. Durante los 10 primeros segundos del programa, el efector final del robot seguirá una trayectoria circular con el radio que prefieras; siendo la velocidad constante (libre a elegir) durante todo el movimiento. A continuación, dicho efector final realizará tres movimientos lineales con el doble de velocidad; permaneciendo en modo de espera los 5 segundos siguientes. Finalmente, el robot regresará a una posición final que puedes definir (vuelta a home).
Pista de ayuda A.- (link) programando un movimiento circular en RoboDK.
Pista de ayuda B.- (link) activación del modo sleep en el robot.
Pista de ayuda C.- (link) establecimiento de la velocidad del robot.
Pista de ayuda D.- La primera temporización de 10 s puede implementarse en RoboDK mediante un pequeño código Python. En el próximo bloque profundizaremos en la programación Python del robot. Para este caso, podemos solucionar el problema de la siguiente forma:
Sintonizar la velocidad del robot "v" de tal forma que se consuman 10 s en el transcurso de la trayectoria.
¿Cómo calculamos "v"?
* Tras lanzar el programa del movimiento circular, RoboDK nos indicará la longitud de la trayectoria (L [mm]) en la esquina inferior izquierda de la pantalla.
* Comandando el valor adecuado para la velocidad del robot (v [mm/s]), conseguiremos que transcurran 10 [s] durante la trayectoria circular del efector final del robot, de tal forma que:
v [mm/s] = L [mm] / t [s] = L [mm] / 10 [s]
Problema 2.- Secuencia de movimientos de una operación Pick and Place
Crearemos en RoboDK una nueva estación conformada por los siguientes ítems:
Una mesa de trabajo, que establecerá la referencia de cota para el robot UR3e.
El propio robot, al cual se le añadirá una pinza o ventosa necesaria para el sistema Pick and Place.
Varias piezas de dos tamaños diferentes: grande (G) y pequeño (P).
Funcionamiento a programar: el robot, empleando la pinza o la ventosa del efector final, recogerá cada una de las piezas y las colocará agrupadas en dos zonas diferentes de la mesa en función de su tamaño (G o P).
Pista de ayuda.- (link) ayuda sobre la programación de un sistema Pick & Drop, similar al Pick & Place propuesto.
Problema 3.- Dibujo de letras mediante el efector final del robot
Vamos a programar la secuencia de movimientos necesaria para que el efector final del robot UR3e describa una trayectoria correspondiente a la letra inicial de tu nombre. Si tienes tiempo también podemos programar las instrucciones que permitan al robot dibujar con su efector final los siguientes caracteres: EPI Gijón UniOvi.
Problema 4.- Trabajando son sistemas de referencia globales y locales
En este ejercicio trabajaremos con un sistema de referencia global (que será la base del robot UR3e) y varios frames locales. Tienes libertad para definir estos marcos de referencia locales. Debemos programar una secuencia de movimientos para el robot que se componga, al menos, de los siguientes ítems:
5 instrucciones de tipo "movimiento articular", empleando varios ejes de rotación del robot.
4 instrucciones de tipo "movimiento lineal", expresadas respecto al sistema de referencia global.
4 instrucciones de tipo "movimiento lineal", expresadas en relación a dos marcos de referencia locales diferentes.
2 instrucciones de tipo "movimiento circular", codificadas respecto al sistema de referencia de prefieras.
El objetivo final de este ejercicio es repasar las distintas formas de expresar la pose (posición + orientación) de cada eslabón del robot. Puedes añadir a la estación de trabajo de RoboDK todos los elementos que prefieras (herramienta en el efector final, objetos adicionales al robot, mesa, etc.). La trayectoria que ha de realizar el efector final del UR3e también puedes diseñarla libremente.
Pista de ayuda.- (link) documentación sobre la creación de sistemas de referencia en RoboDK.
*********************************************************************************************************************************
Resultado final de este bloque: saber crear "desde cero" varios programas en RoboDK (empleando su API gráfica) y transferirlos al robot UR3e, vía USB, para poder observar su funcionamiento físico.
En este bloque nos adentraremos en la programación Python del robot UR3e. En primer lugar, trabajaremos con la filosofía offline de programación; en la cual no es necesario efectuar una conexión TCP/IP con el robot físico. Desarrollaremos nuestros scripts de Python y probaremos su funcionamiento en RoboDK. También podemos transferir nuestros programas al controlador del robot UR3e a través del puerto USB para poder testear el movimiento físico del brazo robótico.
Descarga e instalación del entorno de desarrollo VS Code (Visual Studio Code)
Para la implementación de código fuente emplearemos el entorno de desarrollo Visual Studio Code, disponible para su descarga a través del siguiente enlace: (link) página web oficial para la descarga de VS Code.
También puedes utilizar otros editores de código Python diferentes si lo prefieres, por ejemplo: (link) Spyder, (link) Pycharm, etc.
Creación de un entorno virtual en Python (opcional)
Al ejecutar los scripts de Python que programemos, vamos a necesitar tener instalada la librería robodk. También podemos instalar cualquier otra dependencia que necesites para desarrollar tu software. Para ello, podemos crear un entorno virtual de Python siguiendo estos sencillos pasos:
Mediante el explorador de archivos (de Windows), accedemos a la carpeta en la que quieres desarrollar tu fichero ".py" durante la práctica.
Hacemos clic derecho en la carpeta y seleccionamos la opción "Abrir en Terminal".
Dentro de la Terminal, ejecutamos secuencialmente los siguientes comandos:
Creación del entorno virtual de Python: python -m venv .venv
Activación del entorno virtual: .venv\Scripts\activate.bat
Instalación de la librería robodk: pip install robodk
Introducción a la programación Python con RoboDK y VS Code
En este sitio web tenemos información genérica muy interesante sobre la programación offline de robots: (link) ayuda general sobre la programación offline en RoboDK mediante lenguaje Python. Nos puede ser útil revisar el siguiente código de ejemplo:
# Dibuja un hexágono alrededor del objetivo 1
from robolink import * # RoboDK API
from robodk import * # Herramientas matemáticas para robots
# Inicie la API de RoboDK:
RDK = Robolink()
# Recuperar el robot
robot = RDK.Item('', ITEM_TYPE_ROBOT)
# Obtener la referencia de destino:
target = RDK.Item('Target 1')
target_pose = target.Pose()
xyz_ref = target_pose.Pos()
# Mueve el robot hacia el objetivo de referencia:
robot.MoveJ(target)
# Dibuja un hexágono alrededor del objetivo de referencia:
for i in range(7):
ang = i*2*pi/6 # Ángulo = 0,60,120,...,360
R = 200 # Radio
# Calcula la nueva posición:
x = xyz_ref[0] + R*cos(ang) # nueva coordenada X
y = xyz_ref[1] + R*sin(ang) # nueva coordenada Y
z = xyz_ref[2] # nueva coordenada Z
target_pose.setPos([x,y,z])
# Desplázate al nuevo objetivo:
robot.MoveL(target_pose)
# Activar una llamada de programa al final del movimiento
robot.RunInstruction('Program_Done')
# Vuelve al objetivo de referencia:
robot.MoveL(target)
Si inicialmente te resulta complicado implementar "desde cero" un script en Python o te han quedado dudas con el programa anterior, puedes descargar este primer ejemplo mediante el siguiente enlace y tomarlo como referencia para ir modificando su código fuente: (link) descarga de plantilla para la programación offline del robot UR3e en Python.
Pequeños retos propuestos
Problema 1.- Dibujando señales senoidales
Vamos a programar en Python el robot UR3e para que su efector final (último eslabón del brazo robótico) describa una trayectoria sinusoidal. Si inicialmente te resulta complicado diseñar el algoritmo, podemos ayudarnos del siguiente pseudocódigo:
(1) Realizar conexión con RoboDK.
(2) Obtener la posición inicial del TCP.
(3) Definir el marco de referencia y la herramienta actual.
(4) Establecer parámetros de movimiento (fundamentalmente, la velocidad lineal en [mm/s]).
(5) Definir parámetros de la onda senoidal: amplitud [mm], longitud de onda [mm], número de ondas a dibujar y puntos que conforman la trayectoria de cada onda.
(6) Generar todos los puntos de la trayectoria senoidal (puedes usar el método linspace de numpy, np.linspace). --> x_total
(7) Obtener los puntos imagen de la función senoidal mediante la instrucción:
y_seno = amplitud * np.sin((2 * np.pi / longitud_onda) * x_total) # Implementación de una onda senoidal
(8) Mover el robot al inicio de la onda. Puedes usar este fragmento de código:
primer_punto = pose_inicial * transl(x_total[0], y_seno[0], 0)
robot.MoveJ(primer_punto)
(9) Dibujar la senoide punto a punto:
for i in range(len(x_total)):
punto_actual = pose_inicial * transl(x_total[i], y_seno[i], 0)
robot.MoveL(punto_actual)
(10) El robot vuelve a la pose inicial:
robot.MoveJ(pose_inicial)
Problema 2.- Introduciendo cambios de velocidad en el movimiento
Partiendo del código desarrollado en el Problema 1, vamos a añadir las instrucciones necesarias para que la velocidad del robot se incremente a lo largo de cada punto de la trayectoria senoidal; de tal forma que:
v_k = alpha * v_(k-1)
Si, por ejemplo, alpha es igual a 1.2, significa que la velocidad del robot en el punto k-ésimo de la trayectoria será un 20 % superior a la velocidad desarrollada en el punto anterior (elemento k-1 del conjunto de datos x_total).
Pista de ayuda.- Recuerda que podemos establecer la velocidad del robot mediante la siguiente instrucción: robot.setSpeed(velocidad_mm_s).
Notas importantes sobre la conexión TCP/IP con el robot UR3e
Una vez que hemos desarrollado nuestro algoritmo en código Python, arrastraremos el script a la estación de RoboDK y nos conectaremos al robot UR3e de forma online. Para ello, hacemos click derecho en el modelo gráfico del robot UR3e y pulsamos sobre la opción "Conectar a robot...". En la ventana emergente, veremos un cuadro de diálogo para escribir la dirección IP del robot. Habitualmente, dicha dirección IP será de la forma "156.35.152.XXXX". Finalmente, hacemos click en la opción "Conectar" para establecer la conexión entre el robot y nuestro ordenador.
En este enlace tenemos información gráfica sobre la conexión TCP/IP con el robot de Universal Robots a través de RoboDK: (link) conectando nuestro PC al robot UR3e vía RoboDK.
*****************************************************************************************************
Resultados finales de este bloque:
(1) Haber aprendido a desarrollar scripts de Python que comanden movimientos hacia el robot UR3e, el cual tenemos simulado en RoboDK.
(2) Saber conectar RoboDK, instalado en nuestro ordenador, con el controlador del robot UR3e (vía TCP/IP).