Proyecto de Grado: "Diseñar e Implementar un Sistema de Control Cinemático para el Robot...

FACULTAD DE INGENIERÍA

Carrera Ingeniería Electrónica

MODALIDAD DE GRADUACIÓN

Graduación por Excelencia

Chao Huang Lin

Santa Cruz – Bolivia 2011

“Diseño e Implementación de un Sistema de Control Cinemático para el Robot

Industrial Motoman K3S”

FACULTAD DE INGENIERÍA

Carrera Ingeniería Electrónica

MODALIDAD DE GRADUACIÓN Graduación por Excelencia

Chao Huang Lin NR. 2006111779

“Proyecto de Grado para optar al grado de Licenciado en

Ingeniería Electrónica”

Santa Cruz – Bolivia 2011

“Diseño e Implementación de un Sistema de Control Cinemático para el Robot

Industrial Motoman K3S”

ABSTRACT

TÍTULO Diseño e Implementación de un Sistema de Control Cinemático para el Robot Industrial Motoman K3S

AUTOR Chao Huang Lin

PROBLEMÁTICA

El robot industrial motoman K3S cuenta con una interfaz de usuario poco

intuitivo y difícil de usar, además todo el sistema de control pertenece a una

arquitectura cerrada.

OBJETIVO

Diseñar e Implementar un Sistema de Control Cinemático para el Robot

Industrial Motoman K3S

CONTENIDO

I.- Introducción; II.- Historia, Estructura y Herramientas matemáticas del robot

industrial; III.- Cinemática y Dinámica del robot industrial; IV.- Análisis del

problema; V.- Diseño del proyecto; VI.- Implementación; VII.- Conclusiones y

Recomendaciones; Bibliografía; Anexos.

CARRERA :Ingeniería Electrónica

DESCRIPTORES O TEMAS

:Robot Industrial, Robótica, Cinemática del robot, Control cinemático

E-MAIL :[email protected]

FECHA :Julio de 2011

TABLA DE CONTENIDO

RESUMEN EJECUTIVO ............................................................................................................ i

1 CAPÍTULO I INTRODUCCIÓN ......................................................................................... 2

1.1 DESCRIPCIÓN DEL PROBLEMA .............................................................................. 3

1.2 SITUACIÓN PROBLEMÁTICA ................................................................................... 3

1.3 SITUACIÓN DESEADA ............................................................................................. 4

1.4 MAPA MENTAL ......................................................................................................... 5

1.5 FORMULACIÓN PROBLEMÁTICA ............................................................................ 6

1.6 OBJETIVOS .............................................................................................................. 6

1.6.1 Objetivo General ................................................................................................ 6

1.6.2 Objetivos Específicos ......................................................................................... 6

1.7 METODOLOGÍA ........................................................................................................ 7

2 CAPÍTULO II HISTORIA, ESTRUCTURA Y HERRAMIENTAS MATEMÁTICAS DEL

ROBOT INDUSTRIAL ............................................................................................................... 8

2.1 HISTORIA DEL ROBOT INDUSTRIAL ....................................................................... 9

2.2 MORFOLOGÍA DEL ROBOT INDUSTRIAL .............................................................. 17

2.2.1 Tipos de configuraciones morfológicas ............................................................. 19

2.2.1.1 Cartesiana ................................................................................................ 19

2.2.1.2 Cilíndrica .................................................................................................. 20

2.2.1.3 Esférica .................................................................................................... 21

2.2.1.4 Brazo articulado........................................................................................ 22

2.2.1.5 SCARA ..................................................................................................... 23

2.2.2 Capacidad de carga ......................................................................................... 24

2.2.3 Velocidad ......................................................................................................... 24

2.2.4 Tipos de actuadores ......................................................................................... 25

2.2.5 Espacio o volumen de trabajo........................................................................... 27

2.3 HERRAMIENTAS MATEMÁTICAS PARA LOCALIZACIÓN ESPACIAL.................... 29

2.3.1 Representación de la posición .......................................................................... 29

2.3.1.1 Coordenadas cartesianas ......................................................................... 29

2.3.1.2 Coordenadas polares y cilíndricas: ........................................................... 31

2.3.2 Representación de la orientación...................................................................... 32

2.3.2.1 Ángulos de Euler ...................................................................................... 37

2.3.3 Coordenadas y matrices de transformación homogéneas: ................................ 39

2.3.3.1 Aplicación de las matrices homogéneas ................................................... 41

3 CAPÍTULO III CINEMÁTICA Y DINÁMICA DEL ROBOT INDUSTRIAL ........................... 45

3.1 CINEMÁTICA DEL ROBOT...................................................................................... 46

3.1.1 Cinemática Directa ........................................................................................... 46

3.1.2 Cinemática Inversa........................................................................................... 49

3.1.2.1 Resolucion de cinematica inversa mediante métodos geométricos. .......... 50

3.1.2.2 Resolución de cinemática inversa a partir de la matriz de transformación

homogénea 51

3.1.3 Matriz Jacobiana .............................................................................................. 52

3.1.4 Matriz Jacobiana Inversa .................................................................................. 53

3.1.5 Configuraciones singulares .............................................................................. 53

3.2 CONTROL CINEMÁTICO ........................................................................................ 55

3.2.1 Funciones de control cinemático....................................................................... 56

3.2.2 Tipos de trayectorias ........................................................................................ 58

3.2.2.1 Trayectoria punto a punto ......................................................................... 59

3.2.2.2 Trayectorias coordinadas o isócronas ..................................................... 60

3.2.2.3 Trayectorias continuas .............................................................................. 61

3.3 DINÁMICA DEL ROBOT .......................................................................................... 62

3.4 CONTROL DINÁMICO ............................................................................................. 63

4 CAPÍTULO IV ANÁLISIS DEL PROBLEMA .................................................................... 64

4.1 INTRODUCCIÓN ..................................................................................................... 65

4.2 ROBOT INDUSTRIAL MOTOMAN K3S ................................................................... 65

4.3 SITUACIÓN ACTUAL .............................................................................................. 66

4.4 RELEVAMIENTO DE REQUERIMIENTO ................................................................. 67

4.5 ANÁLISIS DE REQUERIMIENTOS .......................................................................... 67

4.6 VISIÓN DEL PROYECTO ........................................................................................ 68

4.7 ALCANCE DEL TRABAJO ....................................................................................... 68

4.8 REQUERIMIENTOS DE EQUIPOS .......................................................................... 69

4.9 DETALLE DE COSTOS ........................................................................................... 69

4.10 ANÁLISIS BENEFICIOS ESPERADO .................................................................. 70

4.11 ANÁLISIS DE RIESGOS ...................................................................................... 71

5 CAPÍTULO V DISEÑO .................................................................................................... 73

5.1 PLANTEAMIENTO GLOBAL DE LA SOLUCIÓN ...................................................... 74

5.2 DIAGRAMA DE BLOQUES DEL SISTEMA DE CONTROL CINEMÁTICO ............... 75

5.3 DESCRIPCIÓN DE LOS BLOQUES ........................................................................ 76

5.3.1 Bloque GUI (Interfaz Gráfica del Usuario) ......................................................... 76

5.3.1.1 Gráfico 3D ................................................................................................ 77

5.3.1.2 Simulaciones 3D....................................................................................... 77

5.3.1.3 Tiempo Real ............................................................................................. 78

5.3.1.4 Control Remoto ........................................................................................ 78

5.3.2 Bloque del modelo matemático ......................................................................... 79

5.3.3 Bloque de cálculo matemático .......................................................................... 97

5.3.3.1 Cinemática Directa ................................................................................... 97

5.3.3.2 Cinemática Inversa ................................................................................... 97

5.3.4 Bloque de comunicación .................................................................................. 98

5.3.5 Bloque de diseño mecánico Solidworks .......................................................... 101

5.3.6 Bloque Simulink ............................................................................................. 103

5.3.6.1 Módulo Control Joystick .......................................................................... 104

5.3.6.2 Bloques para la adaptación de los señales del joystick ........................... 104

5.3.6.3 Módulo Realidad Virtual .......................................................................... 109

5.3.7 Conexión Rs232 ERC .................................................................................... 110

5.4 PLAN DE PRUEBAS.............................................................................................. 111

5.4.1 Pruebas individuales de los componentes ...................................................... 111

5.4.2 Pruebas de integración ................................................................................... 112

5.4.3 Pruebas de operación global .......................................................................... 114

5.4.4 Pruebas de rendimiento ................................................................................. 115

6 CAPÍTULO VI IMPLEMENTACIÓN ............................................................................... 116

6.1 DESCRIPCIÓN GLOBAL ....................................................................................... 117

6.2 DESCRIPCIÓN DEL AMBIENTE DEL TRABAJO ................................................... 118

6.3 PROBLEMAS ENCONTRADOS ............................................................................ 119

6.4 SOLUCIONES REALIZADAS ................................................................................. 119

6.5 PROCEDIMIENTO DE IMPLEMENTACIÓN ........................................................... 121

6.6 RESULTADOS DE LAS PRUEBAS........................................................................ 126

6.6.1 Pruebas individuales de los componentes ...................................................... 126

6.6.1.1 Joystick .................................................................................................. 126

6.6.1.2 Realidad Virtual ...................................................................................... 126

6.6.1.3 Diseño Mecánico Solidworks .................................................................. 126

6.6.1.4 Modelo matemático del Motoman K3S .................................................... 126

6.6.1.5 Cálculos Matemáticos ............................................................................. 127

6.6.1.6 Comunicación Rs232 ERC ..................................................................... 127

6.6.2 Pruebas de integración ................................................................................... 127

6.6.2.1 Joystick con simulink .............................................................................. 127

6.6.2.2 Modelo matemático con simulación 3D y Grafica 3D ............................... 128

6.6.2.3 GUI (Interfaz Gráfica del Usuario) con el sistema .................................... 128

6.6.3 Pruebas de operación global .......................................................................... 131

6.6.4 Pruebas de rendimiento ................................................................................. 131

7 CAPÍTULO VII CONCLUSIONES Y RECOMENDACIONES ......................................... 138

BIBLIOGRAFÍA ..................................................................................................................... 142

ANEXOS ............................................................................................................................... 145

ÍNDICE DE FIGURA

FIGURA 1.1 MAPA MENTAL ......................................................................................................... 5

FIGURA 2.1 MECANISMO ANIMADOS DE HERÓN DE ALEJANDRÍA ...................................................... 9

FIGURA 2.2 GALLO DE ESTRASBURGO ....................................................................................... 10

FIGURA 2.3 PATO DE VAUCANSON ............................................................................................. 11

FIGURA 2.4 TELEMANIPULADORES ............................................................................................. 12

FIGURA 2.5 ROBOT UNIMATE .................................................................................................... 13

FIGURA 2.6 SIMILITUD DEL ROBOT CON LA ANATOMÍA DEL CUERPO ................................................ 17

FIGURA 2.7 DISTINTOS TIPOS DE ARTICULACIONES PARA ROBOTS ................................................. 18

FIGURA 2.8 ROBOTS DE CONFIGURACIÓN CARTESIANA ................................................................. 20

FIGURA 2.9 ROBOTS DE CONFIGURACIÓN CILÍNDRICA ................................................................... 21

FIGURA 2.10 ROBOTS DE CONFIGURACIÓN ESFÉRICA................................................................... 22

FIGURA 2.11 ROBOTS DE BRAZO ARTICULADO............................................................................. 23

FIGURA 2.12 ROBOTS SCARA ................................................................................................. 23

FIGURA 2.13 TCP (TOOL CENTER POINT) .................................................................................. 24

FIGURA 2.14 VOLUMEN DE TRABAJO ROBOT CARTESIANO............................................................. 27

FIGURA 2.15 VOLUMEN DE TRABAJO ROBOT CILÍNDRICA ............................................................... 28

FIGURA 2.16 VOLUMEN DE TRABAJO ROBOT POLAR ..................................................................... 28

FIGURA 2.17 REPRESENTACIÓN DE UN VECTOR EN COORDENADAS CARTESIANAS ........................... 30

FIGURA 2.18 REPRESENTACIÓN DE COORDENADAS POLARES Y CILÍNDRICAS .................................. 31

FIGURA 2.19 ORIENTACIÓN DEL SISTEMA OUV RESPECT AL OXY EN UN PLANO ............................... 33

FIGURA 2.20 SISTEMA DE REFERENCIA OXYZ Y SOLIDARIO AL OBJETO OUVW .............................. 34

FIGURA 2.21 ROTACIÓN DEL SISTEMA OUVW RESPECTO A LOS EJES OY Y OZ .............................. 36

FIGURA 2.22 ÁNGULO DE EULER ZXZ ........................................................................................ 39

FIGURA 2.23 DISTINTOS SISTEMAS FINALES SEGÚN EL ORDEN DE LAS TRANSFORMACIONES ............. 44

FIGURA 3.1 COORDENADAS DEL ROBOT YASKAWA (MOTOMAN) .................................................... 47

FIGURA 3.2 PARÁMETROS D-H ROBOT CILÍNDRICA ...................................................................... 49

FIGURA 3.3 PROBLEMA CINEMÁTICA CON MÚLTIPLES SOLUCIONES ................................................ 50

FIGURA 3.4 MATRIZ JACOBIANA DIRECTA E INVERSA .................................................................... 52

FIGURA 3.5 FUNCIONES DEL CONTROL CINEMÁTICO ..................................................................... 55

FIGURA 3.6 GRÁFICA DE FUNCIONES DEL CONTROL CINEMÁTICO ................................................... 57

FIGURA 3.7 DIFERENTES TRAYECTORIAS ARTICULARES POSIBLES PARA UN ROBOT DE 2 GDL .......... 59

FIGURA 3.8 DINÁMICA DE UN ROBOT .......................................................................................... 62

FIGURA 4.1 MOTOMAN K3S ...................................................................................................... 65

FIGURA 4.2 TEACHPANEL Y CONTROLADOR ERC PARA ROBOT INDUSTRIAL MOTOMAN K3S ............. 66

FIGURA 5.1 DIAGRAMA DE BLOQUE GENERAL............................................................................... 74

FIGURA 5.2 DIAGRAMA DE BLOQUE SISTEMA DE CONTROL CINEMÁTICO (MATLAB) ........................... 75

FIGURA 5.3 INTERFAZ GRÁFICA DEL USUARIO .............................................................................. 76

FIGURA 5.4 GRÁFICOS 3D .......................................................................................................... 77

FIGURA 5.5 SIMULACIÓN 3D Y TIEMPO REAL ................................................................................ 78

FIGURA 5.6 CONTROL REMOTO .................................................................................................. 79

FIGURA 5.7 MEDIDAS DEL MOTOMAN K3S ................................................................................... 79

FIGURA 5.8 ALGORITMO DENAVIT – HARTENBERG 1 MOTOMAN K3S .............................................. 80

FIGURA 5.9 ALGORITMO DENAVIT – HARTENBERG 3 MOTOMAN K3S .............................................. 81

FIGURA 5.10 ALGORITMO DENAVIT – HARTENBERG 3 MOTOMAN K3S ............................................ 82







FIGURA 5.17 ALGORITMO DENAVIT – HARTENBERG 10 MOTOMAN K3S .......................................... 89




FIGURA 5.21 PARAMETROS DENAVIT – HARTENBERG MOTOMAN K3S ............................................ 93

FIGURA 5.22 MODELO CINEMÁTICO DEL MOTOMAN K3S VISUALIZADO EN DRIVEBOT......................... 96

FIGURA 5.23 TRAMA DE COMUNICACIÓN ERC .............................................................................. 98

FIGURA 5.24 PROTOCOLO DE COMUNICACIÓN ERC ...................................................................... 99

FIGURA 5.25 COMANDO MOVJ ERC .......................................................................................... 100

FIGURA 5.26 DISEÑO MECÁNICO DE CADA PIEZA EN SOLIDWORKS................................................. 101

FIGURA 5.27 ENLAZADO DE PIEZAS CON VRBUILD2.EXE ............................................................... 101

FIGURA 5.28 DISEÑO MECÁNICO MOTOMAN K3S SOLIDWORKS .................................................... 102

FIGURA 5.29 CONTROL JOYSTICK Y REALIDAD VIRTUAL SIMULINK ................................................. 103

FIGURA 5.30 MÓDULO JOYSTICK ............................................................................................... 104

FIGURA 5.31 MÓDULO JOYSTICK Y SUBSISTEMAS S,L,U,R,B,T .................................................... 105

FIGURA 5.32 SUBSISTEMA S..................................................................................................... 106

FIGURA 5.33 BLOQUES SIMULINK .............................................................................................. 106

FIGURA 5.34 RELACIÓN EJE L Y U ............................................................................................ 107

FIGURA 5.35 SUBSISTEMA ADAPTADORVR ................................................................................ 107

FIGURA 5.36 SUBSISTEMA VR TRANSFORMATIONS ..................................................................... 108

FIGURA 5.37 BLOQUE VIRTUAL REALITY .................................................................................... 109

FIGURA 5.38 CONFIGURACIÓN CABLE DE CONEXIÓN RS232 ERC - PC ....................................... 110

FIGURA 6.1 SISTEMA DE CONTROL CINEMÁTICO .......................................................................... 117

FIGURA 6.2 AMBIENTE DE TRABAJO ........................................................................................... 118

FIGURA 6.3 DISEÑO MECÁNICO DE CADA PIEZA EN SOLIDWORKS .................................................. 121

FIGURA 6.4 DISEÑO 3D EN VRML 2.0 ....................................................................................... 121

FIGURA 6.5 BLOQUE PRINCIPAL SIMULINK .................................................................................. 122

FIGURA 6.6 BLOQUE ADAPTADOR VR SIMULINK ......................................................................... 123

FIGURA 6.7 BLOQUE VR TRANSFORMATION SIMULINK ................................................................. 123

FIGURA 6.8 INTERFAZ GRÁFICA DEL USUARIO GUI ..................................................................... 124

FIGURA 6.9 SISTEMA DE CONTROL CINEMÁTICO .......................................................................... 125

FIGURA 6.10 TRAYECTORIA LINEAL GENERADO EN MATLAB .......................................................... 132

FIGURA 6.11 SIMULACIÓN DEL MOVIMIENTO LINEAL .................................................................... 133

FIGURA 6.12 TRAYECTORIA DE MOVIMIENTO LINEAL ................................................................... 134

FIGURA 6.13 TRAYECTORIA EFECTUADA POR EL ROBOT SIMULADO EN MATLAB ............................... 134

FIGURA 6.14 TRAYECTORIA LINEAL EFECTUADA POR EL ROBOT EN TIEMPO REAL ............................ 135

ÍNDICE DE TABLA

TABLA 2.1 CARATERÍSTICAS DE DISTINTOS TIPOS DE ACTUADORES PARA ROBOTS ........................... 26 TABLA 3.1 TABLA DE PARÁMETROS D-H PARA ROBOT CILÍNDRICA.................................................. 49 TABLA 4.1 TABLA DE EQUIPOS Y COMPONENTES ......................................................................... 69 TABLA 4.2 TABLA DE EQUIPOS Y COMPONENTES QUE SE DEBERÍAN ADQUIRIR ................................ 70

i

RESUMEN EJECUTIVO

Hoy en día el mundo están en constante desarrollo, y surge la necesidad de

crear y usar maquinas que sean capaces de hacer las tareas más difíciles,

donde se requiere mucha habilidad y destreza como el brazo humano. Por esta

razón se crearon los brazos robóticos. El cual es utilizado en muchas industrias

a nivel mundial, y han generado buenos resultados.

La Universidad Privada de Santa Cruz de la Sierra UPSA adquirió un brazo

robótico (Motoman K3S) gracias al convenio con la Universidad de Suecia. El

Motoman K3S cuenta con un controlador ERC en el cual su arquitectura es

cerrada y su interfaz de usuario es poco intuitivo.

La solución propuesta es diseñar un Controlador cinemático mejorando el

controlador ERC, utilizar todas la herramientas que tiene matlab como el

simulink, VRML (Virtual Reality Modeling Language), Controlador de joystick,

etc. Creando así un sistema de control cinemático de arquitectura abierta, con

una interfaz de usuario mucho más avanzada, intuitiva y fácil de manejar.

El sistema de control cinemático cuenta con animaciones y simulación 3D del

brazo robótico, permitiendo un manejo mucho más fácil e intuitiva. Y Como el

sistema de control es de código abierto se puede desarrollar mucho más

aplicaciones sobre el programa base.

CAPÍTULO I INTRODUCCIÓN

2

1 CAPÍTULO I INTRODUCCIÓN


3

1.1 DESCRIPCIÓN DEL PROBLEMA

El Motoman K3S es un robot compacto con seis ejes de articulación y una

capacidad de carga de 3 kg. Cuenta con un tamaño reducido y puede mover

hasta una velocidad de 2,5 m/s. por su tamaño compacto puede ser montado

fácilmente en el suelo, techo o pared. Las aplicaciones estándares del Motoman

K3S son: soldadura de arco, montaje y manipulación de materiales.

El controlador ERC del Motoman K3S cuenta con un sistema de control de

arquitectura cerrada y su interfaz de usuario es poco intuitivo, por eso surgió la

idea de Diseñar e Implementar un Sistema de Control Cinemático de

arquitectura abierta con una interfaz de usuario más avanzado, intuitivo y fácil

de manejar. Donde cuenta con animaciones y simulaciones 3D, permitiendo un

manejo mucho más fácil e intuitivo.

1.2 SITUACIÓN PROBLEMÁTICA

“Sistema de arquitectura cerrada y Deficiente interfaz de usario que presenta el

Robot Industrial Motoman K3S de la Universidad Privada de Santa Cruz de la

Sierra”

Debido a que el Robot Industrial Motoman K3S es una tecnología antigua, no

cuenta con una interfaz de usuario y control mediante computadora.

Además para poder equipar al Brazo Robótico con un control moderno e

interfaz de usuario avanzado a nivel comercial presentaría un costo

elevadísimo. El controlador del brazo tiene un costo de 5 a 6 veces mayor que

la estructura mecánica del Brazo Robótico.


4

1.3 SITUACIÓN DESEADA

Tener un Sistema de control cinemático con animaciones y simulaciones 3D,

una interfaz de usuario avanzada, donde permite manipular al Robot de una

forma fácil e intuitiva.


5

1.4 MAPA MENTAL

Figura 1.1 Mapa Mental Fuente [EP]

Deficiente control e interfaz del Robot Industrial Motoman

K3S que se encuentra en la Universidad Privada de Santa

Cruz de la Sierra.

CAUSAS

Tecnología Antigua

Costo Elevado para equipar con control moderno

CONSECUENCIAS

Equipo de Control de gran Tamaño

Problema en la instalación del Equipo

Interfaz de Usuario poco amigable

Dificultad en la programación

Lenguaje de programación de bajo nivel

ESTADOS DESEADOS

Control mediante Computadora

Interfaz del usuario Amigable

Lenguaje de Alto

Nivel


6

1.5 FORMULACIÓN PROBLEMÁTICA

S.P: Deficiente control e interfaz del Robot Industrial Motoman K3S que se

encuentra en la Universidad Privada de Santa Cruz de la Sierra.

1. Control e Interfaz del Robot Industrial Motoman K3S que se encuentra en la

Universidad Privada de Santa Cruz de la Sierra.

2. Control Cinemático del Robot Industrial Motoman K3S

F.P : Sistema de Control Cinemático para el Robot Industrial Motoman K3S

1.6 OBJETIVOS

1.6.1 Objetivo General

Diseñar e Implementar un Sistema de Control Cinemático para el

Robot Industrial Motoman K3S

1.6.2 Objetivos Específicos

1. Caracterizar la Estructura y Herramientas Matemáticas del Brazo

Robótico.

2. Caracterizar la Cinemática y la Dinámica de un Robot Industrial.

3. Diseñar el Modelado 3D y Calcular el modelo matemático del Brazo

Robótico.

4. Diseñar el Sistema de Control Cinemático para brazo robótico.

5. Implementar el Sistema de Control Cinemático.


7

1.7 METODOLOGÍA

1. Caracterizar la Historia, La Estructura y Herramientas Matemáticas del

Brazo Robótico

1.1. Caracterizar la Historia de la Robótica

1.2. Caracterizar Morfología del Brazo Robótico

1.3. Caracterizar Herramientas Matemáticas del Brazo Robótico

2. Caracterizar la Cinemática y la Dinámica de un Robot Industrial

2.1. Caracterizar la Cinemática del Brazo Robótico

2.2. Caracterizar la Dinámica del Brazo Robótico

3. Diseñar el Modelado 3D y Calcular el modelo matemático del Brazo

Robótico.

4. Diseñar el Sistema de Control Cinemático para brazo robótico.

4.1. Programar Software de Control Cinemático

4.2. Simular el Controlador

