UNIVERSIDAD DE LAS
FUERZAS ARMADAS - ESPE
DEPARTAMENTO DE CIENCIA DE LA ENERGÍA Y MECÁNICA
Robótica Industrial
“Explicación de comandos para el uso del Robotic Toolbox”
Carolina Arcentales Cristian Changoluisa
David Del Castillo Lenin Gonzalez
Juan Pablo Granda Dayana Santacruz
28/07/2015
1
DEFINIR ROBOT ANTROPOMORFICO EN MATLAB
Definimos variables de cada eslabón y articulación el robot con Denavit
Hatemberg con la tabla que se muestra en la figura 2.
Figura 1. Robot Antropomórfico a usar
Tabla 1. Valores de constantes aplicando Denavit Hatemberg.
Con la función link añadimos valores que se muestran en la Tabla 1 para
posterior procesamiento de datos en Matlab como se muestra a continuación:
L1 = Link('revolute', 'd', 0.171, 'a', 0.055, 'alpha', pi/2);
L2 = Link('revolute', 'd', 0, 'a', 0.150, 'alpha', 0);
L3 = Link('revolute', 'd', 0, 'a', 0.188, 'alpha', 0);
El siguiente paso es generar el robot al unir cada uno de los links formados, lo
que dará como resultado un brazo robótico de 3 GL esto se lo hará con la
función SerialLink:
antro=SerialLink([L1 L2 L3],'name','antro1');
Procedemos a graficar el robot en un espacio tridimensional con la sub-función
de la clase SerialLink llamada plot pero para ello necesitamos un vector ‘qz’
que representa la variable de cada articulación en este caso son 3 ángulos.
qz=[0 pi/2 -pi/2];
antro.plot(qz);
2
Podemos visualizar las propiedades mecánicas como cinemáticas ingresando
el nombre del robot en la línea de comandos.
>>antro
antro =
antro1 (3 axis, RRR, stdDH, fastRNE)
+---+-----------+-----------+-----------+-----------+-----------+
| j | theta | d | a | alpha | offset |
+---+-----------+-----------+-----------+-----------+-----------+
| 1| q1| 0.171| 0.055| 1.571| 0|
| 2| q2| 0| 0.15| 0| 0|
| 3| q3| 0| 0.188| 0| 0|
+---+-----------+-----------+-----------+-----------+-----------+
grav = 0 base = 1 0 0 0 tool = 1 0 0 0
0 0 1 0 0 0 1 0 0
9.81 0 0 1 0 0 0 1 0
0 0 0 1 0 0 0 1
Aplicamos los siguientes comandos con su utilidad:
antro.teach(); Podemos manejar el robot usando la unidad de programación
virtual.
a=antro.getpos();Obtenemos la posición en la que se encuentra el robot virtual.
Comandos (Funciones y Clases) Usados como sub-funciones de la clase
robot:
Clases:
Link()
SerialLink()
Funciones:
Plot()
Getpos()
Propiedades:
links vector de los links usados.
gravity dirección de la gravedad [gx gy gz].
base pose of robot’s base (4 x 4 homog).
3
name Devuelve el nombre del robot usado para la representación
gráfica.
manuf anotación, el nombre del fabricante.
comment anotación, comentario general.
plotopt opciones para plot () método (conjunto de células).
CINEMÁTICA DIRECTA
Inicialmente se define un objeto “robot”, que para el caso de este informe se
utilizó las dimensiones del robot presentado como proyecto en los parciales
anteriores.
Figura 2. Dimensiones robot antropomórfico.
Una vez definidas las dimensiones del robot, se realiza el estudio de cinemática
directa:
rtbdemo:
Figura 3. Herramienta robotTool
L1=Link('revolute', 'd', 171, 'a', 55, 'alpha', pi/2);
L2=Link('revolute', 'd', 0, 'a', 150, 'alpha', 0);
L3=Link('revolute', 'd', 0, 'a', 188, 'alpha', 0);
4
antro=SerialLink([L1 L2 L3],'name','antro')
qz=[0 pi/2 -pi/2];
antro.fkine(qz)
Esta función devuelve la transformada homogénea correspondiente al último
punto en el que estuvo el robot.
Posteriormente se define un punto al que se va a desplazar el robot
qz: punto inicial del movimiento.
qr: punto final del movimiento .
t: vector tiempo de desplazamiento
q=jtraj(qz,qr,t) % se mueve de qz a qr en un tiempo t
T=antro.fkine(q)
5
T es una matriz tridimensional, representa el tiempo, y los desplazamientos
realizados en cada lapso de tiempo.
subplot(3,1,1);
plot(t,squeeze(T(1,4,:)))
xlabel('Tiempo(s)');
ylabel('X(m)');
subplot(3,1,2);
plot(t,squeeze(T(2,4,:)))
xlabel('Tiempo(s)');
ylabel('Y(m)');
subplot(3,1,3);
plot(t,squeeze(T(3,4,:)))
xlabel('Tiempo(s)');
ylabel('Z(m)');
La función squeeze regresa los valores de posición respecto de tiempo de cada
movimiento.
6
Figura 4. Graficas de desplazamiento en función del tiempo para cada eje coordenado.
Por ultimo graficamos la velocidad para cada eje en el plano xz.
Figura 5. Graficas de desplazamiento en el plano xz.
Por último, se realiza una simulación en tiempo real con la sentencia teach,
permite simular en una ventana la variación de los distintos grados de libertad.
7
Figura 6. Herramienta de simulación para cada grado de libertad.
Comandos utilizados:
rtbdemo Muestra una serie de ejemplos para diferentes tipos de
estudios y análisis matemáticos.
Link Permite ingresar los parámetros de la matriz de DH en un
vector para declararlo como robot.
SerialLink Convierte a objetos declarados como “Link” en un robot con
la configuración especificada dependiendo los grados de
libertad.
Kinematics Proporciona un ejemplo de cómo utilizar la herramienta de
robotics toolbox para los cálculos de cinemática.
Fkine Retorna la transformada homogénea correspondiente al
último valor de posición del robot.
Jtarj Calcula las coordenadas para la generación de trayectoria.
Antro.fkine(q) Matriz tridimensional de velocidades para cada articulación.
‘revoluto’ Define un objeto List como parte de una cadena cinemática
de un robot antropomórfico.
Squeeze Extrae las componentes seleccionadas de la matriz T,
correspondientes al arreglo tridimensional del movimiento.
antro.teach() Devuelve una nueva ventana en la cual esta dibujado el
robot “Antro” y nos da la opción de variar en tiempo real
cada grado de libertad.
8
Cinemática Inversa
La cinemática inversa es el problema de encontrar las coordenadas de ejes del
robot, dado una matriz de transformación homogénea. Es muy útil cuando la
trayectoria está prevista en el espacio cartesiano, por ejemplo un camino en
línea recta.
Después de haber definido el robot, se inicia nuevamente las opciones de la
librería con el comando
>> rtbdemo
Aparece la ventana de la figura 2 con las herramientas de la librería,
seleccionamos Arm: Inverse kinematics.
Por medio de la herramienta se genera el proceso de Cinemática Inversa para
el robot puma pero se puede realizar con el comando ikine los siguientes
comandos para el robot antropomórfico definido anteriormente.
En primer lugar generar la transformada correspondiente a una articulación en
particular.
>> q=[pi/4 pi/4 -pi/4]
q =
0.7854 0.7854 -0.7854
>> T = fkine(antro, q)
T =
0.7071 0 0.7071 246.8269
0.7071 0.0000 -0.7071 246.8269
0 1.0000 0.0000 277.0660
0 0 0 1.0000
9
y luego encontrar los ángulos de las articulaciones correspondientes utilizando
ikine ()
>> qi = ikine(antro, T,qo,[0 0 0 0 0 0])
qi =
27.7168 38.7168 49.7168
DINAMICA
DIRECTA
En este caso se declara al robot con parámetros cinemáticos y dinámicos para
el análisis en RTB de Matlab, de la siguiente forma.
>> L1 = Link('revolute', 'd', 0.171, 'a', 0.055, 'alpha', pi/2, 'm',0.9, 'r',
[0.025;0.013;0.03], 'I',[ 0.025 0 0;0 0.013 0;0 0 0.03]);
>> L2 = Link('revolute', 'd', 0, 'a', 0.150, 'alpha', 0, 'm',0.7, 'r', [0.075;0.04;0.04],
'I',[ 0.075 0 0;0 0.04 0;0 0 0.04]);
>> L3 = Link('revolute', 'd', 0, 'a', 0.188, 'alpha', 0, 'm',0.4, 'r', [0.095;0.07;0.08],
'I',[ 0.095 0 0;0 0.07 0;0 0 0.08]);
Donde:
m= Masa del eslabón.
r= Centro de gravedad de dimensión 3x1.
I= Matriz de Inercia 3x3.
Creamos la cadena cinemática
antro=SerialLink([L1 L2 L3],'name','antro1')
Comando accel
Este comando nos ayuda a encontrar la Aceleración de cada eslabón sometido
a un determinado torque o fuerza.
Declaramos un qz que corresponde a la posición de análisis.
>> qz=[0 pi/2 -pi/2];
y a continuación ejecutamos el comando correspondiente.
>> antro.accel(qz, zeros(1,3), zeros(1,3))
Posición de análisis
Velocidad inicial
Torque Inicial
10
Obteniendo:
Figura 1. Resultado Comando accel.
Comando nofriction y fdyn
El comando nofriction como su nombre lo indica establece como cero las
fricciones en las juntas, esto permite el análisis en estado ideal.
Por otro lado el comando fdyn integra y predice una serie de estados dinámicos
basados en todos los parámetros cinemáticos y dinámicos impuestos.
>> [t q qd] = antro.nofriction().fdyn(10, [], qz);
Donde:
t= Vector tiempo.
q= Posición de la junta.
qd= Velocidad de la junta.
El ejemplo generado corresponde al comportamiento del robot cuando se lo
suelta libremente en condiciones ideales de la posición qz.
Generados estos vectores se los podrá graficar con respecto al tiempo, de la
siguiente manera.
>> subplot(3,1,1)
plot(t,q(:,1))
xlabel('Time (s)');
ylabel('Joint 1 (rad)')
subplot(3,1,2)
plot(t,q(:,2))
xlabel('Time (s)');
ylabel('Joint 2 (rad)')
subplot(3,1,3)
plot(t,q(:,3))
Tiempo de análisis
Función Torque
Posición Inicial
11
xlabel('Time (s)');
>>ylabel('Joint 3 (rad)')
Se obtiene la siguiete grafica.
Figura 7. Posición de los eslabones vs el tiempo.
INVERSA
Al contrario del tema anterior, lo que se busca es analizar los torques inmersos,
en el movimiento del robot.
Comando rne
Este comando nos genera la dinámica inversa, ósea el torque necesario para
realizar el estado deseado teniendo como datos la velocidad y aceleración de
cada eslabón, teniendo:
>> tau = antro.rne(qz, 5*ones(1,3), ones(1,3))
Figura 8. Resultado comando rne
A continuación generaremos la dinámica inversa dentro de una trayectoria. Lo
primero que deberemos hacer es un vector tiempo de análisis.
>> t = [0:.056:2];
Consiguientemente la posición final del robot.
>> qr=[0 0 0];
Posición de análisis
Vector Velocidad
Vector Aceleración
12
Finalmente con la ayuda del comando jtraj visto anteriormente, generamos la
trayectoria entre el punto inicial qz y el final qr.
>> [q,qd,qdd] = jtraj(qz, qr, t)
Graficamos el resultado dinámico durante la trayectoria de la siguiente manera
haciendo el nuevamente del comando rne.
>> tau = antro.rne(q, qd, qdd);
>> plot(t, tau(:,1:3)); xlabel('Time (s)'); ylabel('Joint torque (Nm)')
Figura 9.Grafica Torque de cada eslabón sin efecto de la gravedad
La grafica no es analizada aplicada la gravedad ya que en el primer eslabón
esta es despreciable.
Para los dos eslabones siguientes realizaremos una comparación entre el
estado ideal y el otro donde la gravedad afecta al sistema.
>> taug = antro.gravload(q);
>> subplot(2,1,1); plot(t,[tau(:,2) taug(:,2)]); xlabel('Time (s)'); ylabel('Torque on joint 2
(Nm)');
>> subplot(2,1,2); plot(t,[tau(:,3) taug(:,3)]); xlabel('Time (s)'); ylabel('Torque on joint 3
(Nm)');
13
Figura 10. Grafica de los eslabones 2 y 3 comparados con el efecto gravedad
Comandos Utilizados
Link Genera eslabones
SerialLink Genera cadena cinemática
antro.accel Análisis de aceleración
antro.nofriction() Fricción nula en juntas
antro.fdyn Proyección de la Dinámica del sistema
antro.rne Dinámica Inversa
antro.gravload Agregado de la gravedad
Generación de trayectorias
Se va a partir del robot ya definido en el primer paso, cuyo punto inicial para el
TCP es:
Figura 11. Punto de inicio del TCP en X, Y, Z.
Definiremos este punto como 𝑃0 y el punto al que queremos que llegue el TCP
será 𝑃1 = 0.5, 1.78, −1.9, por lo que tendremos puntos de inicio y de fin en los 3
ejes a trabajar.
14
Figura 12. Punto de inicio y final del TCP en X, Y, Z.
Para esto se usará el comando tpoly, que genera una trayectoria polinomial
escalar, es decir tendremos las posiciones, velocidad y aceleraciones del TCP
en cada eje, por lo que será diferente la velocidad de desplazamiento en el eje
𝑋, en el 𝑌 y en el 𝑍
𝑃0𝑥 = 0 𝑃1𝑥 = 0.5
𝑃0𝑦 = 1.5708 𝑃1𝑥 = 1.78
𝑃0𝑧 = −1.5708 𝑃1𝑧 = −1.9
Figura 13. Polinomios escalares de posición.
Por lo que ahora se pueden obtener las gráficas de posición del TCP en cada
eje.
Figura 14. Posiciones del TCP en cada eje.
15
Ahora definiremos los polinomios necesarios para poder generar las
velocidades y aceleraciones del TCP en cada uno de los ejes
Figura 15. Polinomios escalares de posición, aceleración y velocidad.
Y de igual manera se generan los gráficos de velocidades y aceleraciones por
cada eje
Figura 16. Velocidad del TCP en cada eje.
Figura 17. Aceleración del TCP en cada eje.
16
En este punto es necesario generar segmentos lineales con una combinación
parabólica, esto es debido a que como podemos ver en la velocidad, esta no es
constante, sino que llega a un máximo pico y luego disminuye, esto se elimina
usando el comando lspb.
Figura 18. Polinomios escalares de posición, aceleración y velocidad combinados con
líneas parabólicas.
Ahora las gráficas nos quedarán así
Figura 19. Posiciones del TCP en cada eje.
Figura 20. Velocidad casi constante del TCP en cada eje.
17
Figura 21. Aceleración casi constante del TCP en cada eje.
De esta manera se logra tener velocidades mas constantes y por ende más
reales en comparación al robot con el que se está trabajando.
Ahora para obtener la trayectoria en múltiples ejes entre dos puntos se usará el
comando mtraj, con este comando se puede visualizar la posición, velocidad, y
aceleración del TCP en todos los ejes en el mismo gráfico como se muestra a
continuación.
Figura 22. Obtención de todos los parámetros.
Figura 23. Posición del TCP en todos los ejes.
18
Figura 24. Velocidad del TCP en todos los ejes.
Figura 25. Aceleración del TCP en todos los ejes.
Ahora es necesario interpolar las posiciones para obtener un movimiento
completo del TCP, con las mismas posiciones de inicio y fin que usamos al
principio, para esto se usará el comando trans.
Figura 26. Interpolación del movimiento del TCP en cada eje.
Para poder graficar esta interpolación se usa el comando ctranj que define una trayectoria cartesiana entre dos puntos y se la grafica.
Figura 27. Obtención de la trayectoria cartesiana como matrices de movimiento.
19
Figura 28. Animación del movimiento del TCP en 3D.
Comandos utilizados tpoly Genera una trayectoria escalar a partir de dos puntos en el
mismo eje.
lspb Genera una trayectoria cartesiana a través de una mezcla
entre líneas y curvas.
mtraj Genera trayectorias para múltiples ejes entre dos puntos.
transl Genera una matriz interpolada.
ctraj Genera una trayectoria cartesiana entre dos puntos de
manera tridimensional
tranimate Dibuja la simulación en 3D del movimiento generado.
REPRESENTACIÓN GRÁFICA Y MOVIMIENTO EN 3D
DE UN ROBOT
Una vez definida la cinemática del robot y las posiciones “Home” y “ready to
work”, procedemos a definir el tiempo de ejecución de los movimientos y la su
trayectoria.
t = [0:.05:2]'; % Genera un vector de tiempo q = jtraj(qz, qr, t); % Genera una trayectoria de
coordenadas
Donde qz : es un vector que contiene los ángulos de cada articulación para la posición inicial o “Home”.
20
qr : es un vector que contiene los ángulos de cada articulación para la posición “ready to work” jtraj(): es una trayectoria espacial donde las coordenadas varían desde qz hasta qr.
La duración del movimiento está definida por los elementos del vector de tiempo t.
Una vez declarada la secuencia de trayectoria del robot procedemos a graficar el brazo en un espacio tridimensional en el cual se simula y aprecia el movimiento de las articulaciones. antro.plot(q); % Grafico en espacio tridimensional
Plot es un Método de la Clase Serial-Link. Siendo su estructura general
“nombre del brazo.plot(vector de angulos o función de trayectoria)”
Cabe mencionar que si se utiliza el vector de ángulos para la graficar el brazo, por ejemplo qr, el grafico simplemente permanecerá estático en la posición dada por qr, sin embargo si se utiliza la función de trayectoria, por ejemplo q, se podrá apreciar el movimiento del brazo desde la posición qz hasta la posición qr.
Figura 29. Representación grafica de un robot antropomórfico en la coordenadas dadas
por los vectores qz y qr respectivamente.
Otra función (propia de matlab) que se puede utilizar para la representación
gráfica en 3D es view(az,el)este nos permite ver el grafico desde
diferentes perspectivas, en otras palabras cambia el Angulo de visión del grafico tridimensional. Donde
az: “azimuth” es la rotación horizontal alrededor del eje Z medida en grados desde el eje Y negativo. Los valores positivos indican rotación del punto de vista en contra de las manecillas del reloj. el: es la elevación vertical en grados del punto de vista.
21
Para poder ver este cambio de perspectiva se debe enviar a graficar nuevamente con el Método de la Clase Serial-Link plot.
view(150,40); antro.plot(q);
view(150,40); antro.plot(q);
Figura 30. Representación gráfica de un robot antropomórfico desde diferentes ángulos
de visión
Otro Método de la clase Serial-Link es el Teach(), nos sirve para manipular las articulaciones del robot por medio de sliders y al mismo tiempo nos muestras las coordenas en x, y , z del TCP
antro.teach();
Siendo su estructura general “nombre del brazo.teach()”
22
Figura 31. Representación gráfica de un robot antropomórfico
con la función Teach activada.
Comandos usados
Funciones:
Jtraj(qz,qr,t) Genera una trayectoria
View(az,el) Cambia el ángulo de visión del grafico tridimensional
Metodos:
Name.plot() Muestra una gráfica tridimensional
Name.teach() muestra sliders para la manipulación del robot