PRACTICA 1 ROBÓTICA INDUSTRIAL

Jhonny Ducuara, Julian Robles, Felipe Ramirez

1. Una vez instalado el Toolbox, realice y documente las demostraciones

Rotations y Transformations.

ROTACIÓN

En el campo de la robótica existen muchas formas posibles de representar

orientaciones de las cuales las más comunes son:
- matrices de rotación ortonormal (3x3),
- tres ángulos (1x3), y
- cuaterniones.

Una rotación de pi/2 alrededor del eje x se puede representar como una rotación
ortonormal.
matriz

R = rotx(ang ) crea una matriz de 3 por 3 para rotar un vector de 3 por 1 o una
matriz de vectores de 3 por N alrededor del eje x en ang grados. Cuando se
actúa sobre una matriz, cada columna de la matriz representa un vector
diferente. Para la matriz de rotación R y el vector v, el vector rotado viene dado
por R*v.

>> R = rotx(pi/2)

R=

1 0 0
0 0 -1
0 1 0

Lo que podemos ver es una matriz de 3x3.

Tal matriz tiene la propiedad de que sus columnas (y filas) son conjuntos de
vectores unitarios. El determinante de dicha matriz es siempre 1.

d = det(A) devuelve el determinante de la matriz cuadrada A.

>> det(R)
ans =

Creemos una rotación más compleja.

>> R = rotx(30, 'deg') * roty(50, 'deg') * rotz(10, 'deg')

R=

0.6330 -0.1116 0.7660

0.5276 0.7864 -0.3214
-0.5665 0.6076 0.5567

donde esta vez hemos especificado el ángulo de rotación en grados.

Cualquier rotación se puede expresar en términos de una sola rotación alrededor de

algún eje en el espacio

tr2angvec
Convertir matriz de rotación a forma de vector de ángulo

[THETA,V] = TR2ANGVEC(R, OPTIONS)es la rotación expresada en términos de

un ángulo THETA(1×1) alrededor del eje V(1×3) equivalente a la matriz de
rotación ortonormal R(3×3).

[THETA,V] = TR2ANGVEC(T, OPTIONS)como arriba pero usa la parte rotacional

de la transformación homogénea T(4×4).

Si R(3×3× K) o T(4×4× K) representan una secuencia, entonces THETA(K×1) es

un vector de ángulos para los elementos correspondientes de la secuencia y
V(K×3) son los ejes correspondientes, uno por fila. .

>> [theta,vec] = tr2angvec(R)

theta =

1.0610
vec =

0.5322 0.7634 0.3662

Donde theta es el ángulo (en radianes) y vec es el vector unitario que representa el
dirección del eje de rotación.

Comúnmente las rotaciones se representan mediante ángulos de Euler.

tr2eul
Convertir transformada homogénea a ángulos de Euler

eul = tr2eul ( T , opciones ) son los ángulos ZYZ de Euler (1x3)

correspondientes a la parte rotacional de una transformada homogénea T
(4x4). Los 3 ángulos eul =[PHI,THETA,PSI] corresponden a rotaciones
secuenciales alrededor de los ejes Z, Y y Z respectivamente.

eul = tr2eul ( R , opciones ) como arriba pero la entrada es una matriz de

rotación ortonormal R (3x3).

Si R (3x3xK) o T (4x4xK) representan una secuencia, entonces cada fila de eul

corresponde a un paso de la secuencia.

>> eul = tr2eul(R)

eul =

-0.3972 0.9804 0.8204

by roll-pitch-yaw
que son tres ángulos tales que R = rotz(a)*roty(b)*rotz(c), es decir. las rotaciones
requerido sobre el eje Z, luego el Y, luego el eje Z.
Las rotaciones también se representan comúnmente mediante ángulos de balanceo,
cabeceo y guiñada.

>> rpy = tr2rpy(R)

rpy =
 0.8291 0.6023 0.6948

Que son tres ángulos tales que R = rotx(r)*roty(p)*rotz(y), es decir. las rotaciones
requerido sobre el eje X, luego el Y, luego el eje Z.

Podemos investigar los efectos de las rotaciones sobre diferentes ejes.

usando esta demostración basada en GUI. Los botones del menú permiten la
rotación ejes a variar

>> tripleángulo('rpy', 'esperar')