4.3. Comunicar el Software con el robot industrial

5. Implementar el Sistema de Control Cinemático.

5.1. Probar el controlador

5.2. Corregir y mejorar fallas detectadas

CAPÍTULO II HISTORIA, ESTRUCTURA Y HERRAMIENTAS MATEMÁTICAS DEL ROBOT INDUSTRIAL

8

2

CAPÍTULO II

HISTORIA, ESTRUCTURA Y

HERRAMIENTAS MATEMÁTICAS

DEL ROBOT INDUSTRIAL


9

2.1 HISTORIA DEL ROBOT INDUSTRIAL

Un Robot Industrial es un manipulador multifuncional reprogramable con varios

grados de libertad, capaz de manipular materias, piezas, herramientas o

dispositivos especiales. Los robots son capaces de realizar tareas repetitivas de

forma más rápida, barata y precisa que los seres humanos.

A lo largo de toda la historia, el hombre se ha sentido fascinado por máquinas y

dispositivos capaces de imitar las funciones y los movimientos de los seres

vivos. Los griegos tenían una palabra específica para denominar a estas

máquinas: automatos. De esta palabra deriva la actual autómata: máquina que

imita la figura y movimientos de un ser animado. Los mecanismos animados de

Herón de Alejandría (85 d.C.) se movían a través de dispositivos hidráulicos,

poleas y palancas y tenían fines eminentemente lúdicos.

Figura 2.1 Mecanismo animados de Herón de Alejandría Fuente [1]


10

La cultura árabe (Siglo VIII a XV) heredó y difundió los conocimientos griegos,

utilizándolos no sólo para realizar mecanismos destinado a la diversión, sino

que les dio una aplicación práctica, introduciéndolos en la vida cotidiana de la

realeza. Ejemplos de estos son diversos sistemas dispensadores automáticos

de agua para beber o lavarse. También de ese periodo son otros autómatas, de

los que hasta la actualidad no han llegado más que referencias no suficientes

documentadas, como el hombre de hierro de Albert Magno (1204-1282) o la

Cabeza parlante de Roger Bacon (1214-1294). Otro ejemplo relevante de

aquella época fue el Gallo de Estrasburgo (1352). Este, que es el autómata más

antiguo que se conserva en la actualidad, formaba parte del reloj de la torre de

la catedral de Estrasburgo y al dar las horas movía las alas y el pico.

Durante los siglos XV y XVI algunos de los más relevantes representantes del

renacimiento se interesan también por los ingenios descritos y desarrollados por

los griegos. Es conocido el León Mecánico construido por Leonardo Da Vinci

(1452-1519) para el rey Luis XII de Francia, que se abría el pecho con su garra

y mostraba el escudo de armas del rey. En España es conocido por el Hombre

de palo, construido por Juanelo Turriano en siglo XI para el emperador Carlos

Figura 2.2 Gallo de Estrasburgo Fuente [1]


11

V. Este autómata con forma de monje, andaba y movía la cabeza, ojos, boca y

brazos.

Durante los siglos XVII y XVIII se crearon ingenios mecánicos que tenían

alguna de las características de los robots actuales. Estos dispositivos fueron

creados en su mayoría por artesanos del gremio de la relojería. Su misión

principal era la de entretener a las gentes de la corte y servir de atracción en las

ferias. Estos autómatas representaban figuras humanas, animales o pueblos

enteros. Son destacados entre otros el pato de Vaucason y los muñecos de la

familia Droz y de Mailadert.

El término Robot procede de la palabra checa robota, que significa 'trabajo

obligatorio'; fue empleado por primera vez en la obra teatral de 1921 R.U.R.

(Robots Universales de Rossum) por el novelista y dramaturgo checo Karel

Èapek. Desde entonces se ha empleado la palabra robot para referirse a una

máquina que realiza trabajos para ayudar a las personas o efectúa tareas

difíciles o desagradables para los humanos.

Figura 2.3 Pato de Vaucanson Fuente [1]


12

Los progenitores más directos de los robots de hoy fueron los

telemanipuladores. En 1948 R.C. Goertz del Argonne National Laboratory

desarrllo con el objetivo de manipular elementos radioactivos sin riesgo para el

operador, el primer telemanipulador consistía en un dispositivo mecánico

maestro-esclavo. El manipulador maestro situado en la zona segura era movido

directamente por el operador, mientras que el esclavo situado en contacto con

los elementos radioactivos y unidos mecánicamente al maestro reproducía

fielmente los movimientos del maestro. El operador además de poder observar

a través de un grueso cristal el resultado de sus acciones, también sentía a

través del dispositivo maestro las fuerzas que el esclavo ejercía sobre el

entorno.

Años mas tarde, en 1954, Geortz hizo uso de la tecnología electrónica y del

servocontrol sustituyendo la transmisión mecánica por la eléctrica desarrollando

asi el primer telemanipulador con servocontrol bilateral. Otro de los pioneros de

la tele manipulación fue Ralph Mosher, ingeniero de la General Electric que en

1958 desarrollo un dispositivo denominado Handy-Man, consistente en dos

brazos mecánicos tele operados mediante un maestro del tipo denominado

exoesqueleto. Junto a la industria nuclear, a lo largo de los años sesenta la

industria submarina comenzó a interesarse por el uso de los telemanipuladores.

A este interés se sumo la industria espacial en los años setenta.

Figura 2.4 Telemanipuladores Fuente [1]


13

La evolución de los telemanipuladores a lo largo de los últimos años no ha sido

tan espectacular como la de los robots. Recluidos en un mercado selecto y

limitado (industria nuclear, militar, espacial, etc.) son en general desconocidos y

comparativamente poco atendidos por los investiga- dores y usuarios de robots.

Por su propia concepción, un tele manipulador precisa el mando continuo de un

operador, y salvo por las aportaciones incorporadas con el concepto del control

supervisado y la mejora de la tele presencia promovida hoy día por la realidad

virtual, sus capacidades no han variado mucho respecto a las de sus orígenes.

La sustitución del operador por un programa de ordenador que controlase los

movimientos del manipulador dio paso al concepto de robot.

La primera patente de un dispositivo robótico fue solicitada en marzo de 1954

por el inventor británico C.W. Kenward. Dicha patente fue emitida en el Reino

Unido en 1957, sin embargo fue Geoge C. Devol, ingeniero norteamericano,

inventor y autor de varias patentes, él estableció las bases del robot industrial

moderno. En 1954 Devol concibió la idea de un dispositivo de transferencia de

artículos programada que se patento en Estados Unidos en 1961.

Figura 2.5 Robot Unimate Fuente [1]


14

En 1956 Joseph F. Engelberger, director de ingeniería de la división

aeroespacial de la empresa Manning Maxwell y Moore en Stanford, Conneticut.

Juntos Devol y Engelberger comenzaron a trabajar en la utilización industrial de

sus maquinas, fundando la Consolidated Controls Corporation, que más tarde

se convierte en Unimation(Universal Automation), e instalando su primera

maquina Unimate (1960), en la fabrica de General Motors de Trenton, Nueva

Jersey, en una aplicación de fundición por inyección.

Otras grandes empresas como AMF, emprendieron la construcción de

