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