Un cuaternión es un número hipercomplejo de cuatro partes que se utiliza en

rotaciones y orientaciones tridimensionales.

Un número de cuaternión se representa en la forma a + b i + c j + d k, donde a ,

b , c y d son números reales, e i, j y k son los elementos base, que satisfacen
la ecuación: i 2 = j 2 = k 2 = ijk = −1 .
El conjunto de cuaterniones, denotado por H , se define dentro de un espacio
vectorial de cuatro dimensiones sobre los números reales, R 4 . Cada elemento
de H tiene una representación única basada en una combinación lineal de los
elementos base, i, j y k.

Todas las rotaciones en 3-D pueden describirse mediante un eje de rotación y

un ángulo alrededor de ese eje. Una ventaja de los cuaterniones sobre las
matrices de rotación es que el eje y el ángulo de rotación son fáciles de
interpretar. Por ejemplo, considere un punto en R 3 . Para rotar el punto, se
define un eje de rotación y un ángulo de rotación.

q = Quaternion(R)

>> R = rotx(30, 'deg') * roty(50, 'deg') * rotz(10, 'deg')

R=

0.6330 -0.1116 0.7660

0.5276 0.7864 -0.3214
-0.5665 0.6076 0.5567

Q = quaternion(R)calcula el cuaternión unitario de la rotación deseada Ry

devuelve un vector unitario de 4 por 1,

>> q=UnitQuaternion(R)

q=

0.86256 < 0.26926, 0.38622, 0.18526 >

>>

[Link] HOMOGÉNEAS
Las 3 filas columnas representan la rotación de la matriz, y la última columna
representa la traslación.

En el campo de la robótica existen muchas formas posibles de representar

posiciones y orientaciones, pero la transformación homogénea está bien
Combinado con las potentes herramientas de MATLAB para la manipulación de
matrices.
Las transformaciones homogéneas describen las relaciones entre cartesianas.
marcos de coordenadas en términos de traslación y orientación.

Una traslación pura de 0,5 m en la dirección X está representada por

Crear una matriz de transformación traslacional

T = transl ( x , y , z ) es una transformada homogénea SE(3) (4x4) que

representa una traducción pura de x , y y z .

T = transl ( p ) es una transformada homogénea SE(3) (4x4) que representa una

traducción de p =[ x , y , z ]. Si p (Mx3) representa una secuencia y T (4x4xM) es
una secuencia de transformadas homogéneas tales que T (:,:,i) corresponde a
la i-ésima fila de p .

>> transl(0.5, 0.0, 0.0)

ans =

1.0000 0 0 0.5000
0 1.0000 0 0
0 0 1.0000 0
0 0 0 1.0000

una rotación de 90 grados alrededor del eje Y mediante

Troty
Rotación sobre el eje Y

T = troty ( theta ) es una transformación homogénea (4x4) que representa una

rotación de theta radianes alrededor del eje y.
T = troty ( theta , 'deg') como arriba pero theta está en grados.

>> troty(pi/2)

ans =

0 0 1 0
0 1 0 0
-1 0 0 0
0 0 0 1

y una rotación de -90 grados alrededor del eje Z por

>> trotz(-pi/2)

ans =

0 1 0 0
-1 0 0 0
0 0 1 0
0 0 0 1

estos pueden ser concatenados por multiplicación

>> t = transl(0.5, 0.0, 0.0) * troty(pi/2) * trotz(-pi/2)

t=

0 0 1.0000 0.5000
-1.0000 0 0 0
0 -1.0000 0 0
0 0 0 1.0000

Si esta transformación representara el origen de un nuevo sistema de coordenadas

con respecto al origen del marco mundial (0, 0, 0), ese nuevo origen estaría dado
por
>> t * [0 0 0 1]'

ans =

0.5000
0
0
1.0000

La orientación del nuevo marco de coordenadas puede expresarse en términos de

ángulos de euler

>> tr2eul(t)

ans =

0 1.5708 -1.5708

or roll/pitch/yaw angles

>> tr2rpy(t)

ans =

-1.5708 0 -1.5708

Es importante tener en cuenta que la multiplicación transformada en general no es

conmutativo como se muestra en el siguiente ejemplo

>> trotx(pi/2) * trotz(-pi/8)