maquinas similares (Versatran- 1963.

En 1968 J.F. Engelberger visito Japón y poco más tarde se firmaron acuerdos

con Kawasaki para la construcción de robots tipo Unimate. El crecimiento de la

robótica en Japón aventaja en breve a los Estados Unidos gracias a Nissan,

que formo la primera asociación robótica del mundo, la Asociación de Robótica

industrial de Japón (JIRA) en 1972. Dos años más tarde se formo el Instituto de

Robótica de América (RIA), que en 1984 cambio su nombre por el de

Asociación de Industrias Robóticas, manteniendo las mismas siglas (RIA.)

Por su parte Europa tuvo un despertar más tardío. En 1973 la firma sueca

ASEA construyo el primer robot con accionamiento totalmente eléctrico, en

1980 se fundo la Federación Internacional de Robótica con sede en Estocolmo

Suecia.

La configuración de los primeros robots respondía a las denominadas

configuraciones esférica y antropomórfica, de uso especialmente valido para la

manipulación. En 1982, el profesor Makino de la Universidad Yamanashi de

Japón, desarrolla el concepto de robot SCARA (Selective Compliance Assembly

Robot Arm) que busca un robot con un número reducido en grados de libertad


15

(3 o 4), un coste limitado y una configuración orientada al ensamblado de

piezas.

La definición del robot industrial, como una máquina que puede efectuar un

número diverso de trabajos, automáticamente, mediante la programación previa,

no es válida, porque existen bastantes maquinas de control numérico que

cumplen esos requisitos. Una peculiaridad de los robots es su estructura de

brazo mecánico y otra su adaptabilidad a diferentes aprehensores o

herramientas. Otra característica especifica del robot, es la posibilidad de llevar

a cabo trabajos completamente diferentes e, incluso, tomar decisiones según la

información procedente del mundo exterior, mediante el adecuado programa

operativo en su sistema informático.

Se pueden distinguir cinco fases relevantes en el desarrollo de la Robótica

Industrial:

1. El laboratorio ARGONNE diseña, en 1950, manipuladores amo-

esclavo para manejar material radioactivo.

2. Unimation, fundada en 1958 por Engelberger y hoy absorbida por

Whestinghouse, realiza los primeros proyectos de robots a principios

de la década de los sesentas de nuestro siglo, instalando el primero

en 1961 y posteriormente, en 1967, un conjunto de ellos en una

factoría de general motors. Tres años después, se inicia la

implantación de los robots en Europa, especialmente en el área de

fabricación de automóviles. Japón comienza a implementar esta

tecnología hasta 1968.

3. Los laboratorios de la Universidad de Stanford y del MIT acometen, en

1970, la tarea de controlar un robot mediante computador.


16

4. En el año de 1975, la aplicación del microprocesador, transforma la

imagen y las características del robot, hasta entonces grande y

costoso.

5. A partir de 1980, el fuerte impulso en la investigación, por parte de las

empresas fabricantes de robots, otros auxiliares y diversos

departamentos de Universidades de todo el mundo, sobre la

informática aplicada y la experimentación de los sensores, cada vez

mas perfeccionados, potencian la configuración del robot inteligente

capaz de adaptarse al ambiente y tomar decisiones en tiempo real,

adecuarlas para cada situación.

En esta fase que dura desde 1975 hasta 1980, la conjunción de los efectos de

la revolución de la Microelectrónica y la revitalización de las empresas

automovilísticas, produjo un crecimiento acumulativo del parque de robots,

cercano al 25%.

La evolución de los robots industriales desde sus principios ha sido vertiginosa.

En poco más de 30 años las investigaciones y desarrollos sobre robótica

industrial han permitido que los robots tomen posiciones en casi todas las áreas

productivas y tipos de industria. En pequeñas o grandes fábricas, los robots

pueden sustituir al hombre en aquellas áreas repetitivas y hostiles, adaptándose

inmediatamente a los cambios de producción solicitados por la demanda

variable.

Fuente [1]


17

2.2 MORFOLOGÍA DEL ROBOT INDUSTRIAL

La constitución física de la mayor parte de los robots industriales guarda cierta

similitud con la anatomía de las extremidades superiores del cuerpo humano,

por lo que, en ocasiones, para hacer referencia a los distintos elementos que

componen el robot, se usan términos como cintura, hombro, brazo, codo,

muñeca, etc. [2]

Grado de libertad: (GDL) se refiere a cada uno de los movimientos

independientes que puede realizar cada articulación con respecto a la anterior,

Cada articulación provee al robot de al menos un grado de libertad.

Figura 2.6 Similitud del robot con la anatomía del cuerpo Fuente [2]


18

El movimiento de cada articulación puede ser de desplazamiento, de giro o una

combinación de ambos. De este modo son posibles seis tipos diferentes de

articulaciones:

Esférica o Rótula (3 GDL), Planar (2 GDL), Tornillo (1 GDL), Prismática (1 GDL),

Rotación (1 GDL), Cilíndrica (2 GDL)

Aunque en la práctica, en los robots sólo se emplean la de rotación y la

prismática.

El empleo de diferentes combinaciones de articulaciones en un robot, da lugar a

diferentes configuraciones, con ciertas características tanto en el diseño y

construcción del robot como en su aplicación.

Figura 2.7 Distintos tipos de articulaciones para robots Fuente [3]


19

El número de grados de libertad del robot viene dado por la suma de los GDL

de las articulaciones que lo componen. Puesto que las articulaciones

empleadas suelen ser únicamente de rotación y prismáticas, con un solo grado

de libertad cada una, el número de GDL del robot suele coincidir con el número

de articulaciones que lo componen. [3]

2.2.1 Tipos de configuraciones morfológicas

La estructura del manipulador y la relación entre sus elementos proporcionan

una configuración mecánica, que da origen al establecimiento de los

parámetros que hay que conocer para definir la posición y orientación del

elemento terminal. Fundamentalmente, existen cuatro estructuras clásicas en

los manipuladores, que se relacionan con los correspondientes modelos de

coordenadas en el espacio y que se citan a continuación: cartesianas,

cilíndricas, esféricas, angulares. Así, el brazo robótico puede presentar cuatro

configuraciones clásicas: cartesiana, cilíndrica, esférica, de brazo articulado y

una no clásica: SCARA (Selective Compliance Assembly Robot Arm).

2.2.1.1 Cartesiana

En la configuración Cartesiana o Rectilínea, El posicionando se hace en el

espacio de trabajo con las articulaciones prismáticas. Esta configuración se usa

bien cuando un espacio de trabajo es grande y debe cubrirse, Posee tres

movimientos lineales, es decir, tiene tres grados de libertad, los cuales

corresponden a los movimientos localizados en los ejes X, Y y Z.

Los movimientos que realiza este robot entre un punto y otro son con base en

interpolaciones lineales. Interpolación, en este caso, significa el tipo de

trayectoria que realiza el manipulador cuando se desplaza entre un punto y otro.

A la trayectoria realizada en línea recta se le conoce como interpolación lineal y


20

a la trayectoria hecha de acuerdo con el tipo de movimientos que tienen sus

articulaciones se le llama interpolación por articulación.

2.2.1.2 Cilíndrica

En la configuración Cilíndrica, El robot tiene un movimiento de rotación sobre

una base, una articulación prismática para la altura, y una prismática para el

radio. Este robot ajusta bien a los espacios de trabajo redondos. Puede realizar

dos movimientos lineales y uno rotacional, o sea, que presenta tres grados de

libertad.

Este robot está diseñado para ejecutar los movimientos conocidos como

interpolación lineal e interpolación por articulación. La interpolación por

articulación se lleva a cabo por medio de la primera articulación, ya que ésta

puede realizar un movimiento rotacional.

Figura 2.8 Robots de configuración cartesiana Fuente [2]


21

2.2.1.3 Esférica

En la configuración Esférica o Polar, Dos juntas de rotación y una prismática

permiten al robot apuntar en muchas direcciones, y extender la mano a un poco

de distancia radial. Los movimientos son: rotacional, angular y lineal. Este robot

utiliza la interpolación por articulación para moverse en sus dos primeras

articulaciones y la interpolación lineal para la extensión y retracción

Figura 2.9 Robots de configuración cilíndrica Fuente [2]


22

2.2.1.4 Brazo articulado

En la configuración de Brazo articulado / Articulación esférica / Articulación

coordinada / Rotación / Angular, El robot usa 3 juntas de rotación para

posicionarse. Generalmente, el volumen de trabajo es esférico. Estos tipos de

robot se parecen al brazo humano, con una cintura, el hombro, el codo, la

muñeca. Presenta una articulación con movimiento rotacional y dos angulares.

Aunque el brazo articulado puede realizar el movimiento llamado interpolación

lineal (para lo cual requiere mover simultáneamente dos o tres de sus

articulaciones), el movimiento natural es el de interpolación por articulación,

tanto rotacional como angular.

Figura 2.10 Robots de configuración esférica Fuente [2]


23

2.2.1.5 SCARA

En la configuración SCARA, Similar al de configuración cilíndrica, pero el radio y

la rotación se obtiene por uno o dos eslabones. Este brazo puede realizar

movimientos horizontales de mayor alcance debido a sus dos articulaciones

rotacionales. El robot de configuración SCARA también puede hacer un

movimiento lineal (mediante su tercera articulación). [2]

Figura 2.11 Robots de brazo articulado Fuente [2]

Figura 2.12 Robots SCARA Fuente [2]


24

2.2.2 Capacidad de carga

La capacidad de carga se refiere al peso que puede transportar la garra del

manipulador. A veces, este dato lo proporcionan los fabricantes, incluyendo el

peso de la propia garra.

En modelos de robots indústriales, la capacidad de carga de la garra, puede

oscilar de entre 0.9Kg y 205kg. La capacidad de carga es una de las

características que más se tienen en cuenta en la selección de un robot, según

la tarea a la que se destine. En soldadura y mecanizado es común precisar

capacidades de carga superiores a los 50kg. [4]

2.2.3 Velocidad

Se refiere a la velocidad máxima alcanzable por el TCP (Tool Center Point) o

por las articulaciones. En muchas ocasiones, una velocidad de trabajo elevada,

aumenta extraordinariamente el rendimiento del robot, por lo que esta magnitud

se valora considerablemente en la elección del mismo. En tareas de soldadura

Figura 2.13 TCP (Tool Center Point) Fuente [4]


25

y manipulación de piezas es muy aconsejable que la velocidad de trabajo sea

alta. En pintura, mecanizado y ensamblaje, la velocidad debe ser media e

incluso baja. [4]

2.2.4 Tipos de actuadores

Los elementos motrices que generan el movimiento de las articulaciones

pueden ser, según la energía que consuman, de tipo olehidráulico, neumático o

eléctrico.

Los actuadores de tipo olehidráulico se destinan a tareas que requieren una

gran potencia y grandes capacidades de carga. Dado el tipo de energía que

emplean, se construyen con mecánica de precisión y su coste es elevado. Los

robots hidráulicos se diseñan formando un conjunto compacto la central

hidráulica, la cabina electrónica de control y el brazo del manipulador.

La energía neumática dota a sus actuadores de una gran velocidad de

respuesta junto a un bajo coste, pero su empleo está siendo sustituido por

elementos eléctricos.

Los motores eléctricos, que cubren la gama de media y baja potencia, acaparan

el campo de la Robótica, por su gran precisión en el control de su movimiento y

las ventajas inherentes a la energía eléctrica que consumen. [3]


26

Tabla de características de distintos tipos de actuadores para robots

Neumático Hidráulico Eléctrico Energía Aire a presión

(5-10 bar) Aceite mineral (50-100 bar)

Corriente eléctrica

Opciones Cilindros Motor de paletas Motor de pistón

Cilindros Motor de paletas Motor de pistones axiales

Corriente continua Corriente alterna Motor paso a paso

Ventajas Baratos Rápidos Sencillos Robustos

Rápidos Alta relación potencia-peso Autolubricantes Alta capacidad de carga Estabilidad frente a cargas estáticas

Precisos Fiables Fácil control Sencilla instalación Silenciosos

Desventajas Dificultad de control continuo Instalación especial (compresor, filtros) Ruidoso

Difícil mantenimiento Instalación especial (filtros, eliminación de aire) Frecuentes fugas Caros

Potencia limitada

Tabla 2.1 Caraterísticas de distintos tipos de actuadores para robots

Fuente [3]


27

2.2.5 Espacio o volumen de trabajo

Las dimensiones de los elementos del manipulador, junto a los grados de

libertad, definen la zona de trabajo del robot, característica fundamental en las

fases de selección e implantación del modelo adecuado.

El volumen de trabajo de un robot se refiere únicamente al espacio dentro del

cual puede desplazarse el extremo de su muñeca. Para determinar el volumen

de trabajo no se toma en cuenta el actuador final. La razón de ello es que a la

muñeca del robot se le pueden adaptar grippers (pinzas) de distintos tamaños.

El robot cartesiano y el robot cilíndrico presentan volúmenes de trabajo

regulares. El robot cartesiano genera una figura cúbica.

El robot de configuración cilíndrica presenta un volumen de trabajo parecido a

un cilindro (normalmente este robot no tiene una rotación de 360°)

Figura 2.14 Volumen de trabajo robot cartesiano

Fuente [2]


28

Los robots que poseen una configuración polar, los de brazo articulado y los

modelos SCARA presentan un volumen de trabajo irregular. [2]

Figura 2.15 Volumen de trabajo robot cilíndrica

Fuente [2]

Figura 2.16 Volumen de trabajo robot Polar

Fuente [2]


29

2.3 HERRAMIENTAS MATEMÁTICAS PARA LOCALIZACIÓN ESPACIAL

2.3.1 Representación de la posición

Para localizar un cuerpo rígido en el espacio es necesario contar con una

herramienta que permita la localización espacial de sus puntos. En un plano el

posicionamiento tiene dos grados de libertad, y por tanto la posición de un

punto vendrá definida por dos componentes independientes. En el caso de un

espacio tridimensional será necesario emplear tres componentes.

2.3.1.1 Coordenadas cartesianas

La forma más intuitiva y utilizada de especificar la posición de un punto son

coordenadas cartesianas. Existen además otros métodos, igualmente válidos, y

también ampliamente extendidos, como son las coordenadas polares para dos

dimensiones, y las cilíndricas y esféricas para espacios de tres dimensiones.

Sistema cartesiano de referencia: Normalmente los sistemas de referencia se

definen mediante ejes perpendiculares entre sí con un origen definido. Estos se

denominan sistemas cartesianos, y en el caso de trabajar en el plano (2

dimensiones), el sistema de referencia OXY correspondiente queda definido por

dos vectores coordenados OX y OY perpendiculares entre sí con un punto de

intersección común O.

Si se trabaja en el espacio (tres dimensiones), el sistema cartesiano OXYZ está

compuesto por una terna ortogonal de vectores coordenados OX, OY y OZ.


30

Coordenadas Cartesianas: Si se trabaja en un plano, con su sistema

coordenado OXY de referencia asociado, un punto ‘a’ vendrá expresado por las

componentes (x,y) correspondientes a los ejes coordenados del sistema OXY.

Este punto tiene asociado un vector p(x,y), que va desde el origen O del

sistema OXY hasta el punto a. por tanto, la posición del extremo del vector p

está caracterizado por las dos componentes (x,y), denominadas coordenadas

cartesianas del vector y que son las proyecciones del vector p sobre los ejes

OX y OY.

En el caso de que se trabaje en tres dimensiones, un vector viene definido con

respecto al sistema de referencia OXYZ mediante las coordenadas

correspondientes a cada uno de los ejes coordenados.

Figura 2.17 Representación de un vector en coordenadas cartesianas

Fuente [3]


31

2.3.1.2 Coordenadas polares y cilíndricas:

Para un plano, es posible también caracterizar la localización de un punto o

vector p respecto a un sistema de ejes cartesianos de referencia OXY utilizando

las denominadas coordenadas polares p(r,ө). En esta representación, r

representa la distancia desde el origen O del sistema hasta el extremo del

vector p, mientras que ө es el ángulo que forma el vector p con el eje OX.

En el caso de trabajar en tres dimensiones, un vector p podrá expresarse con

respecto a un sistema de referencia OXYZ, mediante las coordenadas

cilíndricas p(r,ө,z). Las componentes r y ө tienen el mismo significado que en el

caso de coordenadas polares, aplicado el razonamiento sobre el plano OXY,

mientras que la componente z expresa la proyección sobre el eje OZ del vector

p.

Figura 2.18 Representación de coordenadas polares y cilíndricas

Fuente [3]


32

2.3.2 Representación de la orientación

Un punto queda totalmente definido en el espacio a través de los datos de su

posición. Sin embargo, para el caso de un sólido, es necesario además definir

cuál es su orientación con respecto a un sistema de referencia. En el caso de

un robot, no es suficiente con especificar cuál debe ser la posición de su

extremo, sino que en general, es también necesario indicar su orientación. Por

ejemplo, en el caso de un robot que tenga que realizar sobre una pieza curva

una operación de pulido, no bastaría con especificar los puntos de la superficie

para situar adecuadamente la herramienta, sino que será necesario también

conocer la orientación con que la herramienta ha de realizar la operación.

Una orientación en el espacio tridimensional viene definida por tres grados de

libertad o tres componentes linealmente independientes. Para poder describir

de forma sencilla la orientación de un objeto respecto a un sistema de

referencia, es habitual asignar solidariamente al objeto un nuevo sistema, y

después estudiar la relación espacial existente entre los dos sistemas. De forma

general, esta relación vendrá dada por la posición y orientación del sistema

asociado al objeto respecto al de referencia. Para el análisis de los distintos

métodos de representar orientaciones se supondrá que ambos sistemas

coinciden en el origen, y que por tanto no existe cambio alguno de posición

entre ellos.

Matrices de Rotación: Las matrices de rotación son el método más extendido

para la descripción de orientaciones, debido principalmente a la comodidad que

proporciona el uso del álgebra matricial.


33

Un vector p del plano se puede representar en ambos sistemas como:

푃 = 푃 ,푃 = 푃 ∙ 푖 + 푃 ∙ 푗

푃 = [푃 ,푃 ] = 푃 ∙ 푖 + 푃 ∙ 푗

Y la matriz de rotación nos permite obtener las coordenadas de un vector del

sistema OUV en el sistema OXY.

푃푃 = 푅 푃

푃

Donde:

푅 =푖 푖 푖 푗푗 푖 푗 푗 푅 = cos훼 − sin 훼

sin 훼 cos훼

EC (2.1)

EC (2.2)

EC (2.3)

Figura 2.19 Orientación del sistema OUV respect al OXY en un plano

Fuente [3]


34

R es la matriz de rotación, que define la orientación del sistema OUV con

respecto al sistema OXY, y que sirve para transformar las coordenadas de

un vector en un sistema a las del otro. También recibe el nombre de matriz

de cosenos directores.

En un espacio tridimensional, Un vector p del espacio podrá ser referido a

cualquiera de los sistemas de la siguiente manera:

푃 = 푃 ,푃 ,푃 = 푃 ∙ 푖 + 푃 ∙ 푗 + 푃 ∙ 푘

푃 = [푃 ,푃 ,푃 ] = 푃 ∙ 푖 + 푃 ∙ 푗 + 푃 ∙ 푘

Y al igual que en dos dimensiones, se puede obtener la siguiente

equivalencia:

EC (2.4)

Figura 2.20 Sistema de referencia OXYZ y solidario al objeto OUVW

Fuente [3]


35

푃푃푃

= 푅푃푃푃

Donde:

푅 =푖 푖 푖 푗 푖 푘푗 푖 푗 푗 푗 푘푘 푖 푘 푗 푘 푘

R es la matriz de rotación que define la orientación del sistema OUVW con

respecto al sistema OXYZ. Al igual que en dos dimensiones, también recibe el

nombre de matriz de cosenos directores.

La principal utilidad de esta matriz de rotación corresponde a la representación

de la orientación de sistemas girados únicamente sobre uno de los ejes

principales del sistema de referencia.

La orientación del sistema OUVW, con el eje OU coincidente con el eje OX,

vendrá representada mediante la matriz:

푅(푥,훼) =1 0 00 cos훼 − sin 훼0 sin 훼 cos훼

La orientación del sistema OUVW, con el eje OV coincidente con el eje

OY, vendrá representada mediante la matriz:

푅(푦,휙) =cos휙 0 sin휙

0 1 0− sin휙 0 cos휙

EC (2.5)

EC (2.6)

EC (2.7)

EC (2.8)


36

La orientación del sistema OUVW, con el eje OW coincidente con el eje OZ,

vendrá representada mediante la matriz:

푅(푧, 휃) =cos휃 − sin휃 0sin 휃 cos 휃 0

0 0 1

Estas tres matrices, se denominan matrices básicas de rotación de un

sistema espacial de tres dimensiones.

Composiciones de rotaciones: Las matrices de rotación pueden componerse

para expresar la aplicación continua de varias rotaciones. Así, si al sistema

OUVW se le aplica una rotación de ángulo ⍺ sobre OX, seguida de una

EC (2.9)

Figura 2.21 Rotación del sistema OUVW respecto a los ejes OY y OZ

Fuente [3]


37

rotación de ángulo Φ sobre OY y de una rotación de ángulo ө sobre OZ, la

rotación global puede expresarse como:

푇 = 푅(푧, 휃)푅(푦,휙)푅(푥,훼) =cos휃 − sin휃 0sin휃 cos휃 0

0 0 1

cos휙 0 sin휙0 1 0

− sin휙 0 cos휙

1 0 00 cos훼 − sin훼0 sin훼 cos훼

=

=cos휃 cos휙 − sin휃 cos훼 + cos휃 sin휙 sin훼 sin휃 sin훼 + cos휃 sin휙 cos훼sin휃 cos휙 cos휃 cos훼 + sin휃 sin휙 sin훼 − cos휃 sin훼 + sin휃 sin휙 cos훼− sin휙 cos휙 sin훼 cos휙 cos훼

Como el producto de matrices no es conmutativo. Así, si la rotación se

hiciera primero un ángulo ө sobre OZ, seguida de una rotación de ángulo Φ

sobre OY, para finalizar con otra rotación de ángulo ⍺ sobre OX, la rotación

global vendría expresada por:

푇 = 푅(푥,훼)푅(푦,휙)푅(푧,휃) =1 0 00 cos훼 − sin훼0 sin훼 cos훼

cos휙 0 sin휙0 1 0

− sin휙 0 cos휙

cos휃 − sin휃 0sin휃 cos휃 0

0 0 1=

=cos휙 cos휃 −cos휙 sin휃 sin휙

sin훼 sin휙 cos휃 + cos훼 sin휃 − sin훼 sin휙 sin휃 + cos훼 cos휃 − sin훼 cos휙− cos훼 sin휙 cos휃 + sin훼 sin휃 cos훼 sin휙 sin휃 + sin훼 cos휃 cos훼 cos휙

2.3.2.1 Ángulos de Euler

Para la representación de orientación en un espacio tridimensional mediante

una matriz de rotación es necesario definir nueve elementos. El ángulos de

Euler hacen únicamente uso de tres componentes para su descripción.

EC (2.10)

EC (2.11)


38

Todo sistema OUVW solidario al cuerpo cuya orientación se quiere describir,

puede definirse con respecto al sistema OXYZ mediante tres ángulos: Φ, ө, ⍦,

denominados ángulos de Euler. Girando sucesivamente el sistema OXYZ sobre

unos ejes determinados de un triedo ortonormal los valores de Φ, ө, ⍦, se

obtendrá el sistema OUVW. Es necesario, por tanto, conocer además de los

valores de los ángulos, cuáles son los ejes sobre los que se realizan los giros.

Existen diversas posibilidades (24 formalmente definidas), uno de los mas

usuales es:

2.3.2.1.1 Ángulos de Euler ZXZ

Es una de las representaciones más habituales entre las que realizan los giros

sobre ejes previamente girados. Se le suele asociar con los movimientos

básicos de un giróscopo. Si se parte de los sistemas OXYZ y OUVW,

inicialmente coincidentes, se puede colocar al sistema OUVW en cualquier

orientación siguiendo los siguientes pasos.

1. Girar el sistema OUVW un ángulo Φ con respecto al eje OZ,

convirtiéndose así en el OU’V’W’.

2. Girar el sistema OU’V’W’ un ángulo ө con respecto al eje OU’,

convirtiéndose así en el OU’’V’’W’’.

3. Girar el sistema OU’’V’’W’’ un ángulo ⍦ con respecto al eje OW’’

convirtiéndose finalmente en el OU’’’V’’’W’’’.


39

2.3.3 Coordenadas y matrices de transformación homogéneas:

La matriz de transformación homogénea permite la transformación de un vector

de coordenada homogénea de un sistema de coordenada a otro.

La representación mediante coordenadas homogéneas de la localización de

sólidos en un espacio n-dimensional se realiza a través de coordenadas de un

espacio (n+1)-dimensional. Es decir, un espacio n-dimensional se encuentra

representado en coordenadas homogéneas por (n+1) dimensiones, de tal forma

que un vector p(x,y,z) vendrá representado por p(wx,wy,wz,w), donde w tiene

un valor arbitrario y representa un factor de escala. De forma general, un vector

풑 = 푎풊 + 푏풋 + 푐풌, donde 풊, 풋,풌 son los vectores unitarios de los ejes OX, OY y

OZ del sistema de referencia OXYZ, se representa en coordenadas

homogéneas mediante el vector columna:

Figura 2.22 Ángulo de euler ZXZ Fuente [3]


40

푃 =

푥푦푧푤

=

푎푤푏푤푐푤푤

=

푎푏푐1

A partir de la definición de las coordenadas homogéneas surge inmediatamente

el concepto de matriz de transformación homogénea. Se define como matriz de

transformación homogénea T a una matriz de dimensión 4x4 que representa la

transformación de un vector de coordenadas homogéneas de un sistema de

coordenadas a otro.

푇 =푅 × 푃 ×푓 × 푤 ×

= 푅표푡푎푐푖ó푛 푇푟푎푠푙푎푐푖ó푛푃푒푟푠푝푒푐푡푖푣푎 퐸푠푐푎푙푎푑표

Se puede considerar que una matriz homogénea se haya compuesta por cuatro

submatrices de distinto tamaño: una submatriz R3x3 que corresponde a una

matriz de rotación; una submatriz p3x1 que corresponde al vector de traslación;

una submatriz f1x3 que representa una transformación de perspectiva y una

submatriz w1x1 que representa un escalado global. En robótica generalmente

sólo interesará conocer el valor de R3x3 y de p3x1, considerándose las

componentes de f1x3 nulas y la de w1x1 la unidad. Al tratarse de una matriz 4x4,

los vectores sobre los que se aplique deberán contar con dimensiones, que

serán las coordenadas homogéneas del vector tridimensional de que se trate.

EC (2.12)

EC (2.13)


41

2.3.3.1 Aplicación de las matrices homogéneas

Se considera la transformación de perspectiva nula y el escalado global unitario,

la matriz homogénea T resultará ser de la siguiente forma

푇 = 푅 × 푃 ×0 1 = 푅표푡푎푐푖ó푛 푇푟푎푠푙푎푐푖ó푛

0 1

Que representa la orientación y posición de un sistema O’UVW rotado y

trasladado con respecto al sistema de referencia OXYZ. Esta matriz sirve para

conocer las coordenadas (rx, ry, rz) del vector r en el sistema OXYZ a partir de

sus coordenadas (ru, rv, rw) en el sistema O’XYZ:

푟푟푟1

= 푇

푟푟푟1

También se puede utilizar para expresar la rotación y traslación de un vector

respecto de un sistema de referencia fijo OXYZ, de tal manera que un vector rxyz

rotado según R3x3 y trasladado según p3x1 se convierte en el vector r’xyz dado

por:

푟푟푟1

= 푇

푟푟푟1

EC (2.14)

EC (2.15)

EC (2.16)


42

2.3.3.1.1 Traslación

Supóngase que el sistema O’UVW únicamente se encuentra trasladado un

vector p = pxi + pyj + pzk con respecto al sistema OXYZ. La matriz T entonces

corresponderá a una matriz homogénea de traslación:

푇(푃) =

1 0 0 푃0 1 0 푃0 0 1 푃0 0 0 1

푟푟푟1

=

1 0 0 푃0 1 0 푃0 0 1 푃0 0 0 1

푟푟푟1

=

푟 + 푃푟 + 푃푟 + 푃

1

푟푟푟1

=

1 0 0 푃0 1 0 푃0 0 1 푃0 0 0 1

푟푟푟1

=

푟 + 푃푟 + 푃푟 + 푃

1

2.3.3.1.2 Rotación

Supóngase ahora que el sistema O’UVW sólo se encuentra rotado con respecto

al sistema OXYZ. La submatriz de rotación R3x3 será la que defina la rotación, y

se corresponde al tipo matriz de rotación presentada en el argumento de

matrices de rotación. De igual forma que se hacia allí, se pueden definir tres

matrices homogéneas básicas de rotación según se realice ésta según cada

uno de los tres ejes coordenados OX, OY y OZ del sistema de referencia OXYZ:

EC (2.17)


43

푇(푥,훼) =

1 0 0 00 cos훼 − sin훼 00 sin훼 cos훼 00 0 0 1

푇(푦,휙) =

cos휙 0 sin 휙 00 1 0 0

− sin 휙 0 cos휙 00 0 0 1

푇(푧, 휃) =

cos 휃 − sin 휃 0 0sin 휃 cos 휃 0 0

0 0 1 00 0 0 1

2.3.3.1.3 Traslación junto con rotación

La principal ventaja de las matrices homogénea reside en su capacidad de

representación conjunta de posición y orientación. Esta representación se

realiza utilizando al mismo tiempo la matriz de rotación R3x3 y el vector de

traslación p3x1 en una matriz de transformación homogénea. Es por tanto la

aplicación conjunta de lo visto en los dos apartados anteriores.

La traslación y la rotación son transformaciones que se realizan en relación a un

sistema de referencia. Por lo tanto, si se quiere expresar la posición y

orientación de un sistema O’UVW, originalmente coincidente con el de

referencia y que ha sido rotado y trasladado según éste, habrá que tener en

cuenta si primero se ha realizado la rotación y después la traslación o viceversa,

pues se trata de transformaciones espaciales no conmutativas. En la siguiente

figura se demuestra esta no conmutatividad de forma gráfica.

EC (2.18)


44

Distintos sistemas finales según el orden de las transformaciones

Se parte de un sistema OUVW coincidente con OXYZ al que se va a aplicar una

traslación según un vector px,y,z y una rotación de 180° alrededor del eje OZ. Si

primero se rota y después se traslada se obtiene un sistema final O’U’V’W’. En

cambio, si primero se traslada y después se rota se obtiene otro sistema final

O’’U’’V’’W’’, que representa una localización totalmente distinta a la del sistema

final anterior. Se tendrá, por tanto, matrices homogéneas distintas según se

realice una traslación seguida de rotación o una rotación seguida de traslación.

Fuente [3]

Figura 2.23 Distintos sistemas finales según el orden de las transformaciones

Fuente [3]

CAPÍTULO III CINEMÁTICA Y DINÁMICA DEL ROBOT INDUSTRIAL

45

3

CAPÍTULO III

CINEMÁTICA Y DINÁMICA DEL

ROBOT INDUSTRIAL


46

3.1 CINEMÁTICA DEL ROBOT

La cinemática del robot estudia el movimiento del robot con respecto a un

sistema de referencia. Así, la cinemática se interesa por la descripción analítica

del movimiento espacial del robot como una función del tiempo, y en particular

por las relaciones entre la posición y la orientación del extremo final del robot

con los valores que toman sus coordenadas articulares.

La cinemática del robot se puede clasificar en 2 ramas fundamentales, el

primero de ellos se conoce como cinemática directo, y consiste en determinar

cual es la posición y orientación del extremo final del robot, con respecto a un

sistema de coordenadas que se toma como referencia, conocidos los valores de

las articulaciones y los parámetros geométricos de los elementos del robot, el

segundo denominado cinemática inverso resuelve la configuración que debe

adoptar el robot para una posición y orientación del extremo conocidas.

3.1.1 Cinemática Directa

Se utiliza fundamentalmente el álgebra vectorial y matricial para representar y

describir la localización de un objeto en el espacio tridimensional con respecto a

un sistema de referencia fijo. Dado que un robot puede considerar como una

cadena cinemática formada por objetos rígidos o eslabones unidos entre sí

mediante articulaciones, se puede establecer un sistema de referencia fijo

situado en la base del robot y describir la localización de cada uno de los

eslabones con respecto a dicho sistema de referencia. De esta forma, el

problema cinemático directo se reduce a encontrar una matriz homogénea de

transformación T que relacione la posición y orientación del extremo del robot

respecto del sistema de referencia fijo situado en la base del mismo. Esta matriz

T será función de las coordenadas articulares.


47

La matriz de transformaciones homogenea T se puede obtener mediante:

푇 = 퐴 = 퐴 퐴 퐴 … 퐴

Donde 퐴 es la matriz de transformación homogénea que describe la

posición y orientación del eslabón n respecto al n-1.

La relación que existe entre dos elementos contiguos se puede hacer uso de

cualquier sistema de referencia ligado a cada elemento, la forma habitual que

se suele utilizar en robótica es la representación de Denavit-Hartenberg

Figura 3.1 Coordenadas del robot Yaskawa (Motoman) Fuente [5]

EC (3.1)


48

Según la representación D-H, escogiendo adecuadamente los sistemas de

coordenadas asociados para cada eslabón, será posible pasar de uno al

siguiente mediante 4 transformaciones básicas que dependen exclusivamente

de las características geométricas del eslabón.

Estas transformaciones básicas consisten en una sucesión de rotaciones y

traslaciones que permitan relacionar el sistema de referencia del elemento i con

el sistema del elemento i-1. Las transformaciones en cuestión son las siguientes:

1. Rotación alrededor del eje 푧 un ángulo 휃 .

2. Traslación a lo largo de 푧 una distancia 푑 ; vector 푑 (0,0,푑 ).

3. Traslación a lo largo de 푥 una distancia 푎 ; vector 푎 (푎 , 0,0).

4. Rotación alrededor del eje 푥 , un ángulo 훼 .

De este modo se tiene:

퐴 = 푇(푧,휃 )푇(0,0,푑 )푇(푎 , 0,0)푇(푥,훼 )

Realizando el producto de las matrices:

퐴 =

cos 휃푖 − cos훼 sin휃 sin훼 sin 휃 푎 cos 휃sin 휃 cos훼 cos휃 − sin 훼 cos휃 푎 sin휃

0 sin 훼 cos훼 푑0 0 0 1

Donde 휃 , 푎 , 푑 , 훼 , son los parámetros D-H del eslabón i. De este modo,

basta con identificar los parámetros 휃 , 푎 , 푑 , 훼 , para obtener matrices A y

relacionar así todos y cada uno de los eslabones del robot.

EC (3.2)

EC (3.3)


49

Tabla de Parámetros D-H para Robot Cilíndrica

Articulación 휽 풅 풂 휶 1 푞 푙 0 0 2 90 푑 0 90 3 0 푑 0 0 4 푞 푙 0 0

3.1.2 Cinemática Inversa

La cinemática inversa consiste en encontrar los valores que deben adoptar las

coordenadas articulares y los ángulos entre cada eje del robot para que su

extremo se posicione y oriente según una determinada localización espacial. La

cinemática inversa en diferencia de la cinemática directa, es que puede tener

múltiples soluciones. Por ejemplo en la grafica se puede observar que un brazo

Tabla 3.1 Tabla de parámetros D-H para robot cilíndrica Fuente [3]

Figura 3.2 Parámetros D-H robot cilíndrica Fuente [3]


50

de 3 articulaciones puede tener 2 configuraciones distinta para llegar al mismo

punto.

Para resolver problema de cinemática inversa, se puede aplicar métodos

geométricos o método mediante la matriz de transformación homogénea.

3.1.2.1 Resolucion de cinematica inversa mediante métodos geométricos.

Este procedimiento es adecuando para robots de pocos grado de libertad, ya

que a medida que aumenta el grado de libertad del robot las ecuaciones se

hacen muy complejas.

El procedimiento en si se basa en encontrar suficiente número de relaciones

geométricas en las que intervendrán las coordenadas del extremo del robot, sus

coordenadas articulares y las dimensiones físicas de sus elementos.

Figura 3.3 Problema cinemática con múltiples soluciones Fuente [5]


51

3.1.2.2 Resolución de cinemática inversa a partir de la matriz de transformación homogénea

La resolución de problema de cinemática inversa consiste principalmente en

obtener la matriz de transformación homogénea T mediante método de

Denavit-Hartenberg.

Puesto que:

푇 = 퐴 = 퐴 퐴 퐴 … 퐴

En un robot que tiene 3 grado de libertad seria:

푇 = 퐴 = 퐴 퐴 퐴

Multiplicando la T por la matriz inversa de 퐴 y luego por la matriz inversa de

퐴 el resultado sería:

퐴 푇 = 퐴 퐴

퐴 퐴 푇 = 퐴

La T es conocida, los miembros a la izquierda de la ecuación anterior son en

función de las variables articulares (푞 , … ,푞 ). Mientras que los miembros de la

derecha están en función de las variables articulares (푞 , … , 푞 ).

De este modo, de la expresión 퐴 푇 = 퐴 퐴 se tendrá 푞 aislado del

resto de las variables articulares. A su vez obtenida la 푞 , de la expresión

EC (3.4)

EC (3.5)

EC (3.6)


52

퐴 퐴 푇 = 퐴 permite tener el valor de 푞 aislado respecto de 푞 ,

por último, conocidos 푞 y 푞 se puede obtener 푞 sin mucha dificultad.

3.1.3 Matriz Jacobiana

El sistema de control del robot debe establecer a que velocidades debe imprimir

a cada articulación (a través de sus respectivos actuadores) para conseguir que

el extremo desarrolle una trayectoria temporal concreta, por ejemplo, una línea

recta a velocidad constante.

Para este y otros fines, es de gran utilidad disponer de la relación entre las

velocidades de las coordenadas articulares y las de posición y orientación del

extremo del robot. La relación entre ambos vectores de velocidad se obtiene a

través de la denominada matriz Jacobiana.

La matriz jacobiana directa permite conocer las velocidades del extremo del

robot a partir de los valores de las velocidades de cada articulación. Por su

parte, la matriz Jacobiana inversa permitirá conocer las velocidades

determinadas en el extremo del robot.

La matriz jacobiana 퐽 se puede expresar matemáticamente como:

Figura 3.4 Matriz jacobiana directa e inversa Fuente [3]


53

⎣⎢⎢⎢⎢⎡푥̇푦̇푧̇훼̇훽̇훾̇⎦⎥⎥⎥⎥⎤

= 퐽 ∙

⎣⎢⎢⎢⎢⎡푞 ̇⋮⋮⋮⋮푞 ̇ ⎦⎥⎥⎥⎥⎤

퐽 =

⎣⎢⎢⎡ ⋯⋮ ⋱ ⋮

⋯ ⎦⎥⎥⎤

Donde:

푥 = 푓 (푞 , … , 푞 )푥̇ =휕푓휕푞 푞̇

3.1.4 Matriz Jacobiana Inversa

Del mismo modo que se ha obtenido la relación directa que permite obtener las

velocidades del extremo a partir de las velocidades articulares, puede obtenerse

la relación inversa que permite calcular las velocidades articulares partiendo de

las del extremo.

⎣⎢⎢⎢⎢⎡푞̇⋮⋮⋮⋮푞 ̇ ⎦⎥⎥⎥⎥⎤

= 퐽 ∙

⎣⎢⎢⎢⎢⎡푥̇푦̇푧̇훼̇훽̇훾̇⎦⎥⎥⎥⎥⎤

3.1.5 Configuraciones singulares

Se denominan configuraciones singulares de un robot a aquellas en el que el

determinante de su matriz Jacobiana (Jacobiano) se anula. Por esta

circunstancia, en las configuraciones singulares no existe jacobiana inversa.

EC (3.7)

EC (3.8)

EC (3.9)


54

Al anularse el Jacobiano, un incremento infinitesimal de las coordenadas

cartesianas supondría un incremento infinito de las coordenadas articulares, lo

que en la práctica se traduce en que las inmediaciones de las configuraciones

singulares, el pretender que el extremo del robot se mueva a velocidad

constante, obligaría a movimientos de las articulaciones a velocidades

inabordables por sus actuadores.

Por ello, en las inmediaciones de las configuraciones singulares se pierde

alguno de los grados de libertad del robot, siendo imposible que su extremo se

mueva en una determinada dirección cartesiana.

Las diferentes configuraciones singulares del robot pueden ser clasificadas

como:

Singularidades en los límites del espacio de trabajo del robot. Se

presentan cuando el extremo del robot esta en algún punto del limite

de trabajo interior o exterior. En esta situación resulta obvio que el

robot no podrá desplazarse en las direcciones que lo alejan de este

espacio de trabajo.

Singularidades en el interior del espacio de trabajo del robot.

Ocurren dentro de la zona de trabajo y se producen generalmente por

el alineamiento de dos o más ejes de las articulaciones del robot.


55

3.2 CONTROL CINEMÁTICO

El control cinemático establece las trayectorias que debe seguir cada

articulación del robot para cumplir con los requerimientos del usuario. Dichas

trayectorias se seleccionaran dependiendo de las restricciones físicas propias

de los accionamientos y a criterios de calidad como suavidad o precisión de la

misma.

Funciones del control cinemático

Figura 3.5 Funciones del control cinemático Fuente [3]

CO

NTR

OL

CIN

EMÁ

TIC

O

GENERADOR DE

TRAYECTORIA

PROGRAMA

MUESTREO

CONTROL DINÁMICO

Velocidad y aceleración

máxima de la articulación

MODELO CINEMÁTICO

Punto de destino (푥, 푦, 푧,훼, 훽, 훾) Tipo de trayectoria Velocidad Precisión del punto final y de la trayectoria

Trayectorias articulares 푞 (푡)

Referencias para el control dinámico 푞 (퐾푇)


56

3.2.1 Funciones de control cinemático

El robot recibe como entradas los datos procedentes del programa del robot

escrito por el usuario, (punto de destino, precisión, tipo de trayectoria, deseada,

velocidad, etc.), luego establece la trayectoria para cada articulación como

funciones del tiempo.

De manera general, el control cinemático deberá realizar las siguientes

funciones:

a) Convertir la especificación del movimiento dada en el programa en una

