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
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, 0.0 55, 'alpha', pi/2); L2 = Link('revolute', 'd', 0, 'a', 0.150, 0 .150, 'alpha', 0); L3 = Link('revolute', 'd', 0, 'a', 0.188, 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 llamada plot pero para ello necesitamos un vector ‘qz’ que representa la variable de cada articulación ar ticulación en este caso son 3 ángulos. qz=[0 pi/2 -pi/2];
antro.plot(qz); 1
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|
| 2|
q2|
0|
0.15|
| 3|
q3|
0|
0.188|
1.571| 0| 0|
0| 0| 0|
+---+-----------+-----------+-----------+-----------+-----------+ grav =
0 base = 1 0 0 0 tool = 1 0 0 0
0
0 1 0 0
9.81
0 0 1 0 0 0 0 1
0 1 0 0 0 0 1 0 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 gravity base
vector de los links usados. dirección de la gravedad [gx gy gz]. pose of robot’s base (4 x 4 homog).
2
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); 3
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)
4
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.
5
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.
6
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.
7
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 A r m : In v e r s e k i n e m a t i c s . Por medio de la herramienta se genera el proceso de Cinemática Inversa para el robot puma pero se puede realizar con el comando i k i n e 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 1.0000
0
8
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. Posición de análisis Velocidad inicial Torque Inicial
>> antro.accel(qz, zeros(1,3), zeros(1,3))
9
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. Tiempo de análisis Función Torque Posición Inicial
>> [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)) 10
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: Posición de análisis
Vector Velocidad Vector Aceleración
>> 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]; 11
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)');
12
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 y el punto al que queremos que llegue el TCP será = 0.5,1.78, −1.9, por lo que tendremos puntos de inicio y de fin en los 3 ejes a trabajar.
13
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 = 1.5708 = −1.5708
= 0.5 = 1.78 = −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. 14
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.
15
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. 16
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.
17
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.
18
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 q z : es un vector que contiene los ángulos de cada articulación para la
posición inicial o
“Home”.
19
q r : es un vector que contiene los ángulos de cada articulación para la
posición “ready to work” j tr aj (): es una trayectoria espacial donde las coordenadas varían desde q z hasta q r . La duración del movimiento está definida por los elementos del vector de tiempo t . Una vez declarada la secuencia de trayectoria del robot pr ocedemos 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 P l o t 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 q r , el grafico simplemente permanecerá estático en la posición dada por q r , sin embargo si se utiliza la función de trayectoria, por ejemplo q , se podrá apreciar el movimiento del brazo desde la posición q z hasta la posición q r .
Figura 29. Representación grafica de un robot antropomórfico en la coordenadas dadas por los vectores q z y q r 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. 20
Para poder ver este cambio de perspectiva se debe enviar a graficar nuevamente con el Método de la Clase Serial-Link p l o t . 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()”
21
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
22