ans =

0.9239 0.3827 0 0
0 0 -1.0000 0
-0.3827 0.9239 0 0
 0 0 0 1.0000

>> trotz(-pi/8) * trotx(pi/2)

ans =

0.9239 0 -0.3827 0
-0.3827 0 -0.9239 0
0 1.0000 0 0
0 0 0 1.0000

2. Cree un punto de referencia con valores punto = [3, 2, 4]

p = [3; 2; 4]
plot3(p(1), p(2),p(3),'ok', 'MarkerFaceColor', 'b')
grid on
hold on

3. Grafique dicho punto en el eje recién creado con la función plot3(punto(1),

punto(2),punto(3),’ok’)
4. Cree una matriz de rotación de manera manual (una matriz 3x3) de una
rotación de 45 grados en el eje z

R = [cosd(45) -sind(45) 0; sind(45) cosd(45) 0; 0 0 1]

5. Use dicha matriz de rotación para girar el punto descrito a su nueva posición

p2=R*p
plot3(p2(1), p2(2),p2(3),'ok', 'MarkerFaceColor', 'k')
grid on
6. Grafique este nuevo punto de la siguiente manera plot3(punto(1),
punto(2),punto(3),’ok’, ‘MarkerFaceColor’, ‘k’)

7. Gire este nuevo punto 30 grados alrededor del eje y y grafique el punto
resultante
R1 = [cosd(30) 0 sind(30); 0 1 0; -sind(30) 0 cosd(30)]
p3=R1*p2
plot3(p3(1), p3(2),p3(3),'ok', 'MarkerFaceColor', 'r')
grid on
8. Gire finalmente 90 grados sobre el eje x y grafique el punto final

R2 = [1 0 0; 0 cosd(90) -sind(90); 0 sind(90) cosd(90)]

p4=R2*p3
plot3(p4(1), p4(2),p4(3),'ok', 'MarkerFaceColor', 'g')
grid on
9. Genere la matriz de rotación necesaria para llegar del primer punto al punto
final y compare.

R=R*R1*R2
Rt=R1*p
plot3(p4(1), p4(2),p4(3),'ok', 'MarkerFaceColor', 'g')
grid on
 10. Este ejercicio se realizó en eje fijo? Eje actual? Por qué?

El ejercicio inicial se realizó en el eje fijo ya que se describe el vector como un punto
fijo, adicional se realiza pre multiplicación.
La “posición” de cualquier punto P sobre un cuerpo rígido en movimiento respecto a
un sistema de referencia fijo puede describirse mediante el vector cartesiano
tridimensional

11. Realice el mismo ejemplo con el eje contrario

p = [3; 2; 4]
plot3(p(1), p(2),p(3),'ok', 'MarkerFaceColor', 'b')
grid on
hold on

%% giro en x, 90 grados
Rx = [1 0 0; 0 cosd(90) -sind(90); 0 sind(90) cosd(90)] %%Rx
p2=Rx*p
plot3(p2(1), p2(2),p2(3),'ok', 'MarkerFaceColor', 'k')
grid on
%% giro en y, 30 grados
Ry = [cosd(30) 0 sind(30); 0 1 0; -sind(30) 0 cosd(30)] %% Ry
p3=Ry*p2
plot3(p3(1), p3(2),p3(3),'ok', 'MarkerFaceColor', 'r')
grid on

%% giro en z, 45 grados
Rz = [cosd(45) -sind(45) 0; sind(45) cosd(45) 0; 0 0 1]%% Rz
p4=Rz*p3
plot3(p4(1), p4(2),p4(3),'ok', 'MarkerFaceColor', 'g')
grid on

R=Rz*Ry*Rx
Rt=R*p
plot3(p4(1), p4(2),p4(3),'ok', 'MarkerFaceColor', 'y')
grid on

Se realiza post multiplicacion, la matriz de rotación que se multiplica

inicialmente es la Rx, seguido de Ry y finalmente Rz

p = [3; 2; 4]
plot3(p(1), p(2),p(3),'ok', 'MarkerFaceColor', 'b')
grid on
hold on

%% giro en x, 90 grados
Rx = [1 0 0; 0 cosd(90) -sind(90); 0 sind(90) cosd(90)] %%Rx
p2=Rx*p
plot3(p2(1), p2(2),p2(3),'ok', 'MarkerFaceColor', 'k')
grid on