trayectoria analítica en espacio cartesiano. (evolución de cada

coordenada cartesiana en función del tiempo)

b) Muestrear la trayectoria cartesiana obteniendo un número finito de

puntos de dicha trayectoria. Cada uno de estos puntos vendrá dada por

una 6-upla, típicamente (푥,푦, 푧,훼,훽, 훾) .

c) Utilizando la trasformación homogénea inversa, convertir cada uno de

estos puntos en sus correspondientes coordenadas articulares

( 푞 , 푞 , 푞 , 푞 ,푞 , 푞 ). Debe tenerse en cuenta aquí la posibilidad de tener

múltiple solución en la transformación homogénea inversa, así como la

posibilidad de ausencia de solución y puntos singulares, de modo que se

asegure la continuidad de la trayectoria.

d) Interpolación de los puntos articulares obtenidos, generando para cada

variable articular una expresión 푞 (푡) que pase o se aproxime a ellos de

modo que, siendo una trayectoria realizable por los actuadores, se

transforme en una trayectoria cartesiana lo más próxima a la

especificada por el programa del usuario.


57

e) Muestreo de la trayectoria articular para generar referencias al control

dinámico.

Gráfica de funciones del control cinemático

En la Figura 3.6 muestra un posible caso en el que se pretende que un robot de

2 grados de libertad se mueva en línea recta desde el punto

푗 = (푥 ,푦 ) hasta el punto 푗 = (푥 ,푦 ) (Fig. 3.6 a). El control cinemático

selecciona 4 puntos de esta trayectoria 푗 푗 푗 푗 (Fig. 3.6 b) y mediante la

transformación homogénea inversa obtiene los correspondientes vectores

Figura 3.6 Gráfica de funciones del control cinemático Fuente [3]


58

articulares 푞 푞 푞 푞 (Fig. 3.6 c) donde demuestra la relación que debe tener la

primera articulación 푞 y la segunda articulación 푞 para que en su extremo

pase por los puntos de la trayectoria trayectoria 푗 푗 푗 푗 . A continuación trata

de unir estos 4 puntos 푞 푞 푞 푞 con algún tipo de función que pasando por

todos ellos garantice la suavidad y no supere las velocidades y aceleraciones

máximas permisibles para cada accionador (Fig. 3.6 d). El resultado final del

movimiento del extremo del robot es una trayectoria que se aproxima en mayor

o menor medida a la línea recta deseada. (Fig. 3.6 e)

3.2.2 Tipos de trayectorias

El robot para realizar una tarea determinada, debe moverse, este movimiento el

cual pude ser realizado según infinitas trayectorias espaciales. La selección de

la trayectoria a seguir va a depender de la sencillez de implementación, su

utilidad y aplicación a diversas tareas. De este modo, puede encontrarse que

los robots dispongan de trayectorias punto a punto, coordinadas y continúas.


59

a) Movimiento eje a eje. b) Movimiento simultáneo de ejes. c) Trayectoria coordinada d) Trayectoria continua rectilínea.

3.2.2.1 Trayectoria punto a punto

En este tipo de trayectoria cada articulación evoluciona desde su posición inicial

a la final sin considerar el estado o evolución de las demás articulaciones.

Normalmente, cada actuador trata de llevar a su articulación al punto de

destino en el menor tiempo posible, pudiéndose distinguir dos casos:

Figura 3.7 Diferentes trayectorias articulares posibles para un robot de 2 GDL

Fuente [3]


60

Movimiento eje a eje: En este movimiento comenzará a moverse la

primera articulación, y una vez que ésta haya alcanzado su punto final lo

hará la segunda, y así sucesivamente. Este tipo de movimiento da

obviamente como resultado un mayor tiempo de ciclo, teniendo como

única ventaja un menor consumo de potencia instantánea por parte de

los actuadores.

Movimientos simultáneos de ejes: En este caso todos los actuadores

comienzan simultáneamente a mover las articulaciones del robot a una

velocidad específica para cada una de ellas. Dado que la distancia a

recorres y las velocidades serán en general diferentes, cada una acabará

su movimiento en un instante diferente; Sin embargo el movimiento del

robot no acabará hasta que alcance su punto final, lo cual producirá

cuando el eje más tarde concluya su movimiento. De esta manera, el

tiempo total invertido en el movimiento coincidirá cuando el eje que más

tarde emplee en realizar su movimiento particular, pudiéndose dar la

circunstancia de que el resto de los actuadores hayan forzado su

movimiento a una velocidad y aceleración elevada, viéndose obligados

finalmente a esperar a la articulación más lenta.

La trayectorias punto a punto no están implementadas salo en robot muy

simples o con unidades de control muy limitadas.

3.2.2.2 Trayectorias coordinadas o isócronas

Para evitar que algunos actuadotes trabajen forzando sus velocidades y

aceleraciones, teniendo que esperar después la conclusión de movimiento de la

articulación más lenta, puede hacerse un cálculo previo, averiguando cuál es

esta articulación más lenta y que tiempo invertirá. Se ralentizará entonces el

movimiento del resto de los ejes para que inviertan el mismo tiempo en su

movimiento, acabando todos ellos simultáneamente. Se tiene así que todas


61

articulaciones se coordinan comenzando y acabando su movimiento a la vez,

adaptándose todas a la más lenta.

El tiempo total invertido en el movimiento es el menor posible y no se piden

aceleraciones y velocidades elevadas a los actuadores de manera útil. Desde el

punto de vista del usuario la trayectoria que describe el extremo del robot no es

significativa, siendo ésta impredecible aunque como es obvio, un conocimiento

del modelo y control cinemático del robot permitirá su cálculo.

3.2.2.3 Trayectorias continuas

Cada articulación sigue un movimiento aparentemente caótico con posibles

cambios de dirección y velocidad y sin coordinación con el resto de las

articulaciones. Sin embargo, el resultado conjunto será que el extremo del robot

describirá la trayectoria deseada.


62

3.3 DINÁMICA DEL ROBOT

La dinámica se ocupa de la relación entre las fuerzas que actúan sobre un

cuerpo y el movimiento que en el se origina. Por lo tanto, el modelo dinámico de

un robot tiene por objeto conocer la relación entre el movimiento del robot y las

fuerzas implicadas en el mismo.

Esta relación se obtiene mediante el denominado modelo dinámico, que

relaciona matemáticamente:

La localización del robot definida por sus variables articulares o por las

coordenadas de localización de su extremo, y sus derivadas: velocidad y

aceleración.

Las fuerzas pares aplicados en las articulaciones (o en el extremo del

robot).

Los parámetros dimensiónales del robot, como longitud, masa e inercias

de sus elementos.

Figura 3.8 Dinámica de un robot Fuente [3]


63

3.4 CONTROL DINÁMICO

El Control dinámico tiene por misión procurar que las trayectorias realmente

seguidas por el robot 푞(푡)sean lo más parecidas posibles a las propuestas por

el control cinemática 푞 (푡) .Para ello hace uso del conocimiento del modelo

dinámico del robot.

El modelo dinámico de un robot es no lineal, multivariable, acoplado y de

parámetros variantes, por lo que en general su control es extremadamente

complejo. En la práctica ciertas simplificaciones, válidas para un gran número

de los robots comerciales existentes facilitan el diseño del sistema de control,

dado unos resultados razonablemente aceptables, aunque limitando ciertas

situaciones la calidad de sus prestaciones.

Normalmente el control dinámico se realiza en el espacio articular, esto es,

controlando las trayectorias articulares 푞(푡) del robot. Sin embargo, en ciertas

ocasiones, como por ejemplo cuando el robot entra en contacto con el entorno

desarrollando fuerzas de reacción, puede optarse por realizar el control en el

espacio de la tarea o cartesiano, controlando la trayectoria del extremo 푗(푡).

Las técnicas de control usadas serán basadas en control PID y control por

realimentación, ampliamente extendidas, utilizándose también en ocasiones la

linealización por inversión del modelo. Se realizará asimismo alguna referencia

a técnicas de control más potentes, como puede ser el control adaptativo.

En el presente trabajo no se detallara a fondo la dinámica y el control dinámico

del robot porque se enfoque principal es la cinemática y el control cinemático

del robot industrial.

Fuente [3]

CAPÍTULO IV ANÁLISIS DEL PROBLEMA

64

4

CAPÍTULO IV

ANÁLISIS DEL PROBLEMA


65

4.1 INTRODUCCIÓN

La Universidad Privada de Santa Cruz de la Sierra UPSA adquirió un Robot

Industrial (Motoman K3S) al mediado del año 2005 gracias al convenio con la

Universidad de Suecia. El motoman K3S cuenta con un controlador ERC cuyo

sistema de control es muy anticuado y su interfaz de usuario es poco intuitivo.

Ya que este robot pertenece a la segunda generación (1991) de la línea

MOTOMAN, actualmente (2010) se encuentra en la sexta generación. Por esta

razón surge la idea de mejorar y perfeccionar el control del robot mediante el

presente trabajo.

4.2 ROBOT INDUSTRIAL MOTOMAN K3S

El Motoman K3S es un robot industrial compacto con seis ejes de articulación y

una capacidad de carga de 3 kg. Cuenta con un tamaño reducido y puede

mover hasta una velocidad de 2,5 m/s. por su tamaño compacto puede ser

montado fácilmente en el suelo, techo o pared. Las aplicaciones estándares del

Motoman K3S son: soldadura de arco, montaje y manipulación de materiales.

Figura 4.1 Motoman K3S Fuente [6]


66

4.3 SITUACIÓN ACTUAL

En el laboratorio de Robótica de la Universidad Privada de Santa Cruz de la

Sierra se cuenta con un Robot Industrial Motoman K3S, el robot industrial posee

un controlador ERC constituido por un armario que resguarda los circuitos de

control y de potencia, un monitor monocromo y un teachpanel. El controlador

ERC es de gran tamaño y peso, cuenta con una arquitectura cerrado y su

interfaz de usuario es poco intuitivo.

TeachPanel y Controlador ERC para Robot Industrial Motoman K3S

Para poder programar el robot industrial se tiene que hacerlo paso por paso, en

el cual consiste en usar el teachpedant para posicionar cada articulación del

robot en ubicaciones especificas y grabar esa posición introduciendo datos

Figura 4.2 TeachPanel y Controlador ERC para Robot Industrial Motoman K3S

Fuente [7]


67

como la velocidad y el tipo de movimiento, una vez grabada la posición se tiene

que ir al siguiente posición deseada y grabarlo, así sucesivamente.

A lo largo de los años hasta la fecha (2010) en la Universidad Privada de Santa

Cruz de la Sierra (UPSA) se tuvo 2 trabajos finales de grados relacionado con el

robot industrial Motoman K3S, estas son: [11] y [12] gracias a estos trabajos se

aporto conocimiento a lo que es robótica industrial y el método de

comunicación que existe entre la PC y el Robot Industrial Motoman K3S.

4.4 RELEVAMIENTO DE REQUERIMIENTO

Como el controlador ERC que posee actualmente el Motoman K3S es de

arquitectura cerrada y presenta una interfaz poco amigable. Se identificó la

necesidad de crear otro controlador de arquitectura abierta con una interfaz de

usuario mucho más avanzado y dinámica mejorando el controlador ERC, donde

permite visualización y simulación 3D en tiempo real, y que tenga la opción de

implementar nuevas aplicaciones como el CNC y CAM sobre el sistema base.

4.5 ANÁLISIS DE REQUERIMIENTOS

Mediante los estudios y las investigaciones realizadas se vio la posibilidad de

implementar un sistema de control cinemático de arquitectura abierta

programado en matlab, que nos permite hacer simulaciones 3D y visualizar el

movimiento del robot en tiempo real a través de un diseño CAD 3D. También se

podría implementar el mando de control usando un joystick. Como el diseño del

controlador cinemático es de arquitectura abierta se podrá implementar una

variedad de aplicaciones basando en el sistema base del control cinemático que

se va realizar en este proyecto.


68

4.6 VISIÓN DEL PROYECTO

La visión del proyecto es crear un sistema que puede ser adaptado a cualquier

robot industrial, debido a que el control cinemático es una parte de robótica que

se encarga de generar matemáticamente los movimientos del robot sin

considerar lo que hace que el robot o los motores que presenta el robot se

muevan físicamente (Control Dinámico). También implementar aplicaciones

sobre el sistema base de control cinemático como la visión artificial y Control

numérico CNC empleando el Robot Industrial.

4.7 ALCANCE DEL TRABAJO

Para poder aplicar el control cinemático se realizará todo el sistema de control

en matlab 2009 con la ayuda de robotics toolbox, simulink 3D animation, y el

diseño del modelo CAD 3D del robot se realizará en solidworks 2010.

La comunicación del control cinemático con el robot se realizará mediante bus

de comunicación RS232 con los comandos o protocolos proporcionado por

Motoman Inc. y físicamente serán conectados del PC al Controlador ERC del

Motoman K3S mediante un cable DB9 – DB25.

Cabe destacar que el control cinemático que se va desarrollar puede

comunicarse o conectarse con distintas opciones de control dinámico (lo que

hace mover el motor del robot), estas pueden ser los servodrives o servopack

que se encuentran comercialmente disponible para controlar los servomotores

trifásicos que poseen el robot. Y la otra opción que seria lo ideal poder conectar

con el “controlador dinámico” [13] en la cual se está desarrollando

paralelamente con este trabajo.


69

4.8 REQUERIMIENTOS DE EQUIPOS

Los equipos o requerimientos necesarios para la realización de este trabajo

serian los siguientes:

Robot Industrial Motoman K3S

Controlador ERC con puerto RS232

Cable de Comunicación RS232 DB9-DB25

Cable de Comunicación USB-SERIAL

Joystick USB compatible con Windows

Computadora de Escritorio o Laptop

o Matlab 2009

o Sistema Operativo Windows

4.9 DETALLE DE COSTOS

A continuación se detallara los precios de los distintos equipos y componentes

necesarios para la realización de este trabajo.

ITEM DESCRIPCION UNIDAD CANTIDAD PRECIO

UNITARIO ($US)

PRECIO TOTAL ($US)

1 Robot Industrial Motoman K3S con su Controlador ERC PZA 1 45000 45000

2 Cable de Comunicación RS232 DB9-DB25 PZA 1 10 10 3 Cable de Comunicación USB-SERIAL PZA 1 30 30 4 Joystick USB PZA 1 20 20

5 Computadora de Escritorio o Laptop con Windows PZA 1 1000 1000

6 Licencia Matlab 2009 PZA 1 2000 2000 7 Licencia Matlab Simulink 2009 PZA 1 3000 3000 8 Licencia Simulink 3D Animation 2009 PZA 1 1000 1000

TOTAL 52060

Tabla 4.1 Tabla de Equipos y Componentes Fuente [EP]


70

Los equipos o componentes que realmente se deberían adquirir para el

desarrollo del presente trabajo son los siguientes:

ITEM DESCRIPCION UNIDAD CANTIDAD PRECIO

UNITARIO ($US)

PRECIO TOTAL ($US)

1 Cable de Comunicación RS232 DB9-DB25 PZA 1 10 10 2 Cable de Comunicación USB-SERIAL PZA 1 30 30 3 Joystick USB PZA 1 20 20

Computadora de Escritorio o Laptop con Windows PZA 1 1000 1000

6 Licencia Matlab 2009 PZA 1 2000 2000 7 Licencia Matlab Simulink 2009 PZA 1 3000 3000 8 Licencia Simulink 3D Animation 2009 PZA 1 1000 1000

TOTAL 7060

4.10 ANÁLISIS BENEFICIOS ESPERADO

Los beneficios esperados al implementar el proyecto son:

Facilita el manipuleo del robot industrial mediante joystick

Mejora la interfaz del usuario ya que cuenta con una interfaz 3D

Animaciones y simulaciones 3D

Movimiento del Robot en tiempo real con animación 3D

Sistema abierto que permite implementar nuevas aplicaciones por

ejemplo: CNC, CAM

Desarrolla y promueve la Robótica Industrial

Tabla 4.2 Tabla de Equipos y Componentes que Se deberían adquirir

Fuente [EP]


71

4.11 ANÁLISIS DE RIESGOS

Ocurrencia: Es la probabilidad de que puedan ocurrir el riesgo. (0% - 100%) (Valor subjetivo)

Incidencia: Cuando se produce el evento (riesgo), la incidencia indica como afecta ese evento al desarrollo del trabajo

(Baja – Media – Alta) (valor subjetivo)

N RIESGO OCURRENCIA INCIDENCIA PREVISION CONTROL ALTERNATIVA

1 Daño del controlador ERC 30% Alta

No Permitir el manipuleo del Robot a persona no autorizado

Revisar y Hacer Mantenimiento Constantemente

Reparar o cambiar la pieza dañada

2

Daño Servomotores del Robot 30% Media

No Permitir el manipuleo del Robot a persona no autorizado y ubicar el robot lejos de materiales que puedan estorbar al movimiento del robot

Revisar bien las conexiones y quitar los obstaculos que esten cerca del robot antes de hacerlo funcionar

Reparar o cambiar el servomotor

3

Sistema de comunicación patentado y cerrado del Motoman 40% Alta

Revisar anticipadamente la Documentacion y Poner en contacto con Motoman Inc

Probar con los protocolos proporcionado antes utilizarlo en el proyecto

Solicitar mas informacion al fabricante

4

Accidente personal causado por el golpe del robot 20% Media

Tomar todas las medidas de seguridad antes de trabajar con el robot

Mantener distancia considerar al momento de que el robot esta en funcionamiento

Trabajar con el robot remotamente

5 Falta de Tiempo 15% Media Disponer Cronograma de actividades

Cumplir con el cronograma fijado

Trabajar más para recuperar el tiempo perdido

6 Daño del 20% Baja No permitir el uso de la Hacer mantenimiento Conseguir otra


72

computador computadora a persona no autorizado

constante computadora

7

Perdida de información en la computadora 25% Media

Hacer 2 copias en distintos lugares hacer backup constantemente

Recuperar archivo del disco duro o hacerlo de nuevo

8

Daño del controlador ERC por sobretencion 30% Alta

Colocar circuito de protección contra sobretensión

Medir constantemente el voltaje que alimenta el ERC

Recuperar archivo del disco duro o hacerlo de nuevo

CAPÍTULO V DISEÑO

73

5

CAPÍTULO V

DISEÑO

CAPÍTULO V DISEÑO

74

5.1 PLANTEAMIENTO GLOBAL DE LA SOLUCIÓN

El Sistema de control cinemático usa matlab y simulink (herramienta de matlab)

para el control de joystick y la creación de Realidad Virtual. La comunicación del

sistema de control cinematico con el control dinámico (control de servomotores,

parte de potencia) presentan las siguientes opciones:

1. Con el controlador ERC del motoman K3S mediante el protocolo Rs232,

reutilizando la parte de potencia del ERC.

Joystick

Realidad Virtual

Figura 5.1 Diagrama de Bloque General Fuente [EP]

CAPÍTULO V DISEÑO

75

2. Con el controlador dinámico que está desarrollando [13] paralelamente,

la comunicación puede ser mediante pwm, Ethernet o o usb.

3. Con cualquier controlador de servomotor trifásico existente en el

mercado. La comunicación va depender del fabricante.

En este trabajo se enfoca a la opción 1. (Comunicación mediante Rs232 con el

controlador ERC utilizando su parte de potencia y control dinámico). Debido a

que este es la única opción que se cuenta en el laboratorio de la UPSA. Pero el

proyecto en si puede ser fácilmente adaptado a las otras opciones.

5.2 DIAGRAMA DE BLOQUES DEL SISTEMA DE CONTROL CINEMÁTICO

Figura 5.2 Diagrama de Bloque Sistema de Control Cinemático (Matlab)

Fuente [EP]

Joystick USB

ERC

Sistema de Control Cinemático (Matlab)

Comunicación Rs232 ERC

(protocolo Motoman)

Cálculos

matemáticos

(Robotic Toolbox

Cinemática)

Realidad

Virtual (VRML)

Simulink

Controlador

Joystick

Diseño Mecánico

SolidWork

Modelo Matemático de

Motoman K3S

(Parámetros D-H)

GUI (Interfaz gráfica del usuario)

Grafico 3D

Trayectorias del

robot

Simulaciones 3D

Control Remoto

Tiempo Real

CAPÍTULO V DISEÑO

76

El sistema de control cinemático está constituido por varias partes o bloques

interconectados entre sí. El bloque de realidad virtual usa el diseño mecánico

3D del Motoman K3S creado con solidworks, además está interconectado con

el controlador del joystick que permite mover el robot virtual 3D directamente

desde el mando joystick. El bloque central es el de cálculo matemáticos, este

bloque se encuentra interconectado con varios bloques como el bloque

simulink, bloque de comunicación y el bloque de GUI (Interfaz grafica del

usario). El bloque de cálculo matemático es el cerebro del sistema de control

cinemático. Para que este bloque pueda hacer cálculos de cinematica directa e

inversa se necesitará primero conocer el modelo matemático cinemático del

robot Motoman K3S. El modelo cinemático es también conocido como los

parámetros de Denavit-Hartenberg.

5.3 DESCRIPCIÓN DE LOS BLOQUES

5.3.1 Bloque GUI (Interfaz Gráfica del Usuario)

Figura 5.3 Interfaz Gráfica del Usuario Fuente [EP]

CAPÍTULO V DISEÑO

77

El GUI (Interfaz gráfica del Usuario) es el bloque que interactua con el usuario y

está formado por distintos modulos. Estas son: Gráfico 3D, Simulaciones 3D,

Tiempo Real y Control Remoto.

5.3.1.1 Gráfico 3D

El Módulo de gráfico 3D muestra la posición angular de cada eje de articulación

del robot, también nos permite visualizar la posición del extremo del robot en

coordenada XYZ. Además traza toda la trayectoria que transita el robot en

Gráfico 3D (XYZ) y 2D (eje XY y eje XZ) tanto en la simulación como en tiempo

real.

5.3.1.2 Simulaciones 3D

Permite hacer simulaciones 3D utilizando el joystick para controlar los 6 ejes de

Figura 5.4 Gráficos 3D Fuente [EP]

CAPÍTULO V DISEÑO

78

articulación del robot. También permite hacer simulación de movimiento lineal,

donde se coordina los 6 motores de robot para trazar en su punto final una línea

recta, manteniendo la orientación del último eje.

5.3.1.3 Tiempo Real

Permite mover el robot industrial Motoman K3S en tiempo real con el joystick.

5.3.1.4 Control Remoto

Cumple la función de encender y apagar remotamente los sermomotores del

robot industrial Motoman K3S, también permite mover el robot hacia una

posición específica con distinta velocidades. El control remoto utiliza el bloque

de comunicación (5.3.4.) que tiena la función de comunicar con el controlador

ERC mandandole los comandos necesarios para la ejecución de las tareas

asignadas.

Figura 5.5 Simulación 3D y Tiempo Real Fuente [EP]

CAPÍTULO V DISEÑO

79

5.3.2 Bloque del modelo matemático

El Bloque del Modelo Matemático suministra el modelo cinemático del robot

motoman K3S al bloque de cálculos matemáticos para que esta pueda

completar su función. El modelo matemático para Motoman K3S se obtiene con

el algoritmo de Denavit – Hartenberg (3.1.1.) de la siguiente forma:

Figura 5.6 Control Remoto Fuente [EP]

Figura 5.7 Medidas del Motoman K3S Fuente [10]

CAPÍTULO V DISEÑO

80

DH1.Numerar los eslabones comenzando con 1 (primer eslabón móvil dela

cadena) y acabando con n (ultimo eslabón móvil). Se numerara como eslabón 0

a la base fija del robot.

0

1

2

3

4

5

6

0 Eslabon 0

Figura 5.8 Algoritmo Denavit – Hartenberg 1 Motoman K3S Fuente [EP]

CAPÍTULO V DISEÑO

81

DH2.Numerar cada articulación comenzando por 1 (la correspondiente al primer

grado de libertad y acabando en n).

0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6


CAPÍTULO V DISEÑO

82

DH3.Localizar el eje de cada articulación. Si esta es rotativa, el eje será su

propio eje de giro. Si es prismática, será el eje a lo largo del cual se produce el

desplazamiento.

0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6


CAPÍTULO V DISEÑO

83

DH4.Para i de 0 a n-1, situar el eje Zi, sobre el eje de la articulación i+1.

0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5


CAPÍTULO V DISEÑO

84

DH5.Situar el origen del sistema de la base (S0) en cualquier punto del eje Z0.

Los ejes X0 e Y0 se situaran dé modo que formen un sistema dextrógiro con

Z0.

0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

X0

Y0


CAPÍTULO V DISEÑO

85

DH6.Para i de 1 a n-1, situar el sistema (Si) (solidario al eslabón i) en la

intersección del eje Zi con la línea normal común a Zi-1 y Zi. Si ambos ejes se

cortasen se situaría (Si) en el punto de corte. Si fuesen paralelos (Si) se situaría

en la articulación i+1.

0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

Z3

X0

Y0

Linea Normal Comun

N 0 1 Normal Comun Z0 y Z1

N 0 1N 2 3

N 3 4

N 4 5

Z5

Eje de Articulacion


CAPÍTULO V DISEÑO

86

DH7.Situar Xi en la línea normal común a Zi-1 y Zi.

0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

Z3

X0

Y0

Linea Normal Comun


N 0 1N 2 3

N 3 4

N 4 5

Z5

Eje de Articulacion

X1X2X3

X4

X5


CAPÍTULO V DISEÑO

87

DH8.Situar Yi de modo que forme un sistema dextrógiro con Xi y Zi.

0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

Z3

X0

Y0

Linea Normal Comun


N 0 1N 2 3

N 3 4

N 4 5

Z5

Eje de Articulacion

X1X2X3

X4

X5

Y1Y2

Y3

Y4 Y5


CAPÍTULO V DISEÑO

88

DH9.Situar el sistema (Sn) en el extremo del robot de modo que Zn coincida

con la dirección de Zn-1 y Xn sea normal a Zn-1 y Zn.

0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

Z3

X0

Y0

Linea Normal Comun


N 0 1N 2 3

N 3 4

N 4 5

Z5

Eje de Articulacion

X1X2X3

X4

X5

Y1Y2

Y3

Y4 Y5

Z6

X6

Y6


CAPÍTULO V DISEÑO

89

DH10.Obtener Øi como el ángulo que hay que girar en torno a Zi-1 para que Xi-

1 y Xi queden paralelos.


0

1

2

3

4

5

60 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

Z3

X0

Y0

Linea Normal Comun


N 0 1N 2 3

N 3 4

N 4 5

Z5

Eje de Articulacion

X1X2X3

X4

X5

Y1Y2

Y3

Y4 Y5

Z6

X6

Y6

Parametro D-H Motoman K3S [HUANG] V1Articulacion theta [°] d [cm] a [cm] alfa [°]

1 02 03 04 05 90°6 0

Z4'

X4'

Y4'

90°

DH 10

CAPÍTULO V DISEÑO

90

DH11.Obtener Di como la distancia, medida a lo largo de Zi-1, que habría que

desplazar (Si-1) para que Xi y Xi-1 quedasen alineados.


0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

Z3

X0

Y0

Linea Normal Comun


N 0 1N 2 3

N 3 4

N 4 5

Z5

Eje de Articulacion

X1X2X3

X4

X5

Y1Y2

Y3

Y4 Y5

Z6

X6

Y6


1 0 d12 0 03 0 04 0 d25 90° 06 0 d3

Z4'

X4'

Y4'

d1

d2

d390°

DH 11

CAPÍTULO V DISEÑO

91

DH12.Obtener Ai como la distancia medida a lo largo de Xi (que ahora

coincidiría con Xi-1) que habría que desplazar el nuevo (Si-1) para que su

origen coincidiese con (Si).


0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

Z3

X0

Y0

Linea Normal Comun


N 0 1N 2 3

N 3 4

N 4 5

Z5Eje de Articulacion

X1X2X3

X4

X5

Y1Y2

Y3

Y4 Y5

Z6

X6

Y6


1 0 d1 a12 0 0 -a23 0 0 -a34 0 d2 05 90° 0 06 0 d3 0

Z4'

X4'

Y4'

d1

d2

d3

a1

a2Distancia

a3

90°

DH 12

CAPÍTULO V DISEÑO

92

DH13.Obtener ai como el ángulo que habría que girar entorno a Xi (que ahora

coincidiría con Xi-1), para que el nuevo (Si-1) coincidiese totalmente con (Si).


0

1

2

3

4

5

6

0 Eslabon 0

A1 Articulacion 1

A1

A2A3

A4

A5

A6

Z0

Z1Z2

Z3

Z4

Z5

Z3

X0

Y0

Linea Normal Comun


N 0 1N 2 3

N 3 4

N 4 5

Z5Eje de Articulacion

X1X2X3

X4

X5

Y1Y2

Y3

Y4 Y5

Z6

X6

Y6


1 0 d1 a1 -90°2 0 0 -a2 0°3 0 0 -a3 90°4 0 d2 0 -90°5 90° 0 0 90°6 0 d3 0 0°

Z4'

X4'

Y4'

d1

d2

d3

a1

a2Distancia

a3

-90°

90°

-90°

90°

90°

DH 13

CAPÍTULO V DISEÑO

93

Reemplazando el valor de a1, a2, a3, d1, d2, d3 de la fig. 5.7. Se obtiene la

siguente tabla de parámetros D-H.

DH14.Obtener las matrices de transformación i-1Ai.

DH15.Obtener la matriz de transformación que relaciona el sistema de la base

con el del extremo del robot T = 0A1, 1A2... n-1An.

DH16.La matriz T define la orientación (submatriz de rotación) y posición

(submatriz de traslación) del extremo referido ala base en función de las n

coordenadas articulares.

La matriz T (Matriz de Transformación homogénea) (DH14, DH15, DH16) se

pudo obtener mediante la ayuda de robotic toolboox de matlab de la siguiente

forma:


1 0 36.9 15 -902 0 0 -27 03 0 0 -8.5 904 0 44 0 -905 90 0 0 906 0 7.5 0 0

Figura 5.21 Parametros Denavit – Hartenberg Motoman K3S Fuente [EP]

CAPÍTULO V DISEÑO

94

Primero con los parámetros de Denavit – Hartenberg se procede a la creción de

la estructura del robot usando la función “link” y la función “robot” del robotic

toolbox.

La función link recibe como parámetros de entradas el parámetro D-H de una

articulación específica.

link( alpha A theta D 0=Rotacional/1=Prismatico offset, ‘standard’/ ‘modified’) y retorna un objetivo de tipo link donde guarda toda la información referente al

eslabon del robot.

La función robot recibe como parámetro de entrada el vector de objetos link y

retorna un objeto de tipo robot que es la base para los cálculos cinematicos.

%parametro DH c{1}=link([-pi/2 150 0 369 0],'standard') c{2}=link([0 -270 0 0 0],'standard') c{3}=link([pi/2 -85 0 0 0],'standard') c{4}=link([-pi/2 0 0 440 0],'standard') c{5}=link([pi/2 0 pi/2 0 0 pi/2],'standard') c{6}=link([0 0 0 75 0],'standard') global motoman_k3s; motoman_k3s=robot(c); motoman_k3s.name='Motoman K3S'; En el eslabon c(5) se inserto un offset de pi/2 debido a que la funcion link no

toma en cuenta la theta cuando la articulación es de tipo rotacional.( zero-angle

pose) Fuente: [14]

c{5}=link([pi/2 0 pi/2 0 0 pi/2],'standard')

CAPÍTULO V DISEÑO

95

Despues de ejecutar el código anterior, el objeto motoman_k3s de tipo robot

que contiene todo el modelo matematico del robot industrial Motoman K3S.

Motoman K3S (6 axis, RRRRRR) grav = [0.00 0.00 9.81] standard D&H parameters alpha A theta D R/P -1.570796 150.000000 0.000000 369.000000 R (std) 0.000000 -270.000000 0.000000 0.000000 R (std) 1.570796 -85.000000 0.000000 0.000000 R (std) -1.570796 0.000000 0.000000 440.000000 R (std) 1.570796 0.000000 1.570796 0.000000 R (std) 0.000000 0.000000 0.000000 75.000000 R (std)

Para obtener la matriz de transformación homogénea T se utiliza la funcion

fkine que recibe como parámetros de entrada un objeto de tipo robot y el ángulo

de giro de cada eje de articulación.

T=fkine(motoman_k3s,[0 0 0 0 0 0]) T = 0.0000 -0.0000 1.0000 -130.0000 0.0000 1.0000 0.0000 0.0000 -1.0000 0.0000 0.0000 809.0000 0 0 0 1.0000

Para verificar visualmente (Comprobando con la fig. 5.20) que el modelo

cinemático del robot industrial Motoman K3S obtenido con el algoritmo de D-H

sea la correcta Se emplea la función “drivebot” que genera graficos de las

articulaciones del objeto de tipo robot y también nos permite mover las

articulaciones.

drivebot(motoman_k3s)

CAPÍTULO V DISEÑO

96

Figura 5.22 Modelo Cinemático del Motoman K3S visualizado en drivebot

Fuente [EP]

CAPÍTULO V DISEÑO

97

5.3.3 Bloque de cálculo matemático

Este bloque calcula toda la cinemática directa y la cinemática inversa utilizando

robotic toolbox en matlab. Para que puedan realizar los cálculos se necesita

primero conocer el modelo cinemático del robot (Modelo de Denavit -

Hartenberg)(3.1.1.).

5.3.3.1 Cinemática Directa

La cinemática directa calcula la posición y la orientación del extremo del robot

respecto al sistema de referencia fijo situado en la base del robot. A partir de los

ángulos de cada eje de articulación.

La función para obtener la matriz de transformación homogénea en robotic

toolbox del matlab es el fkine. En el cual se introduce dos parámetros de

entrada, el modelo cinemático del robot, y el ángulo de cada eje del robot. La

función fkine nos devuelve la matriz de transformación homogénea que nos

indica la posición y la orientación del extremo del robot.

T=fkine(motoman_k3s,[num_s num_l num_u num_r num_b num_t]);

5.3.3.2 Cinemática Inversa

La cinemática inversa consiste en encontrar los valores que deben adoptar las

coordenadas articulares y los ángulos entre cada eje del robot para que su

extremo se posicione y oriente según una determinada localización espacial.

La función para obtener los ángulos que deben formar cada eje del robot es el

ikine. En el cual se introduce tres parámetros de entrada, el modelo cinemático

del robot, la trayectoria del robot (extremo), y el ángulo inicial del robot

CAPÍTULO V DISEÑO

98

(opcional). La función ikine nos devuelve una serie de vectores con los ángulos

de cada eje de articulación.

angulos=ikine(motoman_k3s,ruta,[m_s m_l m_u m_r m_b m_t]');

5.3.4 Bloque de comunicación

En este bloque envían los angulos de cada eje de articulación generado por el

cálculo matemático al controlador ERC del Motoman K3S usando la función

MOVJ.

Figura 5.23 Trama de comunicación ERC Fuente [8]

CAPÍTULO V DISEÑO

99

Figura 5.24 Protocolo de comunicación ERC Fuente [8]

CAPÍTULO V DISEÑO

100

Figura 5.25 Comando Movj ERC Fuente [9]

CAPÍTULO V DISEÑO

101

5.3.5 Bloque de diseño mecánico Solidworks

Para que simulink puedan simular la realidad virtual se necesita el diseño

mecánico del robot en formato VRML 2.0.

Primero se debe diseñar toda la estructura del robot industrial Motoman K3S en

solidwrorks pieza por pieza tomando las medidas exacta del robot.

Luego en solidworks se exporta todas las piezas del robot al formato VRML 2.0.

Y se utiliza vrbuild2.exe de matlab para en enlazar cada pieza del robot

definiendo la relación que existe entre las piezas y el eje de rotación de cada

pieza con el objetivo de que esta pueda ser controlada mediante el bloque de

virtual reality de simulink.

Figura 5.26 Diseño mecánico de cada pieza en Solidworks Fuente [EP]

Figura 5.27 Enlazado de piezas con vrbuild2.exe Fuente [EP]

CAPÍTULO V DISEÑO

102

Este es un Ejemplo de cómo debe quedar las piezas integradas en vrbuild2.exe de Matlab.

Figura 5.28 Diseño mecánico Motoman K3S Solidworks Fuente [EP]

a) Vista Frontal Plano XY

b) Vista Isométrica Plano XYZ

c) Vista Trasera Plano XY

d) Vista Izquierda Plano ZY

e) Vista Derecha Plano ZY

f) Vista Superior Plano XZ

g) Vista Inferior Plano XZ

a) b) c)

d) e)

f) g)

CAPÍTULO V DISEÑO

103

5.3.6 Bloque Simulink

En este bloque se encuentra 2 módulos. El controlador de joystick y el modulo

de realidad virtual. Ambos se encuentran interconectados con bloques de

cálculo matemático que adaptan las señales del joystick para que puedan

controlar cada eje del robot.

Figura 5.29 Control joystick y Realidad virtual Simulink Fuente [EP]

CAPÍTULO V DISEÑO

104

5.3.6.1 Módulo Control Joystick

El módulo de control de joystick es un bloque de simulink denominado Joystick

Input, este bloque permite tomar el control del mando joystick que se encuentra

conectado y presenta dos salidas de datos: la salida Axes representan los ejes

del joystick y la salida Buttons representan los botones del joystick. La señal de

salida de Axes es un vector donde su contenido puede estar en 1 (sentido +), -1

(sentido -) y 0 (no apretado). Y la señal de salida Buttons también es un vector

pero su contenido solo puede estar en 1 (apretado) y 0 (no apretado).

5.3.6.2 Bloques para la adaptación de los señales del joystick

Para que el modelo 3D del robot Motoman K3S pueda ser movido con el

joystick, se necesita usar cierto bloques de cálculo matemáticos para convertir

la señal del joystick a ángulos radianes y luego adaptarlo al formato que acepta

el bloque de realidad virtual.

Figura 5.30 Módulo joystick Fuente [EP]

CAPÍTULO V DISEÑO

105

Las salidas del Axes y Buttons se conectan a los subsistemas S,L,U,R,B,T

(representan a los 6 ejes del robot). La función de estos subsistemas es

seleccionar los botones específicos del joystick y convertirlo en radianes. En

cada uno de estos subsistemas se encuentran: un bloque selector de simulink

que permite seleccionar la señal específica del joystick, un multiplicador para

variar la velocidad y un integrador para acumular los angulos en radianes.

Figura 5.31 Módulo joystick y Subsistemas S,L,U,R,B,T Fuente [EP]

CAPÍTULO V DISEÑO

106

Debido a que existe una relación especial entre el eje L y el eje U del robot

Motoman K3S. Se debe respetar la formula U=U-L (el nuevo ángulo de U es

igual al ángulo de U antiguo menos el ángulo de L). En la siguiente figura se

muestra la relación entre el eje U y L expresado en simulink.

Figura 5.32 Subsistema S Fuente [EP]

Figura 5.33 Bloques Simulink Fuente [EP]

CAPÍTULO V DISEÑO

107

Las salidas de los subsistemas S,L,U,R,B,T se conectan con el subsistema

AdaptadorVR que tiene la función de adaptar los ángulos reales del robot

Motoman K3S a los ángulos que manejan el Virtual Reality de Matlab.

Figura 5.34 Relación eje L y U Fuente [EP]

Figura 5.35 Subsistema AdaptadorVR Fuente [EP]

CAPÍTULO V DISEÑO

108

Se puede observar en la figura anterior: los ángulos de los ejes L, U y B de

salida es invertido a los ángulos de entradas. Esto es debido a que el sentido de

giro del virtual Reality de Matlab y el sentido de giro de Modelo Matemático (Fig.

5.20) es invertido.

Las salidas del subsistema AdaptadorVR se conectan al subsistema VR

Transformations que se encarga de definir los ejes de rotación de las piezas de

realidad virtual. Por ejemplo el vector [1 0 0] significa eje X, [0 1 0] significa eje

Y y [0 0 1] significa eje Z.

Figura 5.36 Subsistema VR Transformations Fuente [EP]

CAPÍTULO V DISEÑO

109

5.3.6.3 Módulo Realidad Virtual

El módulo de realidad virtual es un bloque de simulink denomidado Virtual

Reality en el cual permite simular piezas 3D con formato VRML2.0 (Virtual

Reality Modeling Language).

Para que funcione el bloque de virtual reality se debe sumistrar el diseño 3D del

robot debidamente enlazado con vrbuild2.exe y seleccionar los movimientos

que se va simular en cada pieza. Como el Motoman K3S es un robot del tipo

articulado solo es necesario seleccionar el movimiento rotacional.

En la figura se puede observar que las 6 entradas rotacionales del bloque

RobotMotomanVR se encuentran conectados. Estas representan las 6

articulaciones del robot Industrial Motoman K3S.

Figura 5.37 Bloque Virtual Reality Fuente [EP]

CAPÍTULO V DISEÑO

110

5.3.7 Conexión Rs232 ERC

En el siguiente grafica muestra cómo debe estar conectado el cable Rs232

entre el ERC y la PC.

Figura 5.38 Configuración cable de Conexión RS232 ERC - PC

Fuente [8]

CAPÍTULO V DISEÑO

111

5.4 PLAN DE PRUEBAS

5.4.1 Pruebas individuales de los componentes

1. Joystick

a. Verificar el driver.

b. Probar que el joystick este bien calibrado y que reconozca todos

los botones.

2. Realidad Virtual

a. Verificar la compatibilidad del solidworks con simulink.

b. Comprobar enlazado de distintas piezas.

3. Diseño Mecánico Solidworks

a. Verificar que cada pieza tenga las medidas correctas.

b. Verificar compatibilidad solidworks y simulink.

4. Modelo matemático del Motoman K3S

a. Verificar el comportamiento del modelo matemático.

b. Verificar que los limites de cada eje.

c. Comprobar que la estructura del modelo matemático sea la

correcta.

5. Cálculos Matemáticos

a. Comprobar que la cinemática directa generado por robotic toolbox

sea correcta

b. Comprobar que la cinemática inversa generado por robotic toolbox

sea la correcta.

6. Comunicación Rs232 ERC

a. Comprobar la compatibilidad de matlab para manejar puerto serial.

b. Verificar la compatibilidad del matlab Rs232 y ERC.

CAPÍTULO V DISEÑO

112

5.4.2 Pruebas de integración

1. Joystick con simulink

a. Verificar la compatibilidad del joystick con simulink.

b. Verificar el reconocimiento del joystick.

c. Verificar compatibilidad del joystick con el modulo de realidad

virtual.

d. Verificar la conexión entre el joystick, simulink y el modulo de

realidad virtual con modelo 3D.

2. Modelo matematico con simulación 3D y Grafica 3D

a. Comprobar los cálculos matemáticos estén correctas con

simulación 3D.

b. Graficar los puntos de la trayectorias del robot para verificar que

los cálculos se efectuó correctamente.

3. GUI (Interfaz Gráfica del Usuario) con el sistema

a. Control Remoto

i. Verificar que el GUI de matlab puedan abrir el puerto serial

correctamente.

ii. Verificar el enlazado entre GUI y el Bloque de

comunicación.

iii. Verificar que las tramas de los distintos comandos estén

correctos.

b. Tiempo Real

i. Comprobar que se pueda manejar el robot Motoman K3S

mediante Joystick en tiempo real.

ii. Verificar el enlace de cada botón del joystick.

iii. Verificar la estabilidad del robot.

c. Simulaciones 3D

CAPÍTULO V DISEÑO

113

i. Comprobar que el botón de simulación 3D puedan abrir

correctamente simulink y hacer visualizar el modulo de

realidad virtual.

ii. Verificar que al activar la simulación el joystick le manda la

señal correctamente al simulink.

iii. Verificar que el modelo 3D del robot se mueva obedeciendo

a los comando del joystick.

iv. Comprobar que el eje L y U se encuentre enlazado

correctamente.

d. Grafico 3D Trayectorias del robot

i. Verificar que la grafica registre cada punto que pasa el

robot sin borrarlo.

ii. Probar que la visión XYZ, XY, y XZ funcione correctamente.

e. Al momento de hacer simulación de movimiento lineal, verificar si

los bloques de simulink recibe correctamente los cálculos

realizado con robotic toolbox, también comprobar que el modelo

robot 3D se mueva en forma lineal viendo la simulación del bloque

de realidad virtual y la grafica 3D que se encuentra en el GUI.

f. Comprobar que en la tabla del GUI se puedan insertar

correctamente los puntos en coordenadas XYZ que deseamos

que el robot mueva en forma lineal. Además si apretamos el

botón de calcular mov lineal se debe generar una trayectoria lineal

en la grafica 3D, luego si apretamos el botón simular, se debe

mover el modelado 3D del robot en forma lineal entre los puntos

insertados manteniendo la orientación del TCP.

CAPÍTULO V DISEÑO

114

5.4.3 Pruebas de operación global

Una vez terminado las pruebas de integración se integra todas las piezas que

compone el sistema. Haciendo prueba de conectividad entre el bloque de

simulink, bloque de cálculos matemáticos, bloque de Modelo matemáticos,

bloque de diseño mecanico, bloque de comunicación RS232-ERC y el bloque

de GUI (Interfaz gráfica del usuario).

En estas pruebas se debe comprobar que el GUI puedan activar todas las

modalidades del sistema, como la simulación, el movimiento en tiempo real. Etc

y también se debe comprobar que a través del GUI se puedan energizar

remotamente los servomotores del Motoman K3S, Enviar comando de

movimiento para llegar a la posición que deseamos.

Cuando se activa el modo de simulación en GUI se debe abrir el simulink y el

modulo de realidad virtual en la cual debe aparecer el modelado 3D del robot

Motoman K3S. Una vez abierto el simulink se debe poder mover cada eje del

robot modelado con los botones del joystick asignados.

Cuando se activa el modo de tiempo real en GUI se debe abrir el simulink y el

modulo de realidad virtual en la cual debe aparecer el modelado 3D del robot

Motoman K3S. Una vez abierto el simulink se debe poder mover cada eje del

robot real con los botones del joystick asignados. Además también se debe

mover el robot de la realidad virtual en 3D.

Para que el sistema genere movimiento lineal se necesita comprobar que en la

tabla del GUI se puedan insertar correctamente los puntos en coordenadas XYZ

que deseamos que el robot mueva en forma lineal. Además si apretamos el

botón de “calcular mov lineal” se debe generar una trayectoria lineal en la

grafica 3D, luego si apretamos el botón simular, se debe mover el modelado 3D

CAPÍTULO V DISEÑO

115

del robot en forma lineal entre los puntos insertados manteniendo la orientación

en el extremo del robot.

En el panel Angulo Motor [rad] se debe mostrar siempre los ángulos en

radianes de cada motor. Tanto en la simulación como en tiempo real. Además

en el panel de Coordenadas XYZ [mm] se debe poder visualizar la posición que

se encuentra el punto final del robot en coordenada cartesiana XYZ.

En la Grafica 3D se debe mostrar la trayectoria que pasó el extremo del robot a

través de puntos rojos. Luego se debe poder cambiar de visión de grafica a XZ,

XY, y XYZ. Y también se debe poder limpiar la grafica con el botón limpiar.

5.4.4 Pruebas de rendimiento

1. Probar el sistema de control cinemático en varias computadoras.

2. Cambiar la velocidad y la cantidad de pulsos que se manda al

controlador ERC por comando, para verificar como reacciona el

movimiento en tiempo real con joystick.

3. En el cálculo de movimiento lineal alterar el valor de puntos por línea y

para visualizar cómo reacciona el sistema.

4. En la simulación del movimiento lineal.alterar el valor de pausa

simulación[s] para verifcar el funcionamiento del sistema.

CAPÍTULO VI IMPLEMENTACIÓN

116

6

CAPÍTULO VI

IMPLEMENTACIÓN


117

6.1 DESCRIPCIÓN GLOBAL

El sistema de control cinemático puede funcionar tanto en tiempo real como en

simulación. Todo el sistema está constituido por varios módulos: modulo de

realidad virtual, modulo de GUI (Interfaz grafica del usuario), modulo de

comunicación, modulo de cálculos matemáticos, módulos de movimientos

lineal, modulo de simulación, modulo de tiempo real, modulo de transformación

de coordenadas y modulo de grafico 3D. Permitiendo así optimizar o mejorar el

sistema implementar módulos nuevas con gran facilidad.

Figura 6.1 Sistema de control cinemático Fuente [EP]


118

6.2 DESCRIPCIÓN DEL AMBIENTE DEL TRABAJO

El lugar del trabajo del presente proyecto es en el laboratorio de PLC –

Robotica CIT-108 en la UPSA. En el laboratorio se cuenta con un robot

industrial Motoman K3S con su respectivo controlador ERC. El robot requiere

alimentación trifásica 380V. En el cual se habilitó un punto especial solo para la

conexión del robot. También se cuenta con 2 computadoras Pentium 4 de

marca DELL, conexión a internet mediante LAN. Instrumento de medición como

Scopmeter, multimetros. Y herramientas como alicates, destornilladores etc.

Figura 6.2 Ambiente de Trabajo Fuente [EP]


119

6.3 PROBLEMAS ENCONTRADOS