%% giro en y, 30 grados
Ry = [cosd(30) 0 sind(30); 0 1 0; -sind(30) 0 cosd(30)] %% Ry
p3=Ry*p2
plot3(p3(1), p3(2),p3(3),'ok', 'MarkerFaceColor', 'r')
grid on

%% giro en z, 45 grados
Rz = [cosd(45) -sind(45) 0; sind(45) cosd(45) 0; 0 0 1]%% Rz
p4=Rz*p3
plot3(p4(1), p4(2),p4(3),'ok', 'MarkerFaceColor', 'g')
grid on
 R=Rz*Ry*Rx
Rt=R*p
plot3(p4(1), p4(2),p4(3),'ok', 'MarkerFaceColor', 'y')
grid on

12. Explore la demostración de crear un modelo de robot y explique qué ocurre

Un manipulador de enlaces en serie comprende una serie de enlaces. Cada enlace

se describe
por cuatro parámetros de Denavit-Hartenberg. Definamos un manipulador simple de
2 enlaces. El primer enlace es

>> L1 = Link('d', 0, 'a', 1, 'alpha', pi/2)

L1 =
Revolute(std): theta=q, d=0, a=1, alpha=1.5708, offset=0

El objeto Link que creamos tiene varias propiedades.

>> L1.a

ans =

>> L1.d

ans =

y determinamos que es una articulación de revolución

>> [Link]

ans =

logical

Para un ángulo de articulación dado, digamos q=0,2 rad, podemos determinar la

transformada del enlace
matriz

>> L1.A(0.2)

ans =
0.9801 0 0.1987 0.9801
0.1987 0 -0.9801 0.1987
0 1 0 0
0 0 0 1
El segundo enlace es

>> L2 = Link('d', 0, 'a', 1, 'alpha', 0)

L2 =
Revolute(std): theta=q, d=0, a=1, alpha=0, offset=0

Ahora necesitamos unirlos en un robot manipulador de enlace en serie.

>> bot = SerialLink([L1 L2], 'name', 'my robot')

bot =

my robot:: 2 axis, RR, stdDH, slowRNE

+---+-----------+-----------+-----------+-----------+-----------+
| j | theta | d| a | alpha | offset |
+---+-----------+-----------+-----------+-----------+-----------+
| 1| q1| 0| 1| 1.5708| 0|
| 2| q2| 0| 1| 0| 0|
+---+-----------+-----------+-----------+-----------+-----------+

El objeto robot mostrado muestra muchos detalles. También tiene una serie de
propiedades como el número de uniones

>> bot.n

ans =

Dados los ángulos articulares q1 = 0,1 y q2 = 0,2 podemos determinar la pose del
efector final del robot

>> [Link]([0.1 0.2])

ans =
0.9752 -0.1977 0.0998 1.97
0.0978 -0.0198 -0.9950 0.1977
0.1987 0.9801 0 0.1987
0 0 0 1
lo que se conoce como cinemática directa del robot. Esto y la cinemática inversa se
tratan en demostraciones separadas.

Finalmente podemos dibujar una figura de palo de nuestro robot.

>> [Link]([0.1 0.2])

Eje actual

p = [3; 2; 4]
plot3(p(1), p(2),p(3),'ok', 'MarkerFaceColor', 'b')
grid on
hold on

R = [cosd(45) -sind(45) 0; sind(45) cosd(45) 0; 0 0 1]

p2=R*p
plot3(p2(1), p2(2),p2(3),'ok', 'MarkerFaceColor', 'k')
grid on

R1 = [cosd(30) 0 sind(30); 0 1 0; -sind(30) 0 cosd(30)]

p3=R1*p2
plot3(p3(1), p3(2),p3(3),'ok', 'MarkerFaceColor', 'r')
grid on

R2 = [1 0 0; 0 cosd(90) -sind(90); 0 sind(90) cosd(90)]

p4=R2*p3
plot3(p4(1), p4(2),p4(3),'ok', 'MarkerFaceColor', 'g')
grid on

R=R*R1*R2
Rt=R1*p
plot3(p4(1), p4(2),p4(3),'ok', 'MarkerFaceColor', 'g')
grid on