1. No se podía activar el modo remoto del controlador ERC debido a que se

necesita una contraseña y configuración especial para activarlo.

2. En la comunicación con el controlador ERC salía en la pantalla del ERC error

del hardware.

3. Al momento de mandar los comandos de movimiento al controlador ERC con

el puerto USB – SERIAL salía error de hardware.

4. No enlazaba el bloque de realidad virtual con simulink.

5. Se encontró que entre el eje L y U del motoman K3S tiene un

comportamiento distinto a los robot comunes de 6 grados de libertad. Debido a

que el eje L y U esta enlazado mediante 2 articulaciones, formando un sistema

de palanca.

6.4 SOLUCIONES REALIZADAS

1. Se encontró la contraseña y el procedimiento para activar el modo remoto en

el pc del laboratorio de robótica:

Procedimientos:

Apretar OP2 e ingresar la contraseña:

24.#4.#2

En Parameter->SD, Cambiar los señales

SD78 a 1

SD110 a 1

Apretar boton flecha para desplazar <| hacia menu anterior

En Concur I/O-> IN-Connect line 7 Step 15 cambiar:


120

4023 por 4025

En Concur I/O-> OT-Connect line 1 Step 2 cambiar:

5023 por 5025

Apretar Flecha <| y Apretar Compile

Luego Apagar y Encender el Controlador ERC, De esta forma se activara

automáticamente el modo remoto.

2. Se detectó que matlab tiene ciertos bugs para trabajar con conversor USB-

SERIAL, el matlab tardaba en tomar el control del puerto serial y no activaba el

RequestToSend a la primera. Entonces se tuvo que activarlo 2 veces para que

funcione.

3. Debido a que matlab no maneja bien el conversor USB-SERIAL, falla cuando

hay transferencia continua de información. Se procedió a migrar el sistema de

control cinematico al PC 01 del lab de PLC – Robotica. En la cual funcionó sin

ningún problema.

4. Cuando no se introduce un nombre a la articulación enlazado con vrbuild2 de

matlab no permitía enlazar el bloque de realidad virtual con simulink, entonces

se solucionó el problema asignando nombre a cada articulación.

5. Se busco la relación matemático que existe en el eje L y U y se encontró

mediante la observación que obedece a la formula U=U-L, el nuevo ángulo de U

es igual al ángulo de U antiguo menos el ángulo de L.


121

6.5 PROCEDIMIENTO DE IMPLEMENTACIÓN

1. Diseñar el modelo CAD 3D del robot industrial Motoman K3S,

haciéndolo pieza por pieza y tomando las medidas exactas de cada

segmento.

2. Exportar cada pieza de solidworks al formato VRML 2.0 (Virtual Reality

Modeling Language). Una vez exportado se debe enlazar cada pieza con

vrbuild2 que tiene matlab.

Figura 6.3 Diseño mecánico de cada pieza en Solidworks Fuente [EP]

Figura 6.4 Diseño 3D en VRML 2.0 Fuente [EP]


122

3. Con el modelo mecánico 3D terminado se inicia el proceso de enlazado

del modelo 3D con simulink. En la cual se enlaza las 6 articulaciones del

modelo 3D del robot con el joystick. y también se realiza ciertas

conversiones matemáticas para poder adaptar los comandos del joystick

al movimiento del robot. Además se inserta un bloque Scope para

visualizar los ángulos de cada articulación del robot.

Figura 6.5 Bloque Principal Simulink Fuente [EP]


123

Figura 6.6 Bloque Adaptador VR Simulink Fuente [EP]

Figura 6.7 Bloque VR Transformation Simulink Fuente [EP]


124

4. Una vez terminado el enlace entre simulink, modelo 3D y joytick se

procede a la realización de la interfaz gráfica. Esta interfaz se divide en

bloques con funciones específicas. Primero se diseña y se programa el

bloque de comunicación con el controlador ERC, luego el bloque de

simulación y tiempo real, después el bloque de posición y gráfica 3D. por

último el bloque de movimiento lineal en la cual implica cálculos de

cinemática inversa.

5. Luego se procede a enlazar todo los bloques entre sí y también

intercomunicar estos bloques con el simulink. Creando así el sistema de

control cinematico.

Figura 6.8 Interfaz Gráfica del Usuario GUI Fuente [EP]


125

Figura 6.9 Sistema de control cinemático Fuente [EP]


126

6.6 RESULTADOS DE LAS PRUEBAS

6.6.1 Pruebas individuales de los componentes

6.6.1.1 Joystick

Identificación de la Prueba Procedimiento Seguido Resultados Obtenidos

Driver Joystick Conectar el joystick al puerto usb y verificar si presenta el driver correcto.

Se verificó que el driver del joystick funciona correctamente.

Calibración Joystick Probar que el joystick este bien calibrado y que reconozca todos los botones.

Se realizo la prueba con éxito.

6.6.1.2 Realidad Virtual


Formato del modelo 3D Verificar que el formato de realidad virtual exportado con solidworks sea compatible con el formato que acepta simulink.(wrml 2.0)

Desde simulink se importo correctamente el modelo 3D sin problemas.

Enlazado de piezas Comprobar que cada pieza del robot este correctamente enlazado.

Se comprobó gráficamente que las piezas del robot esta bien enlazado.

6.6.1.3 Diseño Mecánico Solidworks


Medición Correcta Comprobar que cada pieza tenga las medidas correcta del motoman K3S que se encuetra en el laboratorio.

Las mediciones concuerda con el Motoman K3S que se encuentra en el laboratorio.

Compatibilidad Modelo 3D Simulink

Verificar los parámetros de exportación al archivo wrml 2.0 para que sea compatible con simulink.

Se exporto correctamente el archivo wrml y también se verifico que era compatible.

6.6.1.4 Modelo matemático del Motoman K3S



127

Verificación del modelo matemático

Simular el modelo matemático con la herramienta robotic toolbox usando el comando drivebot. Y comprobar que la estructura generado por drivebot sea idéntica a la estructura real del motoman.

Se observó que el Motoman K3S tiene la misma estructura que el robot generado por drivebot

Verificación de los limites Verificar con el drivebot que los limites de cada eje este bien definido.

Se comprobó que drivebot respecta los limites introducidos.

6.6.1.5 Cálculos Matemáticos


Cinemática Directa Comprobar que la cinemática directa generado por robotic toolbox sea correcta

Se verificó que la cinemática directa generada es la correcta.

Cinemática Inversa Comprobar que la cinemática inversa generado por robotic toolbox sea la correcta.

Se verificó que la cinemática inversa generada es la correcta.

6.6.1.6 Comunicación Rs232 ERC


Puerto Serial Matlab Comprobar que se puede abrir los puertos seriales sin problema, luego mandar los comandos correctamente formateados al controlador ERC.

Se pudo abrir el puerto con matlab y también se pudo hacer que mande las señales debidamente formateado.

Comandos ERC Visualizar en el ERC si recibió correctamente el comando, verificar si el ERC pudo ejecutar el comando.

Se verifico en el ERC que recibo sin error el comando y lo ejecuta correctamente.

6.6.2 Pruebas de integración

6.6.2.1 Joystick con simulink


Reconocimiento del Joystick Insertar el bloque de control de joystick en el simulink para

El bloque de control de joystick reconoció


128

verificar si reconoce el joystick.

perfectamente el joystick usb.

Botón del Joystick Verificar si el controlador de joystick que tiene simulink reconoce cada botón del joystick.

Se verifico que el controlador de simulink reconoce todos los botones del joystick.

Joystick y Realidad Virtual Enlazar el controlador de joystick con el bloque de realidad virtual.

Se enlazo correctamente el josytick con el bloque de realidad virtual.

Enlace joystick, simulink, realidad virtual

Comprobar que al conectar el joystick usb, el simulink lo reconozca correctamente y verificar si esta mandando los datos correctamente al modulo de realidad virtual, luego verificar si el modelo 3D ejecuta correctamente los datos recibidos.

La prueba fue ejecutada satisfatoriamente.

6.6.2.2 Modelo matemático con simulación 3D y Grafica 3D


Verificación del cálculo mediante realidad virtual

Enlazar el modelo matemático con la simulación 3D (realidad virtual). Para comprobar gráficamente que se efectuó correctamente los cálculos matemático.

Se verificó gráficamente que el cálculo realizado no presenta errores.

Verificación del cálculo mediante Gráficos 3D

Graficar los puntos de la trayectorias del robot para verificar que los cálculos se efectuó correctamente.

Se verifico que los cálculos son correctas.

6.6.2.3 GUI (Interfaz Gráfica del Usuario) con el sistema

6.6.2.3.1 Bloque Control Remoto


GUI con puerto serial Verificar que el GUI de matlab puedan abrir el puerto serial correctamente.

Se abrió el puerto serial sin problemas


129

Envio de paquete Probar un envio de paquete por puerto serial mediante un botón de matlab y mostrar lo recibido en un msgbox.

Se envió el recibió correctamente los mensajes por puerto serial a través del matlab.

6.6.2.3.2 Bloque Tiempo Real


Control con joystick Comprobar que se pueda manejar el robot Motoman K3S mediante Joystick en tiempo real.

Se verificó que se pudo manejar el motoman con el joystick. Aunque prsenta cierta lentitud.

Verificación de enlace joystick Mover cada eje de articulación con el joystick.

Se pudo mover cada eje sin problemas.

Variación de parámetros Variar la velocidad y la cantidad de pulso en el momento de envio para visualizar cómo reacciona el robot.

Se pudo observar que a mas velocidad es mas inestable el movimiento, y cuando hay mas pulso es mas impreciso el movimiento.

6.6.2.3.3 Bloque Simulaciones 3D


Enlace GUI con realidad virutal

Comprobar que el botón de simulación 3D puedan abrir correctamente simulink y hacer visualizar el modulo de realidad virtual.

Se efectuó la prueba correctamente.

Enlace GUI joystick Verificar que al activar la simulación el joystick le manda la señal correctamente al simulink.

Se verificó que la simulación con joystick funciona correctamente.

Enlace Modelo 3D con joystick

Verificar que el modelo 3D del robot se mueva obedeciendo a los comando del joystick.

Se verifico que el movimiento obedece a los comandos del joystick.

Enlace entre eje L y U Comprobar que el eje L y U se encuentre enlazado correctamente. Debido a que son 2 ejes especiales donde están articulados con una relación de angulo. (U=U-L)

Se observo que con la ecuación el movimiento simula perfectamente el movimiento real del motoman.


130

6.6.2.3.4 Bloque Grafico 3D Trayectorias del robot


Posición del robot Verificar que la grafica registre cada punto que pasa el robot sin borrarlo.

Se verificó que se mantiene la trayectoria.

Visión de la Gráfica Probar que la visión XYZ, XY, y XZ funcione correctamente.

Se observo que el cambio de visión funciona correctamente.

6.6.2.3.5 GUI con el sistema


Enlace de varios bloques Al momento de hacer simulación de movimiento lineal, verificar si los bloques de simulink recibe correctamente los cálculos realizado con robotic toolbox, también comprobar que el modelo robot 3D se mueva en forma lineal viendo la simulación del bloque de realidad virtual y la grafica 3D que se encuentra en el GUI.

Se verificó que todo se realizo correctamente.

Enlace de varios bloques Comprobar que en la tabla del GUI se puedan insertar correctamente los puntos en coordenadas XYZ que deseamos que el robot mueva en forma lineal. Además si apretamos el botón de calcular mov lineal se debe generar una trayectoria lineal en la grafica 3D, luego si apretamos el botón simular, se debe mover el modelado 3D del robot en forma lineal entre los puntos insertados manteniendo la orientación del TCP.

Se verificó que todo se realizó correctamente.


131

6.6.3 Pruebas de operación global


Operación Global del Sistema Detallado en el punto 5.4.3 Se verificó que todo se realizó correctamente.

6.6.4 Pruebas de rendimiento


Compatibilidad Probar el sistema de control cinemático en varias computadoras.

Se probó el sistema en un laptop y un PC. En el PC funciona correctamente. Pero en el laptop se encontró problema de que matlab 2009 no maneja eficientemente el puerto serial del conversor usb-serial.

Variación de parámetro movj por ERC RS232

Cambiar la velocidad y la cantidad de pulsos que se manda al controlador ERC por comando, para verificar como reacciona el movimiento en tiempo real con joystick.

Se verificó que a mayor velocidad es más inestable y a mayor pulso es mas impreciso el movimiento del robot.

Calculo Movimiento lineal En el cálculo de movimiento lineal alterar el valor de puntos por línea y para visualizar cómo reacciona el sistema.

Se realiza los cálculos sin problemas pero se observó que a medida hay más puntos tarda más en calcular.

Simulación Movimiento Lineal En la simulación del movimiento lineal. Alterar el valor de pausa simulación[s] para verificar el funcionamiento del sistema.

Se observo que funciona correctamente. A medida que hay menos tiempo de pause se mueve mas rápido el robot.


132

En las graficas se demuestra que se generó el movimiento lineal correctamente.

Los puntos verdes olivo es la trayectoria lineal calculada, y los puntos azules es

la trayectoria lineal efectuada por la simulación del robot 3D.

Figura 6.10 Trayectoria lineal generado en matlab Fuente [EP]


133

En las siguientes gráficas se demuestra la simulación del movimiento lineal en VRML (Realidad Virtual) de Matlab.

Figura 6.11 Simulación del Movimiento Lineal Fuente [EP]


134

En esta Grafica se muestra la trayectoria de movimiento lineal pasando por 4 puntos, calculada con la cinematica inversa.

Los puntos rojos de las siguientes gráficas muestra la trayectoria efectuada por el robot 3D (Realidad Virtual) simulado en matlab.

Figura 6.12 Trayectoria de Movimiento Lineal Fuente [EP]

Figura 6.13 Trayectoria efectuada por el robot simulado en matlab

Fuente [EP]


135

Prueba de Funcionamiento: Generacion de trayectoria lineal y Movimiento en

tiempo real de la trayectoria lineal.

En las figuras se pueden observar que el robot dibujo dos líneas rectas siguiendo la trayectoria lineal calculado por el sistema.

Figura 6.14 Trayectoria lineal efectuada por el robot en tiempo real

Fuente [EP]


136

Para observar con más detalle sobre el funcionamiento visiten los siguientes videos:

Trayectoria lineal efectuada por el robot en tiempo real:

Tesis - Sistema de Control Cinematico Robot Industrial

http://www.youtube.com/watch?v=W81HC8tbfiU

Tesis - Movimiento lineal en tiempo Real con simulacion 3D - Matlab.

http://www.youtube.com/watch?v=86xTCckPSjA

Funcionamiento del robot en tiempo real con joystick:

Tesis. Sistema de control cinematico para robot industrial motoman K3S.

Matlab

http://www.youtube.com/watch?v=K842laLX4bU


137

Simulación del Sistema de control cinematico:

Control Cinematico Robot Industrial Motoman K3S - Cinematica Inversa -

Movimiento Lineal - Matlab

http://www.youtube.com/watch?v=Gs2p-KH-4vA

Visite: http://www.youtube.com/user/ChaoHuang1000 para ver todos los videos que demuestran el funcionamiento de este trabajo.

CONCLUSIONES Y RECOMENDACIONES

138

7

CAPÍTULO VII

CONCLUSIONES Y

RECOMENDACIONES


139

CONCLUSIONES

En el presente trabajo se alcanzo satisfactoriamente los objetivos

planteados. En virtud a que se llegó a diseñar e implementar un sistema

de control cinemático de arquitectura abierta programado en matlab para

el robot industrial Motoman K3S.

El sistema de control cinemático desarrollado en el presente trabajo

permite hacer simulaciones en 3D. Movimientos del robot con joystick

tanto en tiempo real como en modo de simulación. También calcula y

grafica todas las trayectorias que el robot atraviesa. Permite realizar

encendido remoto de los servomotores, movimientos mediante

comandos, calcula la cinemática directa, la cinemática inversa y genera

trayectorias lineales manteniendo la orientación. Así abarcando todos los

conceptos fundamentales de la robótica industrial. Además el sistema

está formado por varios módulos en el cual nos permite agregar nuevos

módulos usando el mismo sistema base. Permitiendo que otros

desarrolladores mejoren y reutilicen el sistema.

Los resultados de las pruebas realizadas (6.6.4) demuestra los

siguientes:

o Todos módulos del sistema de control cinemático desarrollado en

la presente tesis funcionan correctamente tanto en PCs como en

laptops, excepto el módulo de comunicación que presenta

incompatibilidad con laptops que utilizan conector USB-SERIAL,

debido a que matlab 2009b no lo maneja correctamente.

o Se demostró que el sistema permite efectuar el movimiento del

robot en tiempo real, y se observó que cuando se configura una


140

velocidad mayor, el movimiento del robot se vuelve más inestable.

Y cuando se configura más pulsos por transmisión, el movimiento

del robot se vuelve más impreciso.

o Se verificó que los cálculos de cinemática directa e inversa

funcionan correctamente, estas hace que el robot se mueva a la

trayectoria deseada. Y se observó que a medida aumentan los

puntos de interpolación, aumenta el tiempo de cálculo de la

cinemática inversa.


141

RECOMENDACIONES

1. Se recomienda exportar todo el bloque de cálculo del sistema de control

cinemático que esta en un lenguaje interpretado matlab al tipo MEX

(lenguaje compilado). Permitiendo que Matlab procese mucho más

rápido.

2. Como el sistema es de arquitectura abierta, se recomienda implementar

nuevo módulos de visión artificial para el robot utilizando las

herramientas de Matlab de procesamiento de imágenes.

3. En base al trabajo de la presente tesis, se recomienda desarrollar

modulo de CAD/CAM (# Diseño asistido por ordenador (computer-aided design – CAD), y # Fabricación

asistida por ordenador (computer-aided manufacturing – CAM) de aplicaciones robóticas para

fabricar piezas a partir de un diseño CAD.

4. Para laptop que no tenga puerto serial se recomienda utilizar Tarjeta

ExpressCard Serial Port en vez del Conector USB-SERIAL. Debido a que

matlab 2009b no maneja adecuadamente el conector USB-SERIAL.

5. Se recomienda cambiar el controlador ERC por controladores de

servomotores trifásicos. Debido a que la velocidad de comunicación del

controlador ERC es muy lenta. (9600 bps half dúplex) y como el sistema

de control cinemático hace todos los cálculos cinematicos, solo se

necesitó utilizar la parte de potencia del controlador ERC que fácilmente

puede ser reemplazado por los controladores de servomotores trifásicos.

Además estas presentan opciones de comunicación mucho más rápido

como Ethernet, profinet, pwm etc.

BIBLIOGRAFÍA

BIBLIOGRAFÍA

BIBLIOGRAFÍA

[EP] Elaboración Propia

[1] Universidad Miguel Hernández de Elche, “Robotica Industrial”,

http://isa.umh.es/asignaturas/crss/, 30/03/2010

[2] Víctor R. González Fernández, “Fundamentos de Robótica”

http://cfievalladolid2.net/tecno/cyr_01/robotica/index.htm,13/11/2010

[3] Antonio Barriento, “Fundamentos de Robótica”, Mcgraw-hill 2da Edición,

España, 2007

[4] Universidad de Atacama, “Seminario de automatización Robótica”,

http://www.industriaynegocios.cl/Academicos/AlexanderBorger/Docts%20Docen

cia/Seminario%20de%20Aut/trabajos/2004/Rob%C3%B3tica/seminario%20200

4%20robotica/, 13/11/2010

[5] John J. Craig, “Introduction to Robotics, Mechanics and Control”, Prentice

Hall; 2 edition, USA, 1989

[6] Lab PLC UPSA

[7] ebay.com lj_machinery_inc, “MOTOMAN YASKAWA K3S 6 axis with ERC

CONTROL”, http://cgi.ebay.com/MOTOMAN-YASKAWA-K3S-6-axis-ERC-

CONTROL-video-/390100149054?pt=BI_Robotics&hash=item5ad3c7e33e,

13/11/2010

[8] Motoman Incorporated, “Motoman ERC Controller Communications Manual”,

Motoman 2 version,,1993

[9] Yaskawa, “Motocom32 Operation Manual”, Yaskawa,,,

[10] Motoman, “K3S Manipulator Manual”, Motoman,,1995

[11] María Mónica Cabrera Aguilera, Rolando Velasco Castedo, “Diseño de un

Controlador Robusto TDOF aplicado al control de trayectoria para el Robot

Industrial Motoman K3S”, 2006

[12] Angélica Lezcano A, “Implementación de una Interfaz para la comunicación

entre la PC y el Robot Industrial Motoman K3S”, 2008

[13] Natan Corcus, “Diseño de un sistema de control de posición para

servomotores del Robot Industrial Motoman K3S“, 2010

[14] Peter Corke robotics-tool-box, “Trouble with theta in the kinematic model”,

BIBLIOGRAFÍA

http://groups.google.com/group/robotics-tool-

box/browse_thread/thread/958a3cba496e8d5f/dbdc0fb32bb3f4ca?hl=en-

GB&lnk=gst&q=theta+parameter+dh#dbdc0fb32bb3f4ca, 14/05/2011

ANEXOS

ANEXOS

ANEXOS

ANEXOS

Codigo Matlab GUI – Motoman.m

function varargout = Motoman(varargin) % MOTOMAN M-file for Motoman.fig % MOTOMAN, by itself, creates a new MOTOMAN or raises the existing % singleton*. % % H = MOTOMAN returns the handle to a new MOTOMAN or the handle to % the existing singleton*. % % MOTOMAN('CALLBACK',hObject,eventData,handles,...) calls the local % function named CALLBACK in MOTOMAN.M with the given input arguments. % % MOTOMAN('Property','Value',...) creates a new MOTOMAN or raises the % existing singleton*. Starting from the left, property value pairs are % applied to the GUI before Motoman_OpeningFcn gets called. An % unrecognized property name or invalid value makes property application % stop. All inputs are passed to Motoman_OpeningFcn via varargin. % % *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one % instance to run (singleton)". % % See also: GUIDE, GUIDATA, GUIHANDLES % Edit the above text to modify the response to help Motoman % Last Modified by GUIDE v2.5 06-Nov-2010 10:08:07 % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @Motoman_OpeningFcn, ... 'gui_OutputFcn', @Motoman_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end % End initialization code - DO NOT EDIT % --- Executes just before Motoman is made visible. function Motoman_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to Motoman (see VARARGIN) % Choose default command line output for Motoman handles.output = hObject; % Update handles structure guidata(hObject, handles); % UIWAIT makes Motoman wait for user response (see UIRESUME) % uiwait(handles.figure1);

ANEXOS

%cinematica del motoman k3s %parametro DH %c{1}=link([-pi/2 150 0 0 0],'standard'); %c{2}=link([0 -270 0 0 0],'standard'); %c{3}=link([pi/2 -85 0 0 0],'standard'); %c{4}=link([-pi/2 0 0 440 0],'standard'); %c{5}=link([pi/2 0 pi/2 0 0],'standard'); %c{6}=link([0 0 0 75 0],'standard'); %--------Nuevo modelo matematico motoman k3s 2011 -------- % c{1}=link([-pi/2 150 0 369 0],'standard'); % c{2}=link([0 -270 0 0 0],'standard'); % c{3}=link([pi/2 -85 0 0 0],'standard'); % c{4}=link([-pi/2 0 0 440 0],'standard'); % c{5}=link([pi/2 0 pi/2 0 0 pi/2],'standard'); % % %el robotic toolbox no acepta theta en eje articulado pq es igual al movimiento angular. para poder hacer se necesita offset % c{6}=link([0 0 0 75 0],'standard'); %link( alpha A theta D 0=Rotacional/1=Prismatico offset, ‘standard’/‘modified’) %--------Nuevo modelo matematico motoman k3s Julio - 2011 Adaptando al sentido de giro real de motoman -------- c{1}=link([-pi/2 150 0 369 0],'standard'); c{2}=link([pi -270 0 0 0],'standard'); c{3}=link([pi/2 -85 0 0 0],'standard'); c{4}=link([-pi/2 0 0 -440 0],'standard'); c{5}=link([-pi/2 0 -pi/2 0 0 pi/2],'standard'); %el robotic toolbox no acepta theta en eje articulado pq es igual al movimiento angular. para poder hacer se necesita offset c{6}=link([0 0 0 -75 0],'standard'); c{1}.qlim=pi/180*[-170 170]; c{2}.qlim=pi/180*[0 180]; c{3}.qlim=pi/180*[-75 75]; c{4}.qlim=pi/180*[-180 180]; c{5}.qlim=pi/180*[-135 135]; c{6}.qlim=pi/180*[-180 180]; global motoman_k3s; motoman_k3s=robot(c); motoman_k3s.name='Motoman K3S'; global copia; copia = [1 0 0 0 0 0]; global ciclo; ciclo = timer('timerfcn',@ciclo_timer,'period',0.2,'StartDelay',1,'executionmode','fixedrate'); start(ciclo); global graf_3d; graf_3d=handles.Grafic; plot3(0,0,0,'ro'); grid(handles.Grafic,'on'); axis(handles.Grafic,'vis3d'); box(handles.Grafic,'on'); xlabel(handles.Grafic,'X'); ylabel(handles.Grafic,'Y'); zlabel(handles.Grafic,'Z');

ANEXOS

daspect(handles.Grafic,[1 1 1]); %cameratoolbar('Show'); hold(handles.Grafic,'on'); % --- Outputs from this function are returned to the command line. function varargout = Motoman_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structure varargout{1} = handles.output; % --- Executes on button press in pushbutton1. function pushbutton1_Callback(hObject, eventdata, handles) % hObject handle to pushbutton1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) ack0 = uint8([16 48]); ack1 = uint8([16 49]); global Serial_ERC; %cabecera SOH (start of header) comando=uint8(1); %Field header number, Subcode number comando=[comando unicode2native('01,000')]; %Start of information STX comando=[comando 2]; %Comando ASCII que se manda a ERC max 256 caracteres %CR = insertar un enter comando=[comando unicode2native('SVON 1') 13]; %ETX end of text comando=[comando 3]; %calcular tamano para insertar Block check character block_check=uint16(0); tam=length(comando); for k=2:tam block_check=block_check+uint16(comando(k)); end %convierte block_check en uint8 y lo invierte comando=[comando typecast(block_check,'uint8')]; enq=uint8(5); fwrite(Serial_ERC,enq,'uint8'); recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=2 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); %ack0 if (buf_rec(tam-1)==ack0(1)) && (buf_rec(tam)==ack0(2))

ANEXOS

recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); fwrite(Serial_ERC,comando,'uint8'); recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=2 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); if buf_rec(tam-1)==ack1(1) && buf_rec(tam)==ack1(2) %ack1 recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); eot=uint8(4); fwrite(Serial_ERC,eot,'uint8'); recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=1 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); %enq if buf_rec(tam)==uint8(5) recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); fwrite(Serial_ERC,ack0,'uint8'); % recibe la respuesta del ERC recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=16 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); if buf_rec(tam-2)==uint8(3) %etx recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); fwrite(Serial_ERC,ack1,'uint8'); recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=1 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); if buf_rec(tam)==uint8(4)%eot recibio=1; end end

ANEXOS

end additemtolistbox(handles.listbox1, char(buf_rec)'); % --- Executes on button press in pushbutton2. function pushbutton2_Callback(hObject, eventdata, handles) % hObject handle to pushbutton2 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) ack0 = uint8([16 48]); ack1 = uint8([16 49]); global Serial_ERC; %cabecera SOH (start of header) comando=uint8(1) ; %Field header number, Subcode number comando=[comando unicode2native('01,000')]; %Start of information STX comando=[comando 2]; %Comando ASCII que se manda a ERC max 256 caracteres %CR = insertar un enter comando=[comando unicode2native('SVON 0') 13]; %ETX end of text comando=[comando 3]; %calcular tamano para insertar Block check character block_check=uint16(0); tam=length(comando); for k=2:tam block_check=block_check+uint16(comando(k)); end %convierte block_check en uint8 y lo invierte comando=[comando typecast(block_check,'uint8')]; enq=uint8(5); fwrite(Serial_ERC,enq,'uint8'); recibio=0; contador=0; while recibio == 0 pause(0.001); %1ms contador=contador+1; if Serial_ERC.BytesAvailable>=2 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); %ack0 if (buf_rec(tam-1)==ack0(1)) && (buf_rec(tam)==ack0(2)) recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); fwrite(Serial_ERC,comando,'uint8'); recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=2 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8');

ANEXOS

if buf_rec(tam-1)==ack1(1) && buf_rec(tam)==ack1(2) %ack1 recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); eot=uint8(4); fwrite(Serial_ERC,eot,'uint8'); recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=1 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); %enq if buf_rec(tam)==uint8(5) recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); fwrite(Serial_ERC,ack0,'uint8'); % recibe la respuesta del ERC recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=16 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); if buf_rec(tam-2)==uint8(3) %etx recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); fwrite(Serial_ERC,ack1,'uint8'); recibio=0; while recibio == 0 pause(0.001); %1ms if Serial_ERC.BytesAvailable>=1 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); if buf_rec(tam)==uint8(4)%eot recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)'); % --- Executes on button press in pushbutton3. function pushbutton3_Callback(hObject, eventdata, handles) % hObject handle to pushbutton3 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Serial_ERC Serial_ERC = serial(get(handles.edit1,'String')); set(Serial_ERC,'BaudRate',9600); set(Serial_ERC,'DataBits',8);

ANEXOS

set(Serial_ERC,'Parity','even'); set(Serial_ERC,'StopBits',1); set(Serial_ERC,'FlowControl','none'); set(Serial_ERC,'RequestToSend','on'); set(Serial_ERC,'DataTerminalReady','off'); fopen(Serial_ERC); % bug que encontre en matlab. necesita poner en off y luego en on set(Serial_ERC,'RequestToSend','off'); set(Serial_ERC,'RequestToSend','on'); set(Serial_ERC,'DataTerminalReady','off'); set(Serial_ERC,'DataTerminalReady','on'); msgbox('Puerto Serial Iniciado'); % guardar datos en handles para ser usado en otra funcion %guidata(hObject,handles); function edit1_Callback(hObject, eventdata, handles) % hObject handle to edit1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit1 as text % str2double(get(hObject,'String')) returns contents of edit1 as a double % --- Executes during object creation, after setting all properties. function edit1_CreateFcn(hObject, eventdata, handles) % hObject handle to edit1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in pushbutton4. function pushbutton4_Callback(hObject, eventdata, handles) % hObject handle to pushbutton4 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Serial_ERC %CERRAR el puerto al finalizar fclose(Serial_ERC); %delete(handles.Serial_ERC); msgbox(Serial_ERC.Status); % --- Executes on button press in pushbutton5. function pushbutton5_Callback(hObject, eventdata, handles) % hObject handle to pushbutton5 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) ack0 = uint8([16 48]); global Serial_ERC; %enviar ENQ (Enquiry requests a response) comando=uint8(5) ; fwrite(Serial_ERC,comando,'uint8'); recibio=0;

ANEXOS

while recibio == 0 pause(0.001) %1ms if Serial_ERC.BytesAvailable>=2 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); if buf_rec(tam-1)==ack0(1) && buf_rec(tam)==ack0(2) %ack0 recibio=1; end end end additemtolistbox(handles.listbox1, char(buf_rec)');%transpuesta %msgbox('rec') % --- Executes on selection change in listbox1. function listbox1_Callback(hObject, eventdata, handles) % hObject handle to listbox1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = cellstr(get(hObject,'String')) returns listbox1 contents as cell array % contents{get(hObject,'Value')} returns selected item from listbox1 % --- Executes during object creation, after setting all properties. function listbox1_CreateFcn(hObject, eventdata, handles) % hObject handle to listbox1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: listbox controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in pushbutton7. function pushbutton7_Callback(~, eventdata, handles) % hObject handle to pushbutton7 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Serial_ERC Serial_ERC=instrfind('port','COM15') % --- Executes on button press in pushbutton8. function pushbutton8_Callback(hObject, eventdata, handles) % hObject handle to pushbutton8 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Serial_ERC; motor_pulso{1}=get(handles.edit3,'String'); motor_pulso{2}=get(handles.edit4,'String'); motor_pulso{3}=get(handles.edit5,'String'); motor_pulso{4}=get(handles.edit6,'String'); motor_pulso{5}=get(handles.edit7,'String'); motor_pulso{6}=get(handles.edit8,'String'); velocidad=get(handles.edit9,'String'); [error,r,codigo]=mover(Serial_ERC,motor_pulso,velocidad); %if ~error % msgbox(codigo');

ANEXOS

%end additemtolistbox(handles.listbox1, r); %comando=uint8(0); %Funcion Add String function h = additemtolistbox(h, newitem) % ADDITEMTOLISTBOX - add a new items to the listbox % H = ADDITEMTOLISTBOX(H, STRING) % H listbox handle % STRING a new item to display oldstring = get(h, 'string'); if isempty(oldstring) newstring = newitem; elseif ~iscell(oldstring) newstring = {oldstring newitem}; else newstring = {oldstring{:} newitem}; end set(h, 'string', newstring); function edit3_Callback(hObject, eventdata, handles) % hObject handle to edit3 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit3 as text % str2double(get(hObject,'String')) returns contents of edit3 as a double % --- Executes during object creation, after setting all properties. function edit3_CreateFcn(hObject, eventdata, handles) % hObject handle to edit3 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit4_Callback(hObject, eventdata, handles) % hObject handle to edit4 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit4 as text % str2double(get(hObject,'String')) returns contents of edit4 as a double % --- Executes during object creation, after setting all properties. function edit4_CreateFcn(hObject, eventdata, handles) % hObject handle to edit4 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end

ANEXOS

function edit5_Callback(hObject, eventdata, handles) % hObject handle to edit5 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit5 as text % str2double(get(hObject,'String')) returns contents of edit5 as a double % --- Executes during object creation, after setting all properties. function edit5_CreateFcn(hObject, eventdata, handles) % hObject handle to edit5 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit6_Callback(hObject, eventdata, handles) % hObject handle to edit6 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit6 as text % str2double(get(hObject,'String')) returns contents of edit6 as a double % --- Executes during object creation, after setting all properties. function edit6_CreateFcn(hObject, eventdata, handles) % hObject handle to edit6 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit7_Callback(hObject, eventdata, handles) % hObject handle to edit7 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit7 as text % str2double(get(hObject,'String')) returns contents of edit7 as a double % --- Executes during object creation, after setting all properties. function edit7_CreateFcn(hObject, eventdata, handles) % hObject handle to edit7 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end

ANEXOS

function edit8_Callback(hObject, eventdata, handles) % hObject handle to edit8 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit8 as text % str2double(get(hObject,'String')) returns contents of edit8 as a double % --- Executes during object creation, after setting all properties. function edit8_CreateFcn(hObject, eventdata, handles) % hObject handle to edit8 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit9_Callback(hObject, eventdata, handles) % hObject handle to edit9 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit9 as text % str2double(get(hObject,'String')) returns contents of edit9 as a double % --- Executes during object creation, after setting all properties. function edit9_CreateFcn(hObject, eventdata, handles) % hObject handle to edit9 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in pushbutton12. function pushbutton12_Callback(hObject, eventdata, handles) % hObject handle to pushbutton12 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) %find_system('Name','Motoman_3D'); global tiempo_real; global Serial_ERC; tiempo_real=1; open_system('Motoman_3D'); open_system('Motoman_3D/RobotMotomanVR'); set_param(gcs,'SimulationCommand','Start'); set_param('Motoman_3D/S/Constant','Value','0'); set_param('Motoman_3D/L/Constant','Value','0'); set_param('Motoman_3D/U/Constant','Value','0'); set_param('Motoman_3D/R/Constant','Value','0'); set_param('Motoman_3D/B/Constant','Value','0'); set_param('Motoman_3D/T/Constant','Value','0'); %relacion entre eje L y U set_param('Motoman_3D/Simulacion','Value','0');

ANEXOS

set_param('Motoman_3D/S/PosRobot','Value','0'); set_param('Motoman_3D/L/PosRobot','Value','0'); set_param('Motoman_3D/U/PosRobot','Value','0'); set_param('Motoman_3D/R/PosRobot','Value','0'); set_param('Motoman_3D/B/PosRobot','Value','0'); set_param('Motoman_3D/T/PosRobot','Value','0'); motor_pulso_num=[0 0 0 0 0 0]; rto = get_param('Motoman_3D/Joystick Input','RuntimeObject'); %rto1 = get_param('Motoman_3D/S/Display','RuntimeObject'); %rto2 = get_param('Motoman_3D/L/Display','RuntimeObject'); %rto3 = get_param('Motoman_3D/U/DataU','RuntimeObject'); %rto4 = get_param('Motoman_3D/R/DataR','RuntimeObject'); %rto5 = get_param('Motoman_3D/B/DataB','RuntimeObject'); %rto6 = get_param('Motoman_3D/T/DataT','RuntimeObject'); %msgbox('funciona'); while tiempo_real cambio=0; velocidad=get(handles.edit9,'String'); pulso=get(handles.edit10,'String'); n_pulso=str2num(pulso); joy1 = rto.OutputPort(1).Data(1); joy2 = rto.OutputPort(1).Data(2); joy3=0; joy4=0; joy5=0; joy6=0; %--------Joy3----------- if rto.OutputPort(2).Data(1) == 1 joy3=1; elseif rto.OutputPort(2).Data(3)==1 joy3=-1; end %--------Joy4----------- if rto.OutputPort(2).Data(4) == 1 joy4=1; elseif rto.OutputPort(2).Data(2)== 1 joy4=-1; end %--------Joy5----------- if rto.OutputPort(2).Data(5) == 1 joy5=1; elseif rto.OutputPort(2).Data(7)== 1 joy5=-1; end %--------Joy6----------- if rto.OutputPort(2).Data(6) == 1 joy6=1; elseif rto.OutputPort(2).Data(8)== 1 joy6=-1; end % ------------------- joy 1------------------------------- if joy1 == 1 % apreto + cambio=1; motor_pulso_num(1)=motor_pulso_num(1)+n_pulso; elseif joy1 == -1 %msgbox('-1'); %apreto - cambio=1; motor_pulso_num(1)=motor_pulso_num(1)-n_pulso;

ANEXOS

end % ------------------- joy 2------------------------------- if joy2 == 1 % apreto + cambio=1; motor_pulso_num(2)=motor_pulso_num(2)+n_pulso; elseif joy2 == -1 %msgbox('-1'); %apreto - cambio=1; motor_pulso_num(2)=motor_pulso_num(2)-n_pulso; end % ------------------- joy 3------------------------------- if joy3 == 1 % apreto + cambio=1; motor_pulso_num(3)=motor_pulso_num(3)+n_pulso; elseif joy3 == -1 %msgbox('-1'); %apreto - cambio=1; motor_pulso_num(3)=motor_pulso_num(3)-n_pulso; end % ------------------- joy 4------------------------------- if joy4 == 1 % apreto + cambio=1; motor_pulso_num(4)=motor_pulso_num(4)+n_pulso; elseif joy4 == -1 %msgbox('-1'); %apreto - cambio=1; motor_pulso_num(4)=motor_pulso_num(4)-n_pulso; end % ------------------- joy 5------------------------------- if joy5 == 1 % apreto + cambio=1; motor_pulso_num(5)=motor_pulso_num(5)+n_pulso; elseif joy5 == -1

ANEXOS

%msgbox('-1'); %apreto - cambio=1; motor_pulso_num(5)=motor_pulso_num(5)-n_pulso; end % ------------------- joy 6------------------------------- if joy6 == 1 % apreto + cambio=1; motor_pulso_num(6)=motor_pulso_num(6)+n_pulso; elseif joy6 == -1 %msgbox('-1'); %apreto - cambio=1; motor_pulso_num(6)=motor_pulso_num(6)-n_pulso; end % -------------------- Enviar por RS232 ------------------------ if cambio==1 motor_pulso{1}=num2str(motor_pulso_num(1)); motor_pulso{2}=num2str(motor_pulso_num(2)); motor_pulso{3}=num2str(motor_pulso_num(3)); motor_pulso{4}=num2str(motor_pulso_num(4)); motor_pulso{5}=num2str(motor_pulso_num(5)); motor_pulso{6}=num2str(motor_pulso_num(6)); % msgbox(motor_pulso) codigo='0'; error=0; %msgbox(motor_pulso{1}); while ~strcmp(codigo','0000') [error,r,codigo]=mover(Serial_ERC,motor_pulso,velocidad); %msgbox(codigo) if error msgbox('error comuniacion'); break; end pause(0.2); end if error msgbox(codigo); break; end % mostrar en los edit los pulsos de los motores set(findobj('Tag','edit3'),'string',motor_pulso{1}); set(findobj('Tag','edit4'),'string',motor_pulso{2}); set(findobj('Tag','edit5'),'string',motor_pulso{3}); set(findobj('Tag','edit6'),'string',motor_pulso{4});

ANEXOS

set(findobj('Tag','edit7'),'string',motor_pulso{5}); set(findobj('Tag','edit8'),'string',motor_pulso{6}); sim_s=motor_pulso_num(1)*0.0000976778; sim_l=motor_pulso_num(2)*0.000132; sim_u=motor_pulso_num(3)*0.000162897; sim_r=motor_pulso_num(4)*0.0000981747; sim_b=motor_pulso_num(5)*0.0000981747; sim_t=motor_pulso_num(6)*0.0001496; u_nuevo = sim_u + sim_l; set_param('Motoman_3D/S/PosRobot','Value',num2str(sim_s)); set_param('Motoman_3D/L/PosRobot','Value',num2str(sim_l)); set_param('Motoman_3D/U/PosRobot','Value',num2str(u_nuevo)); set_param('Motoman_3D/R/PosRobot','Value',num2str(sim_r)); set_param('Motoman_3D/B/PosRobot','Value',num2str(sim_b)); set_param('Motoman_3D/T/PosRobot','Value',num2str(sim_t)); end pause(0.001); end % --- Executes on button press in pushbutton13. function pushbutton13_Callback(hObject, eventdata, handles) % hObject handle to pushbutton13 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global tiempo_real; tiempo_real=0; open_system('Motoman_3D'); open_system('Motoman_3D/RobotMotomanVR'); set_param(gcs,'SimulationCommand','Start'); set_param('Motoman_3D/S/Constant','Value','1'); set_param('Motoman_3D/L/Constant','Value','1'); set_param('Motoman_3D/U/Constant','Value','1'); set_param('Motoman_3D/R/Constant','Value','1'); set_param('Motoman_3D/B/Constant','Value','1'); set_param('Motoman_3D/T/Constant','Value','1'); %relacion entre eje L y U set_param('Motoman_3D/Simulacion','Value','1'); %openfig('Cinematica.fig'); % --- Executes on button press in pushbutton15. function pushbutton15_Callback(hObject, eventdata, handles) % hObject handle to pushbutton15 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global tiempo_real; tiempo_real=0; set_param('Motoman_3D','SimulationCommand','Stop'); %-------Funcion Comando Mov Serial -------

ANEXOS

function [error , retorno , codigo_retorno] = mover(Serial_ERC,motor_pulso,velocidad) %motor_pulso={1 2 3 4 5 6} string %velocidad=12.54 error=0; ack0 = uint8([16 48]); ack1 = uint8([16 49]); %cabecera SOH (start of header) comando=uint8(1); %Field header number, Subcode number comando=[comando unicode2native('01,000')]; %Start of information STX comando=[comando 2]; %Comando ASCII que se manda a ERC max 256 caracteres %CR = insertar un enter %comando=[comando unicode2native('PMOVJ 10.0,0,0,0,0,0,100,0,0,0,0,0,0,0') 13] % ----------------motores-------------------- ms=unicode2native(motor_pulso{1}); ml=unicode2native(motor_pulso{2}); mu=unicode2native(motor_pulso{3}); mr=unicode2native(motor_pulso{4}); mb=unicode2native(motor_pulso{5}); mt=unicode2native(motor_pulso{6}); vel=unicode2native(velocidad); comando=[comando unicode2native('PMOVJ ') vel 44 ms 44 ml 44 mu 44 mr 44 mb 44 mt 44 unicode2native('0,0,0,0,0,0,0') 13]; %--------------------fin motores---------- %ETX end of text comando=[comando 3]; %calcular tamano para insertar Block check character block_check=uint16(0); tam=length(comando); for k=2:tam block_check=block_check+uint16(comando(k)); end %convierte block_check en uint8 y lo invierte comando=[comando typecast(block_check,'uint8')]; %----------------------------------------------------------- enq=uint8(5); fwrite(Serial_ERC,enq,'uint8'); recibio=0; tout=0; while recibio == 0 && tout < 1000 pause(0.0001); %.1ms tout=tout+1; if Serial_ERC.BytesAvailable>=2 tam = Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); %ack0 if (buf_rec(tam-1)==ack0(1)) && (buf_rec(tam)==ack0(2)) recibio=1; end end end if tout >= 1000 error = 1; return

ANEXOS

end %additemtolistbox(handles.listbox1, char(buf_rec)'); retorno=char(buf_rec)'; %--------------------------------------------------------------- fwrite(Serial_ERC,comando,'uint8'); recibio=0; tout=0; while recibio == 0 && tout < 1000 pause(0.0001); %.1ms tout=tout+1; if Serial_ERC.BytesAvailable>=2 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); if buf_rec(tam-1)==ack1(1) && buf_rec(tam)==ack1(2) %ack1 recibio=1; end end end if tout >= 1000 error = 1; return end %additemtolistbox(handles.listbox1, char(buf_rec)'); retorno=[retorno char(buf_rec)']; %----------------------------------------------------------------- eot=uint8(4); fwrite(Serial_ERC,eot,'uint8'); recibio=0; tout=0; while recibio == 0 && tout < 1000 pause(0.0001); %.1ms tout=tout+1; if Serial_ERC.BytesAvailable>=1 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); %enq if buf_rec(tam)==uint8(5) recibio=1; end end end %additemtolistbox(handles.listbox1, char(buf_rec)'); if tout >= 1000 error = 1; return end retorno=[retorno char(buf_rec)']; %------------------------------------------------------------------ fwrite(Serial_ERC,ack0,'uint8'); % recibe la respuesta del ERC recibio=0; tout=0; while recibio == 0 pause(0.0001); %.1ms tout=tout+1; if Serial_ERC.BytesAvailable>=16 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); codigo_retorno = char(buf_rec(9:12)); if buf_rec(tam-2)==uint8(3) %etx recibio=1; end

ANEXOS

end end %additemtolistbox(handles.listbox1, char(buf_rec)'); if tout >= 1000 error = 1; return end retorno=[retorno char(buf_rec)']; %--------------------------------------------------------------- fwrite(Serial_ERC,ack1,'uint8'); recibio=0; tout=0; while recibio == 0 pause(0.0001); %.1ms tout=tout+1; if Serial_ERC.BytesAvailable>=1 tam=Serial_ERC.BytesAvailable; buf_rec=fread(Serial_ERC,tam,'uint8'); if buf_rec(tam)==uint8(4)%eot recibio=1; end end end %additemtolistbox(handles.listbox1, char(buf_rec)'); if tout >= 1000 error = 1; return end retorno=[retorno char(buf_rec)']; function edit10_Callback(hObject, eventdata, handles) % hObject handle to edit10 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit10 as text % str2double(get(hObject,'String')) returns contents of edit10 as a double % --- Executes during object creation, after setting all properties. function edit10_CreateFcn(hObject, eventdata, handles) % hObject handle to edit10 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in pushbutton17. function pushbutton17_Callback(hObject, eventdata, handles) % hObject handle to pushbutton17 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) function Pos_X_Callback(hObject, eventdata, handles) % hObject handle to Pos_X (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB

ANEXOS

% handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Pos_X as text % str2double(get(hObject,'String')) returns contents of Pos_X as a double % --- Executes during object creation, after setting all properties. function Pos_X_CreateFcn(hObject, eventdata, handles) % hObject handle to Pos_X (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function Pos_Y_Callback(hObject, eventdata, handles) % hObject handle to Pos_Y (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Pos_Y as text % str2double(get(hObject,'String')) returns contents of Pos_Y as a double % --- Executes during object creation, after setting all properties. function Pos_Y_CreateFcn(hObject, eventdata, handles) % hObject handle to Pos_Y (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function Pos_Z_Callback(hObject, eventdata, handles) % hObject handle to Pos_Z (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Pos_Z as text % str2double(get(hObject,'String')) returns contents of Pos_Z as a double % --- Executes during object creation, after setting all properties. function Pos_Z_CreateFcn(hObject, eventdata, handles) % hObject handle to Pos_Z (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function Motor_L_Callback(hObject, eventdata, handles) % hObject handle to Motor_L (see GCBO)

ANEXOS

% eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Motor_L as text % str2double(get(hObject,'String')) returns contents of Motor_L as a double % --- Executes during object creation, after setting all properties. function Motor_L_CreateFcn(hObject, eventdata, handles) % hObject handle to Motor_L (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function Motor_U_Callback(hObject, eventdata, handles) % hObject handle to Motor_U (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Motor_U as text % str2double(get(hObject,'String')) returns contents of Motor_U as a double % --- Executes during object creation, after setting all properties. function Motor_U_CreateFcn(hObject, eventdata, handles) % hObject handle to Motor_U (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function Motor_R_Callback(hObject, eventdata, handles) % hObject handle to Motor_R (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Motor_R as text % str2double(get(hObject,'String')) returns contents of Motor_R as a double % --- Executes during object creation, after setting all properties. function Motor_R_CreateFcn(hObject, eventdata, handles) % hObject handle to Motor_R (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function Motor_B_Callback(hObject, eventdata, handles)

ANEXOS

% hObject handle to Motor_B (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Motor_B as text % str2double(get(hObject,'String')) returns contents of Motor_B as a double % --- Executes during object creation, after setting all properties. function Motor_B_CreateFcn(hObject, eventdata, handles) % hObject handle to Motor_B (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function Motor_T_Callback(hObject, eventdata, handles) % hObject handle to Motor_T (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Motor_T as text % str2double(get(hObject,'String')) returns contents of Motor_T as a double % --- Executes during object creation, after setting all properties. function Motor_T_CreateFcn(hObject, eventdata, handles) % hObject handle to Motor_T (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function Motor_S_Callback(hObject, eventdata, handles) % hObject handle to Motor_S (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of Motor_S as text % str2double(get(hObject,'String')) returns contents of Motor_S as a double % --- Executes during object creation, after setting all properties. function Motor_S_CreateFcn(hObject, eventdata, handles) % hObject handle to Motor_S (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes when user attempts to close figure1.

ANEXOS

function figure1_CloseRequestFcn(hObject, eventdata, handles) % hObject handle to figure1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global ciclo; %set_param('Motoman_3D','SimulationCommand','Stop'); % %close_system('Motoman_3D/RobotMotomanVR'); %close_system('Motoman_3D'); % Hint: delete(hObject) closes the figure stop(ciclo); delete(ciclo); delete(hObject); function ciclo_timer(obj, event, string_arg) global motoman_k3s; global copia; global graf_3d; p_s=get(findobj('Tag','Motor_S'),'String'); p_l=get(findobj('Tag','Motor_L'),'String'); p_u=get(findobj('Tag','Motor_U'),'String'); p_r=get(findobj('Tag','Motor_R'),'String'); p_b=get(findobj('Tag','Motor_B'),'String'); p_t=get(findobj('Tag','Motor_T'),'String'); grafica=findobj('Tag','Grafic'); num_s=str2double(p_s); num_l=str2double(p_l); num_u=str2double(p_u); num_r=str2double(p_r); num_b=str2double(p_b); num_t=str2double(p_t); if copia(1)~=num_s || copia(2)~=num_l || copia(3)~=num_u || copia(4)~=num_r || copia(5)~=num_b || copia(6)~=num_t % temp_b=num_b+pi/2; T=fkine(motoman_k3s,[num_s num_l num_u num_r num_b num_t]); % parece error matlab no reconoce un parametro de dh pos_xyz=T(1:3,4)'; str_x = num2str(pos_xyz(1)); str_y = num2str(pos_xyz(2)); str_z = num2str(pos_xyz(3)); set(findobj('Tag','Pos_X'),'string',str_x); set(findobj('Tag','Pos_Y'),'string',str_y); set(findobj('Tag','Pos_Z'),'string',str_z); plot3(graf_3d,pos_xyz(1),pos_xyz(2),pos_xyz(3),'r.'); copia = [num_s num_l num_u num_r num_b num_t]; end % --- Executes on button press in pushbutton18. function pushbutton18_Callback(hObject, eventdata, handles) % hObject handle to pushbutton18 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) x=get(handles.Pos_X,'String'); y=get(handles.Pos_Y,'String'); z=get(handles.Pos_Z,'String');

ANEXOS

m_s=get(handles.Motor_S,'String'); m_l=get(handles.Motor_L,'String'); m_u=get(handles.Motor_U,'String'); m_r=get(handles.Motor_R,'String'); m_b=get(handles.Motor_B,'String'); m_t=get(handles.Motor_T,'String'); dato=get(handles.uitable3,'Data'); if isempty(dato{1,1}) set(handles.uitable3,'Data', {x y z m_s m_l m_u m_r m_b m_t}); else tam=size(dato); dato(tam(1)+1,:)= {x y z m_s m_l m_u m_r m_b m_t}; set(handles.uitable3,'Data', dato); end % --- Executes on button press in pushbutton19. function pushbutton19_Callback(hObject, eventdata, handles) % hObject handle to pushbutton19 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) view([0 0]); % --- Executes on button press in pushbutton20. function pushbutton20_Callback(hObject, eventdata, handles) % hObject handle to pushbutton20 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) view([0 90]); % --- Executes on button press in pushbutton21. function pushbutton21_Callback(hObject, eventdata, handles) % hObject handle to pushbutton21 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) view([-1 -1 1]); % --- Executes when entered data in editable cell(s) in uitable3. function uitable3_CellEditCallback(hObject, eventdata, handles) % hObject handle to uitable3 (see GCBO) % eventdata structure with the following fields (see UITABLE3) % Indices: row and column indices of the cell(s) edited % PreviousData: previous data for the cell(s) edited % EditData: string(s) entered by the user % NewData: EditData or its converted form set on the Data property. Empty if Data was not changed % Error: error string when failed to convert EditData to appropriate value for Data % handles structure with handles and user data (see GUIDATA) % --- Executes during object creation, after setting all properties. function figure1_CreateFcn(hObject, eventdata, handles) % hObject handle to figure1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called

ANEXOS

% --- Executes during object creation, after setting all properties. function pushbutton18_CreateFcn(hObject, eventdata, handles) % hObject handle to pushbutton18 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % --- Executes on button press in pushbutton22. function pushbutton22_Callback(hObject, eventdata, handles) % hObject handle to pushbutton22 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % --- Executes on button press in pushbutton23. function pushbutton23_Callback(hObject, eventdata, handles) % hObject handle to pushbutton23 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) cla(handles.Grafic); graf_3d=handles.Grafic; plot3(0,0,0,'ro'); grid(handles.Grafic,'on'); axis(handles.Grafic,'vis3d'); box(handles.Grafic,'on'); xlabel(handles.Grafic,'X'); ylabel(handles.Grafic,'Y'); zlabel(handles.Grafic,'Z'); daspect(handles.Grafic,[1 1 1]); %cameratoolbar('Show'); hold(handles.Grafic,'on'); % --- Executes on button press in pushbutton24. function pushbutton24_Callback(hObject, eventdata, handles) % hObject handle to pushbutton24 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) set(handles.uitable3,'Data', {'' '' ''}) % --- Executes on button press in pushbutton25. function pushbutton25_Callback(hObject, eventdata, handles) % hObject handle to pushbutton25 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % --- Executes on button press in pushbutton26. function pushbutton26_Callback(hObject, eventdata, handles) % hObject handle to pushbutton26 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global motoman_k3s; dato=get(handles.uitable3,'Data'); tam=size(dato); tam=tam(1); global angulos; angulos={}; for i=1:tam-1 %if isempty(dato{1,1}) % set(handles.uitable3,'Data', {x y z m_s m_l m_u m_r m_b m_t}); %else % tam=size(dato); % dato(tam(1)+1,:)= {x y z m_s m_l m_u m_r m_b m_t}; % set(handles.uitable3,'Data', dato); %end

ANEXOS

%--------------------------------- x_ini=str2double(dato(i,1)); y_ini=str2double(dato(i,2)); z_ini=str2double(dato(i,3)); x_fin=str2double(dato(i+1,1)); y_fin=str2double(dato(i+1,2)); z_fin=str2double(dato(i+1,3)); %T=fkine(motoman_k3s,[0 0 0 0 pi/2 0]); % el eje b tiene q girar 90 para concordar (problema robotic tool) T=fkine(motoman_k3s,[0 0 0 0 0 0]); % corregido %T0=transl([x_ini y_ini z_ini]); %T1=transl([x_fin y_fin z_fin]); T0=T; T0(1,4)=x_ini; T0(2,4)=y_ini; T0(3,4)=z_ini; T1=T; T1(1,4)=x_fin; T1(2,4)=y_fin; T1(3,4)=z_fin; npuntos=str2double(get(handles.edit20,'String')); m_s=str2double(dato(i,4)); m_l=str2double(dato(i,5)); m_u=str2double(dato(i,6)); m_r=str2double(dato(i,7)); m_b=str2double(dato(i,8)); m_t=str2double(dato(i,9)); ruta=ctraj(T0,T1,npuntos); %plot3(ruta(1,:),ruta(2,:),ruta(3,:),'b.'); %if(isempty(angulos)) angulos{i}=ikine(motoman_k3s,ruta,[m_s m_l m_u m_r m_b m_t]'); %else % angulos={angulos ikine(motoman_k3s,ruta,[m_s m_l m_u m_r m_b m_t]')}; %end %corrige error de limites [0 0 0 0 pi/2 0]' %---Comprueba q genero correctamente---------No es necesario %vec_ang=angulos{i}; pos=fkine(motoman_k3s,angulos{i}); tam=size(pos); tam=tam(3); for a=1:tam plot3(pos(1,4,a),pos(2,4,a),pos(3,4,a),'go'); end end % --- Executes on button press in pushbutton27. function pushbutton27_Callback(hObject, eventdata, handles) % hObject handle to pushbutton27 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)

ANEXOS

global angulos; set_param('Motoman_3D/S/Constant','Value','0'); set_param('Motoman_3D/L/Constant','Value','0'); set_param('Motoman_3D/U/Constant','Value','0'); set_param('Motoman_3D/R/Constant','Value','0'); set_param('Motoman_3D/B/Constant','Value','0'); set_param('Motoman_3D/T/Constant','Value','0'); %relacion entre eje L y U set_param('Motoman_3D/Simulacion','Value','0'); pausa=str2double(get(handles.edit21,'String')); lineas=size(angulos); lineas=lineas(2); for z=1:lineas tam=size(angulos{z}); tam=tam(1); for i=1:tam a_s=num2str(angulos{z}(i,1)); a_l=num2str(angulos{z}(i,2)); a_u=num2str(angulos{z}(i,3)); a_r=num2str(angulos{z}(i,4)); a_b=num2str(angulos{z}(i,5)); a_t=num2str(angulos{z}(i,6)); set_param('Motoman_3D/S/PosRobot','Value',a_s); set_param('Motoman_3D/L/PosRobot','Value',a_l); % inv en vrml set_param('Motoman_3D/U/PosRobot','Value',a_u); % inv en vrml set_param('Motoman_3D/R/PosRobot','Value',a_r); set_param('Motoman_3D/B/PosRobot','Value',a_b); set_param('Motoman_3D/T/PosRobot','Value',a_t); pause(pausa); end end function edit20_Callback(hObject, eventdata, handles) % hObject handle to edit20 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit20 as text % str2double(get(hObject,'String')) returns contents of edit20 as a double % --- Executes during object creation, after setting all properties. function edit20_CreateFcn(hObject, eventdata, handles) % hObject handle to edit20 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit21_Callback(hObject, eventdata, handles) % hObject handle to edit21 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit21 as text % str2double(get(hObject,'String')) returns contents of edit21 as a double

ANEXOS

% --- Executes during object creation, after setting all properties. function edit21_CreateFcn(hObject, eventdata, handles) % hObject handle to edit21 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in pushbutton28. function pushbutton28_Callback(hObject, eventdata, handles) % hObject handle to pushbutton28 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) global Serial_ERC; velocidad=get(handles.edit9,'String'); global angulos; set_param('Motoman_3D/S/Constant','Value','0'); set_param('Motoman_3D/L/Constant','Value','0'); set_param('Motoman_3D/U/Constant','Value','0'); set_param('Motoman_3D/R/Constant','Value','0'); set_param('Motoman_3D/B/Constant','Value','0'); set_param('Motoman_3D/T/Constant','Value','0'); %relacion entre eje L y U set_param('Motoman_3D/Simulacion','Value','0'); pausa=str2double(get(handles.edit21,'String')); lineas=size(angulos); lineas=lineas(2); for z=1:lineas tam=size(angulos{z}); tam=tam(1); for i=1:tam a_s=num2str(angulos{z}(i,1)); a_l=num2str(angulos{z}(i,2)); a_u=num2str(angulos{z}(i,3)); a_r=num2str(angulos{z}(i,4)); a_b=num2str(angulos{z}(i,5)); a_t=num2str(angulos{z}(i,6)); %calcular y transformar a pulsos u_angulo=angulos{z}(i,3)-angulos{z}(i,2); % el angulo q debe girar realmente el eje U => U=-L+U sim_s=fix(angulos{z}(i,1)/0.0000976778); sim_l=fix(angulos{z}(i,2)/0.000132); sim_u=fix(u_angulo/0.000162897); sim_r=fix(angulos{z}(i,4)/0.0000981747); sim_b=fix(angulos{z}(i,5)/0.0000981747); sim_t=fix(angulos{z}(i,6)/0.0001496); % sim_s=motor_pulso_num(1)*0.0000976778; % sim_l=motor_pulso_num(2)*0.000132; % sim_u=-(motor_pulso_num(3)*0.000162897); % sim_r=-(motor_pulso_num(4)*0.0000981747); % sim_b=-(motor_pulso_num(5)*0.0000981747); % sim_t=-(motor_pulso_num(6)*0.0001496); %

ANEXOS

% set_param('Motoman_3D/S/PosRobot','Value',num2str(sim_s)); % set_param('Motoman_3D/L/PosRobot','Value',num2str(sim_l)); %mandar por rs232 motor_pulso{1} = num2str(sim_s); motor_pulso{2} = num2str(sim_l); motor_pulso{3} = num2str(sim_u); motor_pulso{4} = num2str(sim_r); motor_pulso{5} = num2str(sim_b); motor_pulso{6} = num2str(sim_t); codigo='0'; error=0; %msgbox(motor_pulso); while ~strcmp(codigo','0000') [error,r,codigo]=mover(Serial_ERC,motor_pulso,velocidad); %msgbox(codigo) if error msgbox('error comuniacion'); break; end pause(0.2); end % Simulacion 3D set_param('Motoman_3D/S/PosRobot','Value',a_s); set_param('Motoman_3D/L/PosRobot','Value',a_l); % inv en vrml set_param('Motoman_3D/U/PosRobot','Value',a_u); % inv en vrml set_param('Motoman_3D/R/PosRobot','Value',a_r); set_param('Motoman_3D/B/PosRobot','Value',a_b); set_param('Motoman_3D/T/PosRobot','Value',a_t); pause(pausa); end end

ANEXOS

Codigo Matlab – Updategui.m

function varargout = updategui(varargin) %create a run time object that can return the value of the gain block's %output and then put the value in a string. rto = get_param('Motoman_3D/RobotMotomanVR','RuntimeObject'); num_s=rto.InputPort(2).Data(4); % como se esta tomando la senal del RobotMotomanVR ese angulo es invertido % respecto al angulo real del modelo matematico por eso se hizo el % adaptadorVR para cambiar el angulo L,U,B son los 3 ejes corregidos num_l=-rto.InputPort(3).Data(4); num_u=rto.InputPort(4).Data(4); num_r=-rto.InputPort(5).Data(4); num_b=rto.InputPort(6).Data(4); %num_b=-(rto.InputPort(6).Data(4)-pi/2); % parche num_t=-rto.InputPort(7).Data(4); str_s = num2str(num_s); str_l = num2str(num_l); str_u = num2str(num_u); str_r = num2str(num_r); str_b = num2str(num_b); str_t = num2str(num_t); %get a handle to the GUI's 'current state' window txt_s = findobj('Tag','Motor_S'); txt_l = findobj('Tag','Motor_L'); txt_u = findobj('Tag','Motor_U'); txt_r = findobj('Tag','Motor_R'); txt_b = findobj('Tag','Motor_B'); txt_t = findobj('Tag','Motor_T'); %update the gui set(txt_s,'string',str_s); set(txt_l,'string',str_l); set(txt_u,'string',str_u); set(txt_r,'string',str_r); set(txt_b,'string',str_b); set(txt_t,'string',str_t);

ANEXOS

Codigo Simulink->File->Model Properties->Callbacks->StartFcn -

Motoman_3D.mdl

%The GUI handles are by default hidden, turn them on set(0,'ShowHiddenHandles','on'); %Set up the arguments that will go into the gain block event callback listener blk = 'Motoman_3D/RobotMotomanVR'; event = 'PostOutputs'; listener = @updategui; %Create the listener h = add_exec_event_listener(blk, event, listener);

ANEXOS

CURRICULUM VITAE

DATOS PERSONALES

Nombres y Apellidos: Chao Huang Lin

Fecha de nacimiento: 2 de Septiembre de 1989

Lugar de nacimiento: Santa Cruz de la Sierra – Bolivia

CI: 7714433 SC

Estado Civil: Soltero

Domicilio: Av. Argentina esq. Av. Irala # 37

Teléfonos: 3334125 – 70852018

Email: [email protected]

EDUCACIÓN

• Egresado en la carrera de ingeniería Electrónica (2006 - 2010) Universidad: UPSA Tesis: “Diseño e Implementación de un Sistema de Control Cinemático para el Robot Industrial Motoman K3S”

• Bachiller en Humanidades (2005)

Colegio Cristo Rey

CURSOS DE CAPACITACIÓN RECIBIDOS

• Sistema de Control Distribuido SIMATIC – PCS 7 - SIEMENS (Buenos Aires - Argentina) (Junio de 2009)

• PLC Siemens S7-200 (Step 7 Microwin – Wincc Flexible) (Enero de 2009)

• PLC OPTOP 22 (Enero de 2007)

ANEXOS

EXPERIENCIA LABORAL

• Pasantía Profesional en Siemens AG División Industria y Automatización (Marzo – Junio de 2009)

• Ayudante de FISICA UPSA (2008)

• Participación En Promo UPSA (Con certificado merito al compromiso institucional) (Agosto de 2008)

PROYECTOS Y LOGROS ACADÉMICOS UNIVERSITARIOS

• Sistema de control y monitoreo de presión de una red de bombeo de agua potable Primer Lugar (Junio de 2010)

• Sistema de control de grupo Electrógeno Segundo Lugar categoría “ Electrónica y Redes” (Noviembre de 2009)

• Sistema Modularizado de Control y Comunicación Aplicado a Demótica Primer Lugar categoría: “Electrónica y Redes” (Noviembre de 2008)

• Proyecto “MIU S.R.L” con el producto “Enchufe Programable” 3er Lugar en la 4ta Feria de Emprendimiento como miembro del grupo creador de (Junio de 2008)

• Brazo Robótico MOTOKID (microstep) Primer Lugar TecnoUpsa 2006 Ciencia + Tecnología Proyecto: Área: Ciencia Básica primera categoría “Electrónica” (noviembre de 2006)

ANEXOS

BECAS DE ESTUDIOS OBTENIDOS

• Beca a la Excelencia “Primer Lugar compartido” de la Carrera de Ingeniería Electrónica Durante el Periodo I/2010 UPSA Santa Cruz Octubre de 2010

• Beca a la Excelencia “Primer Lugar” de la Carrera de Ingeniería Electrónica Durante el Periodo 2/2006 UPSA Santa Cruz Mayo de 2007

• Beca a la Excelencia “Primer Lugar” de la Carrera de Ingeniería Electrónica Durante el Periodo 1/2006 UPSA Santa Cruz Octubre de 2006.

• Beca Completa de estudio universitario en la UPSA - Premio Futuro CRE. Otorgada por CRE – 1er. Lugar (Noviembre de 2005).

• Beca de Estudio - Concurso Nacional Bachiller UPSA – CAINCO 2005 3er lugar (+ mejor examen en área Matemática) (noviembre de 2005)

• Premio Bachiller Kupel – Unikuljis 2005.(Beca Completa) Primer Lugar (Noviembre de 2005)

• Beca Completa Concurso Departamental Becas “El Deber-PUC 2005” Primer Lugar (octubre de 2005)

LOGROS ACADÉMICOS NIVEL MEDIO

• Diploma de Excelencia: por haber distinguido como alumno sobresaliente (1er Lugar ) Curso: 1ro. de Secundaria – Colegio Cristo Rey (2002)

• Diploma de Excelencia: por haber distinguido como alumno sobresaliente (1er Lugar ) Curso: 2do. de Secundaria – Colegio Cristo Rey (2003)

• Diploma de Excelencia: por haber distinguido como alumno sobresaliente (1er Lugar ) Curso: 3ro. de Secundaria – Colegio Cristo Rey (2004)

ANEXOS

• Diploma de Excelencia: por haber distinguido como alumno sobresaliente (1er Lugar ) Curso: 4to. de Secundaria – Colegio Cristo Rey (2005)

• Primer Lugar (Medalla de ORO) en las Olimpiadas de Química y Física 2003, modalidad Química Teórica – Categoría 2, realizadas en las instalaciones de la UPSA, (septiembre de 2003).

• Primer Lugar(Medalla de ORO) en las Olimpiadas de Química y Física 2004, en la modalidad Mecánica realizadas en la instalaciones de la UPSA, ( septiembre de 2004)

• Primer Lugar en la 1ra OLIMPIADA DE MATEMATICAS organizada por el Colegio Cristo Rey (Octubre de 2004)

• Segundo Lugar en la XXIII TECNO – FEXPO CRISTO REY - AREA QUIMICA TECNOLOGIA organizado por el colegio Cristo Rey. Con el proyecto “Tabla Periódica Virtual” http://es.geocities.com/quimicavirtualll

• (Octubre de 2004)

• Tercer Lugar (Medalla de BRONCE) en la 6ta olimpiada Departamental de Física 2004 efectuado en las instalaciones de de la Universidad UTEPSA, (Octubre de 2004)

• Primer Lugar en la Olimpiada de Física “Año Mundial de la Física 2005” organizado por Fundación Simón I. Patiño - EMI – y colegio Alexander Von Humboldt (Septiembre del 2005)

• Medalla de Plata en la I Olimpiada de Matemática UPSAMat del cuarto Nivel, organizada por la Facultad de Ingeniería de la UPSA. (septiembre de 2005).

• Tercer Lugar (Compartido) (Medalla de BRONCE) en la Olimpiada de Química Física 2005, en la modalidad de Física Teórica – Tema: Electromagnetismo, realizadas en la instalaciones de la UPSA (septiembre de 2005).

• Diploma Mejor Prueba Experimental en la 10ma olimpiada Boliviana de Física. (Olimpiada Nacional) Organizado por la SOBOFI

ANEXOS

IDIOMAS

• Español

• Ingles Básico

• Chino Mandarín Básico

MEMBRECÍAS PROFESIONALES

• Miembro de ASME 2008 (American Society Of Mechanical Engineers) http://www.asme.org/

CONOCIMIENTOS Y HABILIDADES

Sistemas Operativos: DOS Windows 98 Windows 2000 Windows xp Windows vista Windows 7 Linux- Básico

Software: Office 2003 Office 2007 Pspice (Electrónica) Proteus (Electrónica) Step7 MicroWin (PLC S7-200) Step7 (PLC S7-300 S7-400) Wincc Flexible (HMI) Wincc (Scada) Matlab Autocad Autocad Electrical SolidWork

ANEXOS

Lenguaje de programación: C C++ C# Php Java Script PIC C css Assembler pic Ladder (PLC) Microsfot Sql Server

PROYECTOS REALIZADOS

Proyectos de Electrónica y Automatización

• Display Rotacional Pic • Brazo Robótico (programación completa del firmware) PIC • Diseño de pantalla digital para coliseo UPSA • Enchufe programable para encendido automático de equipos eléctricos • Diseño de sistema de seguridad anti atraco para vehículos • Automatic Turn On para encendido automático del PC • Modulo GSM – SMS mediante nokia 6190 ( parte del proyecto: “Sistema

Modularizado de Control y Comunicación Aplicado a Domótica”) • Proyecto Pantalla LED Aire Limpio de la RED MONICA: Comunicación de datos

(Indice de calidad del aire ICA) hacia pantalla LED móvil mediante comunicación GPRS.) (proyecto auspiciado por SWISSCONTACT)

• Virtualización de una estación SCADA

Proyecto de programación

• Sudoku-CH (programa que resuelve y genera sodokus de solución única) www.nicx.host.sk

• Tabla periódica Virtual http://es.geocities.com/quimicavirtualll (actualmente fuera de servicio por cierre de geocities) se migro automáticamente a http://geocities.ws/quimicavirtualll/

• Sistema de Información para restaurant (chifa wonderly) • Rompecabezas puzle (Estructura de Datos) • Sistema completo de administración de socio para club o gimnasio (New Body)

o Control de socio mediante código de barra o Base de datos Sql server o Sistema Multiusuario o Sistema Multiestación (VPN)

Proyecto de Grado: "Diseñar e Implementar un Sistema de Control Cinemático para el Robot...

Engineering

Transcript of Proyecto de Grado: "Diseñar e Implementar un Sistema de Control Cinemático para el Robot...