tesis (5 de noviembre)

INSTITUTO TECNOLÓGICO Y DE ESTUDIOS SUPERIORES DE MONTERREY CAMPUS MONTERREY

DIVISIÓN DE INGENIERÍA Y ARQUITECTURA PROGRAMA DE GRADUADOS EN INGENIERÍA

Implementación de un Control Supervisorio Difuso para el control de posición de un Robot Manipulador Delta.

TESIS

PRESENTADA COMO REQUISITO PARCIAL PARA OBTENER EL GRADO ACADÉMICO DE:

MAESTRO EN CIENCIAS ESPECIALIDAD EN AUTOMATIZACIÓN

POR:

Pedro Armando Juárez Pérez

MONTERREY, N.L. DICIEMBRE DE 2006

INSTITUTO TECNOLÓGICO Y DE ESTUDIOS SUPERIORES DE MONTERREY CAMPUS MONTERREY

DIVISIÓN DE INGENIERÍA Y ARQUITECTURA PROGRAMA DE GRADUADOS EN INGENIERÍA

Los miembros del comité de tesis recomendamos que el presente proyecto de tesis presentado por el Ing. Pedro Armando Juárez Pérez sea aceptado como requisito parcial para obtener el grado académico de:

Maestro en ciencias con

Especialidad en Automatización

Comité de Tesis:

________________________

Dr. Antonio Ramón X Favela Contreras Asesor

________________________

M.C. Manuel G. Cabrera López Sinodal

________________________

M. C. Gilberto Reynoso Meza Sinodal

Aprobado:

________________________

Dr. Francisco R. Ángel Bello A. Director de Programas de Graduados en Ingeniería

Diciembre, 2006

DEDICATORIA

A MIS PADRES Y A MI HERMANA

Por su amor, por su ejemplo,

porque el esfuerzo también ha sido de ellos.

A SUS

Pampa amo unkas

seyok yejyejtsi ichpokatsi

ken ya pan ni tlaltipaktli.

AGRADECIMIENTOS

Mi agradecimiento a todos aquellos que compartieron este espacio y este tiempo conmigo en especial:

Al Dr. Antonio Favela, por su consejo y apoyo como asesor; al M.C. Manuel Cabrera por su apoyo como sinodal en la realización de este proyecto. Al M.C. Gilbeto Reynoso, por su consejo y su apoyo como sinodal. Porque sin él nunca hubiera existido este proyecto ni yo tenido la oportunidad de participar en él. A los alumnos que participaron en el desarrollo del prototipo Delta: Jorge Silvestre, Raúl, Fito, Héctor, Enrique, Víctor, Juan, Mario, Luis Fernando, Pedro, Perkins, Carlos y Jorge. A la MAT por compartir proyectos, tareas, desvelos. Por todo el apoyo y aprendizaje recibido de ellos. A Gil Glz, Luis Carlos y Gerardo por su amistad y compañía en estos dos años en Monterrey. Lo hicieron más fácil. A la AEPI por compartir sueños, por creer que un mundo mejor es posible. Mi agradecimiento a ustedes, en especial a: Lula, Branko, Picos, Cinthia, Kathy, Daniel, Ado, Aldo, Ando, Lizeth, Sandra.

A todos ustedes: ¡Tlaskamatik Miak!

Pedro Armando Juárez Pérez

I

Resumen

En este trabajo se presenta el desarrollo y construcción de un Robot Manipulador Delta y la implementación de una estrategia de control supervisorio difuso sobre el mismo. El controlador difuso genera una ganancia para atenuar o amplificar la referencia en cada una de sus articulaciones a partir del error y de la razón de cambio del mismo. Esta estrategia se compara con la de un PID convencional obteniéndose, en general, un mejor desempeño.

El Robot manipulador Delta pertenece a los robots manipuladores de cadena cinemática cerrada o robots paralelos. Estos robots poseen la particularidad de alcanzar altas aceleraciones debido a las pocas masas implicadas en su movimiento. Además, las fuerzas gravitacionales, fuerzas inerciales y la variabilidad de la masa hacen que la dinámica del robot sea no lineal. Esto obliga a utilizar estrategias de control que tengan un buen desempeño para todas las regiones alcanzables en su espacio de trabajo.

El desarrollo del Robot manipulador Delta es el primer esfuerzo del departamento de Mecatrónica y Automatización del Tecnológico de Monterrey campus Monterrey por generar investigación en implementación de estrategias de control convencionales y no convencionales en este tipo de arquitecturas robóticas.

II

Índice general

Resumen.............................................................................................................................................. I Índice general.................................................................................................................................... II Listado de Figuras........................................................................................................................... IV Listado de Tablas ............................................................................................................................VI 1. Introducción ........................................................................................................ 7

1.1. Definición del Problema y Justificación .............................................................................9 1.2. Hipótesis ..................................................................................................................................9 1.3. Metodología ............................................................................................................................9 1.4. Objetivos ...............................................................................................................................10

1.4.1. Objetivos generales.....................................................................................................10 1.4.2. Objetivos específicos..................................................................................................10

1.5. Alcances .................................................................................................................................10 1.6. Estructura ..............................................................................................................................10

2. Robótica Paralela y Manipulador tipo Delta......................................................11

2.1. Introducción..........................................................................................................................12 2.2. Definición y una Clasificación de Robots Industriales...................................................12 2.3. Robots Paralelos...................................................................................................................13

2.3.1. Arquitecturas ...............................................................................................................14 2.3.2. Espacio alcanzable......................................................................................................17

2.4. Robot Manipulador tipo Delta...........................................................................................19 2.4.1. Aplicaciones.................................................................................................................20 2.4.2. Cinemática....................................................................................................................22 2.4.3. Espacio alcanzable......................................................................................................28 2.4.4. Dinámica ......................................................................................................................30

2.5. Resumen ................................................................................................................................32 3. Desarrollo de un manipulador Delta ................................................................. 33

3.1. Introducción..........................................................................................................................34 3.2. Diseño Mecánico..................................................................................................................35 3.3. Diseño Electrónico ..............................................................................................................37 3.4. Comunicación.......................................................................................................................38

3.4.1. Microcontrolador........................................................................................................38 3.4.2. Interfaz Humano-Máquina........................................................................................40

3.5. Resumen ................................................................................................................................43 4. Implementación de un Control Supervisorio Difuso para un Robot Delta ...... 44

4.1. Introducción..........................................................................................................................45 4.2. Control Clásico .....................................................................................................................45 4.3. Control Difuso......................................................................................................................47

4.3.1. Antecedentes teóricos en el diseño del FKBC.......................................................49 4.3.2. Fuzzificación................................................................................................................49 4.3.3. Mecanismo de Inferencia...........................................................................................50 4.3.4. Defuzzificación ...........................................................................................................52

4.4. Control Supevisorio .............................................................................................................53 4.4.1. Esquema I: Modificar la referencia del sistema......................................................53

III

4.4.2. Esquema II: Ajuste de ganancia de un PID ...........................................................55 4.5. Control Convencional PID implementado......................................................................56 4.6. Control Supervisorio Difuso ..............................................................................................56

4.6.1. Implementación ..........................................................................................................57 4.6.2. Sintonización del control supervisorio difuso........................................................57

4.7. Resumen ................................................................................................................................59 5. Pruebas y análisis de resultados ........................................................................ 60

5.1. Introducción..........................................................................................................................61 5.2. Resultados..............................................................................................................................62

5.2.1. Prueba I ........................................................................................................................62 5.2.2. Prueba II ......................................................................................................................68 5.2.3. Prueba III.....................................................................................................................74

5.3. Análisis de Resultados .........................................................................................................80 6. Conclusiones y perspectivas...............................................................................81

6.1. Introducción..........................................................................................................................82 6.2. Implementación de modelos cinemáticos ........................................................................82 6.3. Implementación de un esquema supervisorio difuso .....................................................82 6.4. Interfaz humano-máquina...................................................................................................82 6.5. Prototipo delta ......................................................................................................................83 6.6. Perspectivas...........................................................................................................................83

Bibliografía ....................................................................................................................................... 85 A. Programación del Controlador Supervisorio Difuso ......................................... 87

A.1 Tesis_Sup_Difuso.c ............................................................................................................ 87 B. Programación de la interfaz................................................................................91

B.1 Interfaz humano-máquina.................................................................................................. 91 B.2 Archivar y guardar datos en Excel .................................................................................. 113 B.3 Interfaz sintonía difuso..................................................................................................... 117

Vita............................................................................................................................128

IV

Listado de Figuras

Figura 2.1. Clasificación de Robots por estructuras cinemáticas.. ...................................................13 Figura 2.2. Algunas estructuras de Robots Paralelos Planares.. .......................................................16 Figura 2.3. Un ejemplo de estructura R-P-(RRR) de un robot paralelo de tres grados de libertad.....................................................................................................................................................................16 Figura 2.4. Star Robot: robot paralelo espacial de tres grados de libertad diseñado por Herve con juntas de tipo helicoidal y paralelogramos. ..................................................................................17 Figura 2.5. Una estructura de robot espacial de seis grados de libertad..........................................17 Figura 2.6. Algunas Estructuras de Robots Paralelos Espaciales de seis grados de libertad. ......18 Figura 2.7. Robot Manipulador Paralelo tipo Delta...........................................................................19 Figura 2.8. Robot Manipulador Paralelo Delta Lineal con actuadores lineales. ............................20 Figura 2.9. SurgiScope. Robot Delta en aplicaciones médicas. ........................................................21 Figura 2.10. IRB 340. Robot con arquitectura delta, una solución de ABB para operaciones de “pick-and-place”......................................................................................................................................21 Figura 2.11. Robots Hitachi Seiki con configuración delta para aplicaciones de (a) “pick-and-place” y (b) perforado CNC ..................................................................................................................22 Figura 2.12: Planteamiento cinemático Delta.. ...................................................................................23 Figura 2.13. Planteamiento cinemático vectorial. ...............................................................................24 Figura 2.14. Espacio de trabajo para un Robot Paralelo tipo Delta. ...............................................28 Figura 2.15. Vistas del espacio de trabajo para un robot Delta........................................................29 Figura 2.16. Diagrama para modelo dinámico....................................................................................30 Figura 3.1. Prototipo desarrollado en el Departamento de Mecatrónica y Automatización del Tecnológico de Monterrey Campus Monterrey .................................................................................34 Figura 3.2. Estructura del prototipo.....................................................................................................35 Figura 3.3. Vista de a) la base fija del manipulador y del b) mecanismo de transmisión de movimiento. .............................................................................................................................................35 Figura 3.4. Vista de los brazos y antebrazos del manipulador..........................................................36 Figura 3.5. Base móvil del manipulador...............................................................................................36 Figura 3.6.Esquemático general de la electrónica, comunicación y control del manipulador Delta. .........................................................................................................................................................37 Figura 3.7. Algoritmo de programación dentro del microcontrolador ATMEL 89C51 ..............39 Figura 3.8 IHM diseñada para el control del manipulador ...............................................................40 Figura 3.9. Detalle de la IHM................................................................................................................41 Figura 3.10. Panel para observar los paquetes enviados y recibidos de la IHM............................41 Figura 3.11. Panel para la sintonía de un control supervisorio difuso. ...........................................42 Figura 3.12. Formato del archivo de Excel para la sintonía del un controlador difuso supervisorio. .............................................................................................................................................43 Figura 4.1. Diagrama de bloques de un esquema de control clásico. ..............................................45 Figura 4.2: Diagrama de bloques de un esquema de control difuso................................................47 Figura 4.3. Estructura del Controlador Difuso...................................................................................48 Figura 4.4. Defuzzificación por Singletons .........................................................................................53 Figura 4.5: Diagrama de bloques del esquema supervisorio I. .........................................................54 Figura 4.6. Esquema supervisorio I.a. ..................................................................................................54 Figura 4.7. Esquema supervisorio I.b...................................................................................................55 Figura 4.8. Esquema Supervisorio II....................................................................................................55 Figura 4.9.Esquema de Control Supervisorio Difuso implementado en el prototipo Delta.......57 Figura 4.10. Conjuntos difusos de entrada..........................................................................................58

V

Figura 4.11. Regla de defuzzificación por Singletons para la acción del supervisorio..................59 Figura 5.1. Número de articulación en el Robot Delta......................................................................62 Figura 5.2. Respuesta articular para la prueba I.1.a. ...........................................................................63 Figura 5.3. Respuesta espacial prueba I.1.a. ........................................................................................64 Figura 5.4. Respuesta articular para (a) la prueba I.2.a. (b) la prueba I.2.b.....................................66 Figura 5.5. Respuesta espacial para (a) la prueba I.2.a. y (b) la prueba I.2.b ..................................67 Figura 5.6. Respuesta articular para (a) la prueba II.1.a. y (b) la prueba II.1.b. .............................69 Figura 5.7. Respuesta espacial para (a) la prueba II.1.a. y (b) la prueba II.1.b. ..............................71 Figura 5.8. Respuesta articular para la prueba II.2.a. .........................................................................72 Figura 5.9. Respuesta espacial para la prueba II.2.a. ..........................................................................73 Figura 5.10. Respuesta articular para la prueba III.1.a.......................................................................75 Figura 5.11. Respuesta espacial para la prueba III.1.a .......................................................................76 Figura 5.12. Respuesta articular para la prueba III.2.b. .....................................................................78 Figura 5.13. Respuesta espacial para la prueba III.2.b.......................................................................79 Figura 6.1. Propuesta de comunicación y control para el Robot Delta construido. .....................83

VI

Listado de Tablas

Tabla 2.1. Espacio alcanzable del robot Delta al variar la posición angular de sus brazos..........30 Tabla 4.1. Funciones de membresía más comunes en el Control Difuso ......................................50 Tabla 4.2. Tabla de implicaciones difusas para dos variables y una salida con granularidad de 7 conjuntos difusos. ...................................................................................................................................52 Tabla 4.3. Tabla de implicaciones difusas para el supervisorio. .......................................................59 Tabla 5.1. Conjunto de pruebas realizadas. .........................................................................................61 Tabla 5.2. Índices de desempeño articular de la prueba I.1.a. ..........................................................62 Tabla 5.3. Índices de desempeño espacial por ejes de la prueba I.1.a.............................................62 Tabla 5.4. Índices de desempeño articular para la prueba I.2.a........................................................65 Tabla 5.5. Índices de desempeño espacial para la prueba I.2.a ........................................................65 Tabla 5.6. Índices de desempeño articular para la prueba I.2.b .......................................................65 Tabla 5.7. Índices de desempeño espacial para la prueba I.2.b ........................................................65 Tabla 5.8. Índices de desempeño articular para la prueba II.1.a. .....................................................68 Tabla 5.9. Índices de desempeño espacial para la prueba II.1.a.......................................................68 Tabla 5.10. Índices de desempeño articular para la prueba II.1.b....................................................70 Tabla 5.11. Índices de desempeño espacial para la prueba II.1.b. ..................................................70 Tabla 5.12. Índices de desempeño articular para la prueba II.2.a. ...................................................70 Tabla 5.13. Índices de desempeño espacial para la prueba II.2.a.....................................................70 Tabla 5.14. Índices de desempeño articular para la prueba III.1.a. .................................................74 Tabla 5.15. Índices de desempeño espacial para la prueba III.1.a. .................................................74 Tabla 5.16. Índices de desempeño articular para la prueba III.2.a ..................................................77 Tabla 5.17. Índices de desempeño espacial para la prueba III.2.a..................................................77

7

1. Introducción

1

8

Hoy en día el uso de robots en la industria es cada vez más común. Existe una gran cantidad de configuraciones de robots y para cada configuración diversas aplicaciones. Estas van desde la simple manipulación de objetos hasta la identificación e inspección de productos.

Se habla de dos grandes familias de robots: los robots de cadena cinemática abierta (robots seriales) y los de cadena cinemática cerrada (robots paralelos). Los primeros se caracterizan por tener uno de los extremos sujeto a la base del robot mientras que el otro está libre y puede ser unido a una herramienta para realizar tareas de ensamble o de manipulación de objetos. Por otra parte, los robots de cadena cinemática cerrada no tienen extremos libres por lo que todos sus extremos forman una cadena cerrada. En años recientes científicos han mostrado un enorme interés en robots con estructuras cerradas [1]

El Robot Manipulador Delta pertenece a la familia de Robots paralelos o de cadena cinemática cerrada. Esta configuración se caracteriza por tener mayor precisión y rigidez, debido a su estructura paralela. Más aún, debido a las pocas masas en movimiento, este robot permite obtener altas aceleraciones por lo que se utiliza en aplicaciones en donde se requiere manipular objetos con gran precisión y velocidad [11].

Además, debido a las fuerzas gravitacionales, las fuerzas inerciales y la variabilidad de la carga que se desplazará, el sistema se vuelve altamente no lineal. Esta característica complica el diseño del esquema de control. Dicho esquema deberá ser lo suficientemente robusto para presentar un buen desempeño independientemente de la zona en la que se esté trabajando. De lo contrario, se tendrá que operar el robot alrededor de un punto de operación donde el esquema de control haya presentado mejores resultados.

Se tiene poca información de esquemas usados para controlar el Robot Manipulador tipo Delta, pero se han usado algunos esquemas de control basados en PID’s tradicionales. Dentro de estos controladores están un PID desacoplado, bastante simple pero con algunas limitantes en su comportamiento; un PID con ante-alimentación, el cual presenta mejores resultados aún cuando se utilice un modelo cinemático inverso simplificado; un PD con linealización ante-alimentada, que no aporta nada diferente al PID con ante-alimentación; un PD ante-alimentado predictivo, el cual repite varias veces una misma trayectoria para predecir el torque de ante-alimentación a utilizar lo cual genera mejores resultados que los anteriores; por último, se ha usado un PD con ante alimentación predictiva, este a diferencia del anterior cambia sus parámetros de acuerdo a la identificación del modelo [21].

Como puede apreciarse, existe información para controladores PID’s. Sin embargo, no existe lo mismo para otros esquemas de control no convencionales como el control difuso. Un esquema de control difuso genera valores cuantitativos a partir del procesamiento de valores cualitativos. Esta clase de control emula el proceso de inferencia del ser humado para tomar decisiones y generar una manipulación a través de estas. La función de un control supervisorio es la de evaluar, mediante la información generada del sistema, el comportamiento del controlador para ajustar valores previamente definidos y así mejorar el desempeño general del sistema.

En [3] se diseñaron los modelos cinemáticos y dinámicos que gobiernan el comportamiento del manipulador Delta. Además, se desarrolló e implementó en simulación un control supervisorio difuso. Este, atenúa o aumenta una ganancia que modifica los parámetros de un control PID convencional a partir de error y del cambio en este.

Es este trabajo de tesis, se sigue con esa propuesta. Se tiene un prototipo de manipulador Delta desarrollado en el departamento de Mecatrónica y Automatización del Tecnológico de Monterrey. En él se implementan los modelos de cinemática inversa y directa del Robot, además se implementa una estrategia de control supervisorio difuso para generar una ganancia que mejore el desempeño de cada articulación y por ende el desempeño general del sistema.

9

1.1. Definición del Problema y Justificación

Se observa un área de oportunidad en cuanto a esquemas de control en la robótica paralela y, en particular, en el robot paralelo tipo Delta. Al ser un robot de reciente diseño (1991), aún no se cuenta con la suficiente información sobre esquemas de control no convencionales diseñados y aplicados especialmente para esta clase de diseño.

Se sabe que en robótica, la mayoría de las aplicaciones de control hacen uso de las técnicas de control no lineal. Sin embargo, técnicas de control como el espacio de estados, el control difuso, entre otros no han sido explotados a pesar de haberse reportado excelentes resultados en la industria. Es por esto que se debe, no sólo diseñar esquemas de control no convencionales, sino implementarlos en modelos reales para comparar sus comportamientos.

Además, se elige el Robot Manipulador Delta con actuadores rotacionales debido a que tiene las características de los manipuladores de estructura cinemática paralela y es una de las más simples.

1.2. Hipótesis

El esquema de control supervisorio difuso implementado en un robot manipulador tipo Delta presenta un mejor desempeño que el uso de técnicas de control convencionales.

1.3. Metodología

Con el objeto de probar la hipótesis de este trabajo se siguió la metodología que se describe a continuación:

1. Analizar y validar la modelación cinemática y dinámica llevada a cabo por [3] tanto a lo referente con el modelo matemático como a las librerías desarrolladas en C++.

2. Analizar los resultados obtenidos en simulación con la estrategia presentada en [3].

3. Diseñar una interfaz para el control de las principales funciones del manipulador.

4. Implementar las librerías de la modelación y de control difuso, además de complementar la interfaz para implementar un control supervisorio difuso.

5. Seleccionar un esquema de control supervisorio difuso capaz de se implementado de acuerdo a las limitaciones de hardware en el prototipo.

6. Desarrollar y programar el algoritmo de supervisión difusa, seleccionado en el punto anterior.

7. Seleccionar una región de trabajo y sintonizar el control PID convencional para dicha región.

8. Sintonizar el control supervisorio difuso.

9. Definir las pruebas que servirán de comparación entre el control PID convencional y el esquema supervisorio propuesto.

10. Realizar las pruebas y analizar resultados.

11. Establecer conclusiones después de haber analizado los resultados del punto 10.

10

1.4. Objetivos

1.4.1. Objetivos generales

Objetivo tecnológico.- Terminar la construcción de un prototipo del manipulador Delta sobre el cual se puedan implementar diferentes esquemas de control.

Objetivo científico.- Diseñar, implementar y evaluar un esquema de control supervisorio difuso para un prototipo de manipulador tipo Delta que mejore el desempeño de un control PID convencional.

1.4.2. Objetivos específicos

Evaluar el estado el prototipo del manipulador Delta, proponer modificaciones, y en su caso, implementarlas para mejorar su diseño mecánico, dinámico electrónico y de comunicación.

Concluir la primera fase del desarrollo del manipulador Delta.

Diseñar e implementar un esquema de control supervisorio difuso a través de software especializado.

Realizar un análisis comparativo entre el esquema supervisorio y el control PID convencional.

1.5. Alcances

El presente trabajo abarcará la conclusión de la fase inicial de desarrollo del manipulador Delta y el diseño e implementación de un control supervisorio difuso sobre este.

1.6. Estructura

La estructura general de este documento es como sigue:

En el capítulo dos se describe de forma general la robótica paralela y una clasificación de robots con esta estructura. Además, en dicho capítulo, se describe y analiza de forma particular el robot manipulador paralelo tipo Delta con actuadores rotacionales. Aquí, se presenta la modelación cinemática y dinámica del mismo. En el capítulo tres se describe el prototipo del manipulador Delta donde se han implementado las estrategias de control. Para el capítulo 4, el lector encontrará los fundamentos de la teoría del control clásico o convencional así como del control difuso. Además, es en este capítulo donde se describe tanto la implementación del control PID convencional, como el diseño y la implementación del algoritmo supervisorio difuso para el manipulador Delta. Los resultados y análisis de las pruebas realizadas con los esquemas de control se presentan en el capítulo cinco. Por último, en el capítulo 6 se finaliza con las conclusiones y líneas futuras de investigación.

11

2. Robótica Paralela y Manipulador tipo Delta

En este capítulo se define y clasifican los robots paralelos o de cadena cinemática cerrada. Además, se realiza una descripción detallada de algunas de las configuraciones de robots paralelos que existen actualmente. Por otro lado, se presenta una descripción del robot manipulador tipo Delta con actuadores rotacionales. Se formulan los modelos cinemáticos y dinámicos que describen el comportamiento del robot en el espacio y que ayudan en la implementación de este trabajo de tesis.

2

12

2.1. Introducción

En años recientes, ha habido gran interés en el estudio de robots paralelos. Su popularidad se debe, en parte, a las ventajas que estos ofrecen sobre su contraparte seriales. Actualmente existen una gran cantidad de configuraciones y de arquitecturas paralelas. Cada una de estas arquitecturas tiene características únicas conservando las ventajas de las arquitecturas paralelas en general.

En este capítulo se hará una introducción a la robótica paralela, se presentará una clasificación para esta clase de arquitecturas; además se enlistarán sus principales características. Al final, se tratará el Robot paralelo tipo Delta, se describirá su configuración y se expondrán sus características. Finalmente, se analizará la cinemática de esta configuración robótica así como su espacio alcanzable.

2.2. Definición y una Clasificación de Robots Industriales

Para definir formalmente a un robot industrial existen ciertas dificultades debido a la evolución de la robótica que ha obligado a actualizar las muchas definiciones que se encuentran. Por ejemplo, la Asociación de Industrias de la Robótica (RIA, por sus siglas en inglés) define al robot industrial como "un manipulador multifuncional reprogramable, capaz de mover materias, piezas, herramientas, o dispositivos especiales, según trayectorias variables, programadas para realizar tareas diversas".

Esta definición es una de las más aceptadas, aunque la palabra manipulador pareciera ser limitada (los robots industriales también pintan, soldan, etc.). Por otro lado, en el sentido estricto, al pintar o soldar se necesita manipular las herramientas necesarias (una brocha, por ejemplo) para realizar dicha tarea (pintar, en este caso). Sin embargo, para propósitos de esta tesis, se definirá al robot industrial como lo propone [8].

Robot Industrial. Sistema mecánico multifuncional con diferentes grados de libertad, multiprográmale y controlado automáticamente.

Por lo general, un robot está compuesto de los siguientes subsistemas:

Mecánico. Consiste en una estructura mecánica la cual se mueve a través de energía eléctrica, hidráulica y/o neumática para transmitir el movimiento a cada una de las uniones del robot. En este subsistema se encuentra el efector final.

Capacidades de percepción. Consiste en los sensores internos que proveen información sobre el estado del robot, así como en los sensores externos para obtener la información del ambiente.

Controlador. Realiza los objetivos de las tareas deseadas. Genera las señales de entrada de los actuadores para lograr llevar al robot al lugar deseado.

Interfaz de comunicación. A través de esta el usuario programa las tareas que el robot debe realizar.

Dispositivos periféricos. Algunos robots cuentan con cámaras de visión u otros dispositivos que constituyen el ambiente del mismo.

13

Ahora bien, existen diferentes formas de clasificar a los robots manipuladores [17]. En este caso, se considerará la clasificación de acuerdo a su estructura cinemática. Pero antes, se presentarán algunas nociones formales [12] que permitirán definir esta clasificación. Para cada eslabón de un manipulador, el grado de conexión es el número de cuerpos rígidos unidos a este por una junta. Así, las cadenas cinemáticas simples, serán aquellas en donde cada miembro de la cadena (eslabón) posee un grado de conexión de al menos dos. De esta forma, los robots manipuladores se pueden clasificar en seriales o de Cadena cinemática abierta (CCA) y en paralelos o de Cadena cinemática cerrada (CCC)

Manipuladores Seriales o de CCA. Consisten en cadenas cinemáticas simples en donde todos los grados de conexión son dos, excepto para dos de ellas, la base y el efector final. Estas últimas cuentan con solo un grado de conexión (ver Figura 2.1 a).

Manipuladores Paralelos o de CCC. Consisten en cadenas cinemáticas simples en donde uno de los eslabones, diferente a la base, posee un grado de conexión mayor a dos (ver Figura 2.1 b).

Puesto que el trabajo de esta tesis trata sobre un robot paralelo, a continuación se describe a detalle este tipo de configuración.

(a)

(b)

Figura 2.1. Clasificación de Robots por estructuras cinemáticas. (a) Manipuladores seriales o de cadena cinemática abierta. (b) Manipuladores paralelos o de cadena cinemática cerrada.

2.3. Robots Paralelos

Las primeras máquinas que se diseñaron con arquitecturas paralelas fueron para realizar pruebas de neumáticos [18] y simuladores de vuelo como la estructura de Stewart [22]. En años recientes, robots con este tipo de arquitecturas comenzaron a llamar la atención, no solo de investigadores sino también de la industria.

Si se toma únicamente la definición expuesta previamente para definir un robot paralelo se estaría considerando también los mecanismos redundantes, los cuales cuentan con menos grados de libertad que actuadores. Lo que aquí interesa es una definición formal como la que propone [7].

14

Robot Paralelo. Es aquél que está compuesto por una base móvil de n grados de libertad generados con n actuadores simples y una base fija. Dichas bases se encuentran unidas por al menos dos cadenas cinemáticas independientes.

Al comparar robots con estructuras paralelas contra robots con estructuras seriales, la discusión se centra en características como el espacio alcanzable, la relación carga/masa del robot, precisión, comportamiento dinámico, entre otras. A continuación se enlistan los principales elementos de comparación:

Espacio alcanzable. Esta se podría considerar una desventaja que tiene la estructura paralela. El espacio alcanzable es relativamente pequeño si se le compara con el de las estructuras seriales. En estructuras paralelas este se determina con la intersección de los espacios de trabajo de todas las cadenas cinemáticas que conforman dicha estructura.

Relación carga-masa del robot. En las estructuras seriales el efector final y, obviamente, el objeto a manipular se encuentran en el extremo de toda la cadena. Como consecuencia, cada actuador necesita la suficiente potencia, no solo para cargar el objeto, sino los eslabones y actuadores que se encuentran en medio. Lo que resulta en una baja relación carga-masa del robot. En cambio, en las estructuras paralelas, la carga del objeto a manipular está soportada directamente por los actuadores; además las articulaciones se pueden colocar cerca de la base fija. Por lo tanto, los eslabones entre la base fija y la base móvil pueden ser más ligeros y la relación carga-masa del robot es mucho mas grande, generalmente con un factor de al menos de 10 [8].

Precisión y Repetibilidad. Los robots seriales van acumulando el error de una articulación a la otra, de igual forma la fricción y la flexibilidad también se comportan de manera serial afectando al error global del robot. En cambio, los robots paralelos no presentan esta situación puesto que el error en vez de acumularse, se divide.

Movimiento espacial. Dentro de los robots paralelos, las arquitecturas ocasionan que haya ciertas regiones dentro de su volumen de trabajo que sean imposibles de alcanzar. Estas regiones se deben a la presencia de singularidades dentro de su espacio de trabajo.

Análisis Cinemático. Para los robots paralelos es más sencillo el análisis cinemático inverso que el directo, a diferencia de los robots seriales donde existe una mayor simplicidad al hacer el análisis cinemático directo.

Dentro de los robots paralelos existen más de 100 diferentes arquitecturas mecánicas [16] propuestas. Es probable que nunca se logren descubrir todas las posibilidades de configuraciones. A continuación se presentan las arquitecturas más comunes en cuanto a robots paralelos se refiere.

2.3.1. Arquitecturas

Debido a las ventajas que ofrecen los robots paralelos con respecto a los seriales, investigadores han tratado de desarrollar diferentes y mejores arquitecturas paralelas. En esta sección, se presentará el diseño de algunas arquitecturas de robots paralelos comenzando por los robots planares terminando con las configuraciones paralelas espaciales. Antes de seguir, cabe mencionar que por convención las juntas de revoluta se representan con un R y las juntas prismáticas con una P.

15

Robots planares

Las estructuras de estos robots están conformadas por juntas prismáticas y de revolutas. Todos los ejes de las juntas de revoluta están perpendiculares al plano de movimiento y los ejes de las juntas prismáticas paralelas al plano de movimiento. Dentro de los robots planares se encuentran los de dos grados de libertad. Se puede demostrar que existen más de veinte configuraciones [15]. Aunque en realidad este tipo de configuraciones no tienen una aplicación práctica dentro de los robots paralelos.

Los que si tienen aplicación y son más utilizados que los anteriores son los robots planares de tres grados de libertad. Están compuestos por una base móvil, la cual se mueve dentro de un plano con tres grados de libertad: dos traslacionales a lo largo de los ejes x y y , otro rotacional a través de un ángulo θ alrededor del eje z perpendicular al plano.

A esta clase de arquitecturas se les conoce como estructuras robóticas completamente paralelas ya que poseen tres cadenas cinemáticas independientes impulsadas por tres actuadores. Cada cadena cinemática está formada por dos cuerpos rígidos unidos por una junta. Las cadenas pueden tener las siguientes secuencias: RPR (Figura 2.2 a), PRR (Figura 2.2 b), RRR (Figura 2.2 c).

Por lo general la base móvil de estas configuraciones tiene la forma de un triángulo. De todas estas configuraciones destaca la 3-RPR que ha sido objeto de estudio y se han reemplazado las cadenas por cables [9] [10].

Robots de movimiento espacial

En general, la plataforma móvil para los robots paralelos espaciales puede tener tres o seis grados de libertad. En el caso de tres grados de libertad, el robot puede posicionar un punto en el espacio. Mientras en el caso de seis grados de libertad el robot puede colocar al efector final en cualquier posición y orientación.

Los robots paralelos espaciales de tres grados de libertad tienen una base móvil conectada a la basé fija por tres brazos. Estos tres grados son excelentes para operaciones de manipulación de objetos [7]. Uno de estos robots es el Robot Manipulador Tipo Delta, objeto de esta tesis, el cuál se detallará más adelante.

Además del Robot Delta, existen otros robots paralelos espaciales de tres grados de libertad. En la mayoría de estos [8] sus brazos están compuestos por una junta de revoluta en un extremo y una esférica en el otro (las juntas esféricas se representan como RRR) (Figura 2.3).

Algunos investigadores han desarrollado diferentes configuraciones de robots paralelos espaciales de tres grados de libertad y les han agregado otro tipo de juntas; como el Star Robot diseñado por Hervé [13] con juntas de tipo helicoidal y de paralelogramos (Figura 2.4). Así existen infinidad de variaciones en cuanto a configuración para robots espaciales de tres grados de libertad. Muchos de ellos son similares al robot Delta con algunas modificaciones a las juntas que utilizan.

En cuanto a los robots de seis grados de libertad, el más representativo es el robot con estructura Gough-Stewart en donde la base fija y la móvil están conectadas por seis brazos movidos por actuadores prismáticos. Este tipo de configuraciones presentan algunas características y variaciones especiales:

16

Figura 2.2. Algunas estructuras de Robots Paralelos Planares. (a) Estructura RPR. (b) Estructura PRR. (c) Estructura RRR.

Figura 2.3. Un ejemplo de estructura R-P-(RRR) de un robot paralelo de tres grados de libertad.

(a) (b)

(c)

17

Figura 2.4. Star Robot: robot paralelo espacial de tres grados de libertad diseñado por Herve con juntas de tipo helicoidal y paralelogramos.

1. La base fija y la móvil son hexágonos. Cada uno de los brazos están unidos a los vértices de las bases (Figura 2.6a).

2. La base fija es un hexágono mientras la base móvil es un triángulo. Dos brazos están conectados a un mismo vértice de la base móvil (Figura 2.6b).

3. La base fija y la móvil son triangulares. Los brazos están conectados en pares en ambos extremos de cada uno de los lados de la base fija hasta cada uno de los vértices de la base móvil. (Figura 2.6c)

La combinación de juntas es variada se pueden lograr configuraciones (RR)-P-(RRR), R-(RR)-(RRR), P-(RRRPP), R-R-P-(RRR), entre otras.

Figura 2.5. Una estructura de robot espacial de seis grados de libertad.

2.3.2. Espacio alcanzable

El espacio alcanzable, como se mencionó antes, es relativamente pequeño si se compara con los robots seriales. Esto se debe a que sus movimientos están restringidos por los límites mecánicos de las juntas pasivas (juntas sin actuadores), interferencia entre los eslabones que forman las articulaciones, y las limitaciones debidas a los actuadores de las estructuras.

18

Una vez que se han determinado todas las posibles posiciones que puede alcanzar el efector final se tienen que representar esas posiciones para formar el espacio del trabajo del robot. En un robot serial, por ejemplo, se puede obtener un espacio 3D puesto que este volumen solo depende de la capacidad de movimiento de las primeras tres articulaciones; mientras la orientación depende de las últimas tres juntas. Esto no ocurre en un robot paralelo de 6 grados de libertad, por ejemplo. Ya que una completa representación del espacio de trabajo sería si se pudiera representar un espacio de 6 dimensiones: los movimientos del efector final también dependen de la orientación de la base móvil. No es posible graficar 6 dimensiones, por lo tanto el espacio de trabajo para un robot paralelo se tiene que representar por "subespacios", los cuales Merlet [7] los llama "Tipos de espacios de trabajo".

Figura 2.6. Algunas Estructuras de Robots Paralelos Espaciales de seis grados de libertad.

(a) (b)

(c)

19

2.4. Robot Manipulador tipo Delta

Dentro de los manipuladores espaciales paralelos de tres grados de libertad hay uno que sobresale de los demás debido a sus características. El Robot Manipulador tipo Delta fue diseñado y patentado por R. Clavel en 19911, con la idea de contar con un robot capaz de alcanzar grandes velocidades y aceleraciones en procesos de manipulación de objetos.

El diseño original está constituido por tres cadenas cinemáticas paralelas unidas a una base móvil, cada una de estas cadenas son dirigidas por tres actuadores de revoluta que se encuentran acoplados a una base fija del robot. El movimiento de la base móvil se logra por la combinación del movimiento de los brazos y transmitido a la base móvil por los antebrazos (sistema de barras paralelas) a través de dos rótulas. La combinación de las contribuciones de las tres cadenas cinemáticas y de los antebrazos provoca que la base móvil siempre se mantenga paralela a la base fija. Idealmente su espacio alcanzable se encuentra en la intersección de las tres esferas provocadas por los tres brazos.

Figura 2.7. Robot Manipulador Paralelo tipo Delta

El Robot Delta, al pertenecer a la familia de estructuras paralelas comparte la característica de tener mayor precisión y rigidez, debido a su estructura paralela. De igual forma, debido a las pocas masas en movimiento, su estructura paralela le permite obtener altas aceleraciones por lo que se utiliza principalmente en aplicaciones en donde se requiere manipular objetos con gran precisión y velocidad [23]. Cabe señalar, que el Robot Delta se caracteriza por ser el más sencillo capaz de manipular objetos en el espacio con una sola orientación. Se tiene documentado que su primera aplicación fue el empaquetamiento de galletas de chocolate [14].

1 Número de patente 4,976,582 EUA

20

El robot Delta tiene una gran cantidad de variantes al diseño original. Una de ellas es el Delta con actuadores lineales (Delta Lineal) (Figura 2.8). Esta configuración resulta de reemplazar los actuadores de revoluta y los brazos con tres actuadores lineales geométricamente paralelos o rieles. Esta configuración da la libertad en la elección de una dimensión del espacio de trabajo. Además permite que la base móvil siempre se encuentre ortogonal a las guías o rieles del robot.

Otra de ellas es el robot Hexa. Aquí la variante radica en que cada brazo ha sido reemplazado por dos brazos. Cada uno de ellos conectado a una rótula del antebrazo correspondiente. Esta estructura tiene entonces seis cadenas cinemáticas para formar un total de seis grados de libertad. Las orientaciones de la base móvil, sin embargo, están limitadas a pequeños ángulos. Algunas otras variantes de han diseñado, se recomienda consultar a [7], ahí se presentan una gran variedad de variantes tanto del robot Delta como en general de los robots paralelos.

Figura 2.8. Robot Manipulador Paralelo Delta Lineal con actuadores lineales.

2.4.1. Aplicaciones

El robot Delta fue introducido al mercado por Demaurex, cuyo objetivo era comercializar el robot para la industria del empaquetamiento (la primera aplicación del robot Delta fue el empaquetamiento de galletas); y por ABB bajo el nombre de IRB 340 FlexPicker. Ahora bien, el robot Delta ofrece diferentes soluciones tanto en aplicaciones industriales como en muchas otras áreas.

Aplicaciones médicas

El robot Delta está siendo utilizado como un contenedor para microscopio. Este robot tiene el nombre de SurgiScope (Figura 2.9). El microscopio pesa aproximadamente 20Kg y el robot SurgiScope es el encargado de cargarlo mientras se realizan las cirugías. Se utiliza principalmente en neurocirugías. El robot está siempre bajo el control del cirujano y su equipo de trabajo.

Aplicaciones industriales

Como se mencionó antes el robot Delta fue diseñado para aplicaciones de manipulación de objetos. Así, el campo fuerte de este tipo de robot son las operaciones llamadas "fast pick-and-

21

place". ABB ha diseñado robots Delta para incorporarse a las industrias alimenticias, farmacéuticas y electrónicas. Su principal modelo es el IRB 340 flexpicker (Figura 2.10).

También existen aplicaciones para el mecanizado, un ejemplo es el robot desarrollado por el grupo Krause and Mauser. Ellos desarrollaron el Quickstep, una fresadora CNC con tres grados de libertad. Además de ellos, la compañía Hitahi Seiki manufactura robots Delta de pequeñas dimensiones para labores de empaquetamiento y perforado. Esta licencia fue concedida por Demaurex.

Así como estos, se pueden enumerar varios ejemplos en la industria de robots con arquitecturas paralelas. Se puede observar que los diseños están hechos para mucho más que meramente aplicaciones de "pick-and-place”.

Figura 2.9. SurgiScope. Robot Delta en aplicaciones médicas.

Figura 2.10. IRB 340. Robot con arquitectura delta, una solución de ABB para operaciones de “pick-and-place”.

22

Figura 2.11. Robots Hitachi Seiki con configuración delta para aplicaciones de (a) “pick-and-place” y (b) perforado CNC

2.4.2. Cinemática

La cinemática del robot estudia el movimiento del mismo con respecto a un sistema de referencia. Se interesa principalmente 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 de la herramienta del robot con los valores que toman las coordenadas de sus articulaciones [2].

Se conocen dos planteamientos de modelos cinemáticos: modelo cinemático directo y modelo cinemático inverso. El primero consiste en determinar la posición y orientación del efector final con respecto al sistema de la base del robot a partir de conocer los valores de las articulaciones y los parámetros geométricos. Mientras que el modelo cinemático inverso consiste en determinar la posición que deben adaptar las articulaciones para que el efector final llegue a una posición conocida.

Una de estas ventajas de los robots paralelos con respecto a los seriales es la simpleza en el análisis de su cinemática inversa, no así para la directa. A continuación se determinan los dos modelos utilizando un análisis geométrico. Las fórmulas y diagramas utilizados también se muestran a continuación.

(a) (b)

23

Figura 2.12: Planteamiento cinemático Delta. (a) Esquema isométrico del Robot Delta. (b) Vista superior del Robot Delta.

De acuerdo en la Figura 2.12:

rO : Centro de la base fija. Punto de referencia.

iA : Punto de unión del brazo de control i con la base móvil.

iB : Punto de unión i del antebrazo de movimiento libre con el brazo i de control.

iC : Punto de unión del antebrazo de movimiento libre i con la base móvil.

EFO : Punto central de la base móvil.

iα : Ángulo que separa al punto iA con 1A .

iθ : El movimiento articular del brazo i del robot

EFR : La distancia iEFCOrr.

RR : La distancia iO AOrr.

RR : La distancia iO AOrr.

a : La distancia iiBArr.

b : La distancia iiCBrr.

Para comenzar a desarrollar el modelo de un Robot Delta se debe considerar cada eslabón-unión por separado. El cuál está definido como la estructura consecutiva comenzando desde el

α

(a) (b)

24

origen de la base fija rO hasta el centro de la unión de uno de los eslabones con la base móvil

EFO (Figura 2.13a).

Figura 2.13. Planteamiento cinemático vectorial.

Y se encuentra la siguiente relación vectorial:

iEFEFRiiiiiR COOOCBBAAO +=++

(2.1)

Ahora bien, se observa que si se quiere ir del punto OR al punto Ai se tiene primero que realiza una translación de magnitud RR en dirección y− y en seguida una rotación positiva

sobre el eje z un ángulo α (Figura 2.12b) . Así, tenemos que el vector iR AO puede escribirse como:

( ) ( )

−

−

=−=

0

0

100

0

0

0,,0, Rii

ii

RiR RCS

SC

RTranszRotAO αααα

α

(2.2)

OR

Ai

Bi

Ci

OEF

RR OR

Bi

Ci

OEF

Ay

Az

-a

θ

θ Az’

Ay'

(a) (b)

25

Siguiendo el mismo procedimiento se plantea el vector ii BA (Figura 2.13b). Primero se

realiza una traslación de magnitud a sobre el eje –Ay. Después con una rotación de θ sobre el eje x se llega al eje coordenado Ai’. Al final, solo es necesario realizar una rotación de α sobre el eje z para llegar al eje coordenado en el punto Bi.

El vector iiBA queda como sigue:

−

−

−

=

0

0

0

0

001

100

0

0

a

CS

SCCS

SC

BA

ii

iiii

ii

ii

θθθθαα

αα

(2.3)

Ahora resolviendo la otra parte de la igualdad de (2.1), primero se definen las componentes de OEF respecto a OR:

=

EFz

EFy

EFx

EFR

O

O

O

OO

(2.4)

De igual forma para iEFCO , haciendo una traslación desde OEF con una magnitud de REF

sobre el eje –y para luego realizar una rotación de magnitud α sobre el eje z, se tiene:

−

−

=

0

0

100

0

0

EFii

ii

iEF RCS

SC

CO αααα

(2.5)

Sustituyendo cada uno de los vectores de la ec. (2.1) la ecuación vectorial queda de la siguiente manera:

26

−

+

=+

−

−+

−

−

0

0

100

0

0.

0

0

0

0

001

0

0

100

0

0

1

EFii

i

EFz

EFy

EFx

ii

ii

iiRii

ii

RCS

SC

O

O

O

CBa

CS

SCRCS

SC

αααα

θθθθαα

αα

(2.6)

A partir de esta ecuación se desarrollará el modelo cinemático tanto inverso como directo. El análisis se muestra a continuación.

Cinemática Directa

Suponiendo que los tres brazos se mueven libres, se plantea que pueden describir tres esferas. En la intersección de estas esferas se encuentra el espacio alcanzable y por lo tanto, el modelo cinemático directo corresponde a la solución de la intersección de las tres esferas. Sabiendo que el centro de cada una de las esferas es Bi=[Bxi Byi Bzi] y b la longitud del brazo se obtienen el siguiente sistema de ecuaciones para cada uno de los brazos:

( ) ( ) ( ) 221

21

21 bBzzByyBxx =−+−+−

(2.7)

( ) ( ) ( ) 222

22


(2.8)

( ) ( ) ( ) 223

23


(2.9)

Restando (2.8) de (2.7) y (2.9) de (2.8) se obtiene:

10131211 azayaxa =++

(2.10)

20232221 azayaxa =++

(2.11)

Donde,

11 ++−= iii BxBxa ,

12 ++−= iii ByBya ,

11 ++−= iii BxBxa ,

2

22

21

22

21

22

21

10

BzBzByByBxBxa

+++++= ,

27

2

23

22

23

22

23

22

20

BzBzByByBxBxa

+++++=

Del sistema simplificado resulta una recta paramétrica

tz =

(2.12)

taaaa

aaaa

aaaa

aaaay

22112112

23112113

22112112

20112110

−

−−

−

−=

(2.13)

ta

a

aaaa

aaaa

a

a

aaaa

aaaa

a

a

a

ax

−

−−

+

−−

−=

11

13

22112112

23112113

11

12

22112112

20112110

11

12

11

10

(2.14)

Basta ahora con introducir estas ecuaciones en cualquiera de las ecuaciones de las tres esferas para encontrar t y después sustituyendo t para encontrar la posición del efector final del manipulador.

Cinemática Inversa

Para encontrar el modelo cinemático inverso las ecuaciones (2.7), (2.8) y (2.9) pueden reescribirse a partir de la ecuación (2.6) como:

( )[ ] ( )( )[ ]( )[ ] 0

coscoscos22

22

=−−−

++−−++−

basenCz

aRCysenaRCx

ii

iiRiiiRi

θ

αθαθ

(2.15)

Para resolver esta ecuación no lineal Reynoso [3] propone utilizar el método de Newton-Raphson con condición inicial ( ) 00 =iθ .

28

( ) ( ) ( )( )( )( )1

11 ' −

−− −=

ni

ni

niniF

F

θθ

θθ

(2.16) 2.4.3. Espacio alcanzable

A la estructura del robot Delta se le puede considerar simple, el cálculo de su espacio de trabajo es equivalente a la intersección de los volúmenes que forma cada articulación. Así, se puede observar que cada articulación describe una esfera de radio la longitud del antebrazo con centro en el codo de la articulación (el punto B). Este centro tiene como lugar geométrico la circunferencia con centro A y de radio la longitud del brazo del robot. La intersección de ambos lugares resulta en un volumen con forma de toroide.

El espacio alcanzable por el efector final es la intersección de los tres volúmenes en forma de toroide que se forman en cada brazo. En la Figura 2.14 se presenta el espacio alcanzable para un Robot Manipulador Delta [3].

Figura 2.14. Espacio de trabajo para un Robot Paralelo tipo Delta.

En [3] se propuso la idea de pensar en un robot paralelo Delta con espacio de trabajo reconfigurable. El volumen del espacio de trabajo alcanzable depende de la configuración de los brazos del robot. Es decir, el espacio de trabajo se modifica al variar α y por ende a la matriz de rotación.

b) Vista superior. a) Vista isométrica.

29

Así, al calcular el volumen de trabajo para diferentes configuraciones se puede crear la

Tabla 2.1. Para todas las configuraciones se realizaron simulaciones para un robot paralelo tipo Delta similar al modelado en [3] donde la distancia entre el actuador al centro de la base fija del manipulador es de 150mm, la longitud del antebrazo de 200mm, la longitud del brazo de 400mm, la distancia del brazo (en el extremo unido a la base móvil) al centro de la base móvil es de 25mm y la distancia del centro de la base fija a cualquiera de los actuadores es de 150mm. En esta tesis se trabajó con un prototipo con dichas dimensiones y una posición angular de sus brazos de 0, 120, -120. Utilizando las ecuaciones para modelar su cinemática se simuló el espacio de trabajo, el cuál se observa en la Figura 2.15. Este espacio se realizó con las limitaciones mecánicas pertinentes.

Figura 2.15. Vistas del espacio de trabajo para un robot Delta

a) b)

c)

30

Configuración Volumen espacio alcanzable

0,120,-120 27,803,000 mm3

0,150,-150 33,524,000 mm3

0,90,-90 32,131,000 mm3

0,60,-60 41,704,000 mm3

Tabla 2.1. Espacio alcanzable del robot Delta al variar la posición angular de sus brazos.

2.4.4. Dinámica

Una parte importante para definir el modelo dinámico de un sistema robótico es la matriz jacobiana. Esta matriz expresa la relación entre las velocidades espaciales y las velocidades angulares (ec. (2.7)) . Utilizando la Figura 2.16. se define la matriz de rotación como se observa en la ec. (2.7).

qJX && =

(2.17)

=

100

0

0

ii

ii

R

i CS

SC

R θθ

θθ

(2.18)

Figura 2.16. Diagrama para modelo dinámico

De acuerdo a [24], la matriz jacobiana que gobierna al manipulador Delta es:

zi yi

xi

Ci

Bi

Oi Ai

qi

LB

LA

31

−=

−

33

22

11

1

3

2

1

00

00

00

bs

bs

bs

s

s

s

JT

T

T

T

T

T

(2.19)

Donde,

iii BCs = ,

=

iA

iA

R

ii

CosqL

SenqL

Rb 0

Para obtener el modelo dinámico del manipulador Delta se hacen las siguientes simplificaciones que no afectan el modelo dinámico obtenido:

Las inercias rotacionales de los antebrazos se desprecian.

Las masas de los antebrazos se separan en 2 porciones colocadas en sus dos extremidades (2/3 en la parte superior: codo) (1/3 en la parte inferior: base móvil).

Los efectos de fricción y elasticidad se desprecian.

Dentro de los parámetros dinámicos se tiene a la masa total a nivel de la base móvil (2.20), al centro de masa del brazo (2.21) y a la inercia total del brazo (2.22) que se conforma por la inercia del motor (Im) y la inercia propia del brazo (2.23). En estos parámetros mn es la masa de la base móvil, mL es la masa de la caga, mab es la masa de los antebrazos, r es la relación de la masa de los antebrazos localizada en la parte superior (2/3), mbr es la masa del brazos y mc la masa del codo.

abLnnt mrmmm )1(3 −++=

(2.20)

abcbr

abcbr

AGbrmmm

rmmmLr

++

++= 2

1

(2.21)

brmbi III +=

(2.22)

++= abc

br

Abr rmmm

LI3

2

(2.23)

32

Así, el robot puede reducirse solamente a 4 cuerpos: la base móvil, y los tres brazos superiores. Además, dos fuerzas actúan sobre la base móvil: las fuerzas gravitacionales Gn y las fuerzas inerciales Fn.

[ ]Tntn gmG −= 00

(2.24)

nntn XmF &&=

(2.25) Por otro lado, se sabe que la relación entre el torque y la fuerza que la produce está dada

por JT. Así, los torques respectivos de Gn y Fn son respectivamente:

n

T

Gn GJ=Γ

(2.26)

n

T

n FJ=Γ

(2.27) Ahora bien, el torque ΓGb producido por las fuerzas gravitacionales de los brazos y la

matriz de inercias de estos en el espacio articular están dados por la ec. (2.28) y por la ec (2.29)

[ ]TGbbGb qqqgrm 321 coscoscos=Γ

(2.28)

=

1

1

1

00

00

00

b

b

b

b

I

I

I

I

(2.29)

Aplicando el principio de trabajo virtual que dice que la contribución de todas las fuerzas no-inerciales deben ser iguales a la contribución de todas las fueras inerciales se tiene que las ecuaciones que describen la dinámica del manipulador están dadas por:

n

T

bGbn

T FJqIGJ +=Γ++Γ &&

(2.30)

n

T

bGbbn

T

bb FJIIGJIIq1111 −−−− −Γ++Γ=&&

(2.31)

2.5. Resumen

Hasta aquí se ha definido y clasificado los robots paralelos o de cadena cinemática cerrada; se han descrito algunas configuraciones de robots paralelos y en particular del Robot Manipulador Delta con actuadores rotacionales. Por otra parte, se ha expuesto su cinemática tanto inversa como directa, su dinámica y su espacio alcanzable. Todo esto, complementa la descripción, definición y análisis matemático del prototipo construido y son herramientas básicas para la implementación de esquemas de control convencionales y no convencionales en este.

33

3. Desarrollo de un manipulador Delta

En este capítulo se expone el prototipo desarrollado en el departamento de Mecatrónica y Automatización del Tecnológico de Monterrey Campus Monterrey y que sirve para la implementación de un control supervisorio difuso expuesto en el capítulo 4. La descripción se realiza en base a tres áreas: diseño mecánico, electrónico y sistema de comunicación. En cada sección se detallan los componentes utilizados, los algoritmos de programación y características físicas del prototipo. Al final del capítulo se describe la interfaz humano-máquina para el control del manipulador.

3

34

3.1. Introducción

Como parte del trabajo de investigación de esta tesis, se ha continuado con la coordinación del proyecto de construcción de un prototipo del Robot Delta con actuadores rotacionales. Este proyecto se ha venido desarrollando en el departamento de Mecatrónica y Automatización del Tecnológico de Monterrey campus Monterrey. El desarrollo de este proyecto permitirá la implementación y evaluación de esquemas avanzados de control como lo son el control adaptable, predictivo y experto; control difuso; control con ante-alimentación, entre otros. Además de contar con otras áreas de desarrollo en robótica como lo puede ser la implementación de sistemas de visión, planeación de trayectorias, etc. El diseño e implementación del prototipo se ha dividido en tres áreas:

Figura 3.1. Prototipo desarrollado en el Departamento de Mecatrónica y Automatización del

Tecnológico de Monterrey Campus Monterrey

Diseño Mecánico.- Aquello relacionado con la estructura mecánica; la selección y ubicación de sensores y demás componentes como el efector final, la o las tarjetas impresas, entre otros; además del diseño y construcción de las articulaciones para el movimiento del robot manipulador delta.

Diseño Electrónico.- Aquello relacionado con toda la circuitería electrónica que permita la comunicación de la computadora con el microcontrolador y del microcontrolador con el movimiento de los motores. Además, que permita el funcionamiento de los diferentes componentes del robot (efector final, sensado de la posición de cero de máquina, de la posición mínima y máxima de cada articulación, entre otros.).

Comunicación.- Aquello relacionado con los protocolos de comunicación entre la computadora y el microcontrolador. Además, está relacionado con la programación de las funciones de la interfaz humano-máquina y de las subrutinas del microcontrolador.

Hasta el término de esta tesis, se ha construido la estructura mecánica que logra el movimiento del robot; se ha implementado un circuito electrónico que permite la comunicación entre el microcontrolador, los filtros PID, y la computadora; se han programado subrutinas sobre un microcontrolador para el control y la comunicación del robot; una interfaz gráfica que permite la interacción entre el usuario y el microcontrolador y un esquema de control convencional para cada una de las tres articulaciones.

35

A continuación se realiza una descripción de cada una de las áreas en las que se ha dividido el prototipo. Cabe resaltar que cada una de las partes que lo componen es modular.

3.2. Diseño Mecánico

La estructura que sostiene a la base fija del prototipo es un perfil PTR cuadrado de acero de 50mm y tiene una altura de 1200mm (ver Figura 3.2). La base fija (perfil angular) que sostiene los motores forma un triángulo equilátero de 320mm por lado. Estos se encuentran a una distancia de 150mm con respecto al centro de la misma Figura 3.3 (a).

Figura 3.2. Estructura del prototipo

a)

b)

Figura 3.3. Vista de a) la base fija del manipulador y del b) mecanismo de transmisión de movimiento.

Por otro lado, los brazos y los antebrazos están hechos de barras redondas de aluminio de 12.7mm (½’’) y 9.525mm (3/8’’) de diámetro respectivamente. La longitud total de cada brazo es de 200mm, mientras que la longitud total de cada antebrazo es de 400mm. La unión entre estos dos elementos se realiza mediante 2 rótulas de 9.525mm (3/8’’) con rosca fina de 24 hilos (ver Figura 3.4).

36

a) Unión entres los dos elementos.

b) Brazo y antebrazo.

Figura 3.4. Vista de los brazos y antebrazos del manipulador.

En uno de los extremos de los antebrazos se encuentra la base móvil donde se acopla el efector final del robot Delta. La distancia entre el extremo del antebrazo unido a la base móvil y el centro de esta es de 25mm. En la Figura 3.5 se muestra tanto la base móvil, su unión con el antebrazo y el efector final.

Los motores utilizados para mover cada una de las articulaciones del robot Delta utilizan 24VCD de alimentación, soportan una corriente de 2A y una potencia de 22W. Su velocidad máxima es de 3200rpm. Además, estos motores, se encuentran acoplados a los brazos del robot por un tren de reducción 200:1 y una banda que transmite el movimiento de los motores a las articulaciones (ver Figura 3.3).

a) Vista superior.

b) Vista lateral.

Figura 3.5. Base móvil del manipulador.

Se han colocado en los actuadores 6 sensores ópticos (dos por cada brazo) para detectar la posición máxima y mínima de cada articulación e impedir que estos puedan llegar a posiciones indeseables que aumente el torque y dañen algún componente. Sobre uno de los engranes cónicos, que transmiten el movimiento al brazo, se colocó una placa de metal que interrumpe la señal de los sensores. Además, estos sensores son elementales para llevar al robot a la posición cero. La colocación de estos sensores puede variar de acuerdo a las necesidades del sistema.

El espacio alcanzable del robot es de 27, 803,000 mm3 de acuerdo con simulaciones realizadas en [3]. Encontrándose su centro en ( ) ( )mmzyx 500,0,0,, −= .

37

3.3. Diseño Electrónico

En cuanto al diseño electrónico, se tienen cuatro componentes principales:

Microcontrolador ATMEL 80C51

1 GAL (L16V8)

3 integrados LMD 18200 y

3 filtros PID LM 629.

Cada motor en cada una de las articulaciones se acciona a través del integrado LMD 18200. Este integrado es un puente H de 3A y 55VCD diseñado para aplicaciones de control de movimiento. Este puente H recibe un ancho de pulso modulable de 5VCD para transmitir de igual forma un ancho de pulso modulable con el voltaje necesario para el motor (en este caso 24VCD).

El control de posición de los actuadores se realiza por medio del integrado LM629. Este integrado es un filtro PID que maneja una ecuación de manipulación digital (ver capitulo 4) Su salida es una señal de ancho de pulso modulable de 8 bits que alimenta al puente H para accionar los actuadores. En este integrado el error entre la referencia y el estado actual se maneja de forma interna, por lo que no se puede modificar. Sin embargo, el valor del error en cada instante de muestreo se puede conocer.

Además, es utilizado un microcontrolador ATMEL 80C51 donde se encuentran programas la mayor parte de las subrutinas de manipulación y comunicación del robot con una interfaz humano-máquina realizada sobre la plataforma LabWindows de National Instruments (NI).

Por otro lado existe un GAL L16V8 donde está programada la rutina para mandar al robot a su posición “cero” ( ( ) ( )mmzyx 150,0,0,, −= con la utilización de los 6 sensores ópticos que determinan la llegada de cada brazo a la posición deseada. Esta rutina inicia cuando se pulsa un botón que se encuentra en el circuito.

Puesto que se ha desarrollado una interfaz, se utiliza una conexión RS232 para interactuar entre el microcontrolador y una computadora personal. En la siguiente sección se describen las subrutinas programadas, el algoritmo de programación, los protocolos entre el microcontrolador y la computadora, y el microcontrolador y los LM629.

Figura 3.6.Esquemático general de la electrónica, comunicación y control del manipulador Delta.

M 3 M 2

IHM

Microcontrolador ATMEL 89C51

Filtro PID LM 629

Filtro PID LM 629

Filtro PID LM 629

Comunicación serial

Puente H

LMD 18200

Puente H

LMD 18200

Puente H

LMD 18200

M 1

GAL L16V8

38

3.4. Comunicación

Esta área es la que lleva a cabo la comunicación entre los filtros PID LM 629 y el microcontrolador y de este con la computadora a través de una Interfaz Humano-Máquina. (IHM) En este sistema, el microcontrolador es en realidad el que lleva a cabo el control general del robot. Es decir, en él se encuentran programadas todas las rutinas que permitan al robot moverse. La IHM es solamente para mostrar la recepción de información generada por el microcontrolador y para establecer los puntos articulares de referencia.

3.4.1. Microcontrolador

Como ya se indicó, el microcontrolador utilizado es el ATMEL 89C51. En la Figura 3.7 puede observarse el algoritmo de programación. Se pueden identificar las siguientes rutinas programadas:

Recepción de la IHM. En esta subrutina se reciben los paquetes de datos enviados desde la IHM. Una vez recibidos se valida la información y en caso se ser válida se procede a identificar si los datos son para actualizar posiciones o parámetros de los LM629.

Transmisión a la IHM. Su función es enviar las posiciones actuales de las articulaciones en cada periodo de muestreo.

Escritura a PID’s. En esta subrutina se actualizan las posiciones de los integrados LM629.

Lectura de posición. Desde esta subrutina se obtienen las posiciones actuales de las articulaciones desde los LM629 en forma de cuentas. Estas cuentas son procesadas y enviadas a la IHM en la subrutina de Transmisión.

Inicialización de sistema. Esa subrutina es una de las más importantes. En ella se configura al microcontrolador (inicializar sus registros, su modo serial, habilitar las interrupciones, etc.) Además, configura los parámetros predefinidos de los LM629 (define posición inicial como el cero, límite de velocidad igual a 3200rpm, el límite de aceleración igual 507 rps2).

Rutina de cero de máquina. Esta subrutina coloca los pid’s en modo velocidad. Es decir, manda la instrucción a los LM629 para mover las articulaciones hacia arriba a una velocidad definida hasta que la GAL envía al microcontrolador la señal que las articulaciones ya llegaron a su posición origen.

Los datos que son enviados o recibidos por el microcontrolador hacia o desde la IHM tienen una estructura que puede variar en tamaño según sea el caso. En el caso de recibir o enviar posiciones el paquete es de 8 bytes y la estructura en hexadecimal es la siguiente:

0F-Lo3-Hi3-Lo2-Hi2-Lo1-Hi1-AA

donde el primer byte es la identificación del paquete. Los siguientes 5 bytes son la parte alta y baja de las posiciones de cada actuador convertidas en cuentas de encoder. Es decir, las posiciones se envían en 2 bytes. El último byte indica el fin del paquete.

39

Figura 3.7. Algoritmo de programación dentro del microcontrolador ATMEL 89C51

Para el caso de parámetros de PID el paquete es de 20 bytes donde el primer byte es de identificación y los siguientes 18 son la parte alta y baja de los tres parámetros del controlador para cada LM629. La estructura se muestra a continuación:

0F-Kd3lo-Kd3Hi-Ki3Lo-Ki3Hi-Kp3Lo-Kp3Hi

-Kd2lo-Kd2Hi-Ki2Lo-Ki2Hi-Kp2Lo-Kp2Hi

-Kd1lo-Kd1Hi-Ki1Lo-Ki1Hi-Kp1Lo-Kp1Hi-BB

Inicio

Inicializar Sistema

Espera a recibir datos

¿Los datos recibidos son parámetros?

¿Los datos recibidos son posiciones?

Escribir parámetros

a los tres PID’s

Escribir posiciones

a los tres PID’s

Cero de Robot

Leer posiciones de los tres encoders

Transmitir posiciones a P.C.

No No

Si Si

40

3.4.2. Interfaz Humano-Máquina

Para la interacción con el robot se diseñó una interfaz sobre la plataforma LabWindows (ver Figura 3.8). Esta provee al usuario la capacidad de mover al robot, observar y guardar las trayectorias mediante gráficas, así como de configurar los parámetros y esquemas de control desde una computadora.

Figura 3.8 IHM diseñada para el control del manipulador

La interfaz cuenta con un intervalo de reloj ajustable. En cada intervalo se envían las 3 posiciones deseadas para asegurar la recepción continua de las posiciones actuales. Desde luego, el envío de paquetes hacia el microcontrolador se realiza con la estructura descrita en la sección 3.4.1. Los paquetes enviados al microcontrolador pueden ser posiciones deseadas o parámetros del PID y recibe posición actual de cada articulación.

En la parte central de la interfaz se encuentran distribuidas tres áreas de graficado para cada articulación. En cada una de estas áreas se grafica la referencia y la posición actual de la articulación correspondiente a la gráfica. Además, en la parte superior se encuentran tres paneles (ver Figura 3.9.a) con casillas para modificar la referencia de cada articulación. Es decir, cada articulación puede moverse individuamente. Por otro lado, no sólo se puede modificar la referencia sino los parámetros kp, ki y kd de las tres articulaciones también individualmente. En lo paneles además se despliega el error hasta dos instantes de muestreo atrás.

Desde la parte inferior de la interfaz se encuentran controles (ver Figura 3.9.b) para mover al robot espacialmente. Automáticamente, al introducir una posición espacial, la interfaz envía las referencias a cada articulación para llegar a la posición espacial indicada. Además, se puede obtener la posición espacial actual a partir de las posiciones de cada una de las articulaciones. Para esto, se hizo uso de las librerías para LabWinbdows realizadas en [3].

41

Por otro lado, la interfaz tiene la capacidad para archivar y guardar datos (ver Figura 3.9.c) en un archivo de Excel. En este archivo se almacena la referencia, la posición actual, el error y el cambio en el error para cada una de las tres articulaciones. Además, crea tres gráficas para la referencia y la posición de cada articulación. También desde la interfaz se puede observar los paquetes enviados y recibidos al presionar el botón de “ver comunicación”.

En la parte derecha de la interfaz se encuentran los elementos para la sintonía y la selección de la estrategia del control (ver Figura 3.9.d). Los parámetros de los PID’s se envían al presionar el botón de “Cargar PID’s”. Al accionar el control supevisorio difuso o presionar el botón “Sintonizar CSD” aparece un panel para la sintonía de este (ver Figura 3.11). La IHM permite generar un control difuso para el control de la posición del manipulador Delta a partir de la implementación de las librerías también realizadas por [3].

a)

b)

c)

d)

Figura 3.9. Detalle de la IHM

Figura 3.10. Panel para observar los paquetes enviados y recibidos de la IHM.

42

Por otro lado, para llenar las tres tablas se pueden cargar las funciones de membresía, las tablas de inferencia y los valores de cada singleton desde un archivo en Excel con un formato ya definido (ver Figura 3.12). Esto con el fin de reducir el tiempo en el llenado de la tabla y facilitar la visualización de las funciones de membresía, lo que el panel de sintonía no lo puede dar. Para el manejo de los archivos en Excel, se creó un menú desde el cuál se podrá abrir un archivo, cargar los parámetros (llenado de las tablas) de un archivo existente ó incluso guardar los parámetros a un archivo existente.

Figura 3.11. Panel para la sintonía de un control supervisorio difuso.

43

Figura 3.12. Formato del archivo de Excel para la sintonía de un controlador difuso supervisorio.

3.5. Resumen

En este capítulo se ha descrito de manera general el prototipo desarrollado para la implementación de estrategias de control avanzado. La descripción se ha realizado en tres áreas: diseño mecánico, electrónico y sistema de comunicación. En cada una de las secciones se exponen las características de cada una de ellas, adentrándose en la descripción de la planta que será controlada. Lo anterior es importante porque define muchas de las características del control supervisorio difuso implementado.

44

4. Implementación de un Control Supervisorio Difuso para un Robot Delta

En la primer parte de este capítulo se exponen los conceptos necesarios de la teoría de control PID convencional y del control difuso. Además, se define el concepto de control supervisorio y se presentan algunos esquemas supervisorios implementables. En la segunda parte del capítulo se presenta la ecuación discreta del control PID convencional, implementada en el prototipo, así como su sintonía. Por otro lado, se describe el esquema de control supevisorio difuso implementado para mejorar el desempeño del PID convencional. Se muestran los conjuntos difusos de entrada y de salida; las funciones de membresía para cada variable de entrada; las reglas de inferencia y el esquema singletons utilizado en el proceso de defuzzificación.

4

45

4.1. Introducción

A través de los años muchas técnicas de control se han desarrollado debido al aumento en los criterios de desempeño y a la complejidad de los sistemas. Otras, sin embargo, han prevalecido a lo largo de los años debido a su sencillez y fácil sintonía. De igual forma, en muchas ocasiones los investigadores se han visto en la necesitad de combinar dos o mas técnicas para lograr los parámetros de desempeño requeridos.

En la primer parte de este capítulo se exponen tres técnicas de control. Primero se abordará el control clásico, una técnica que ha perdurado a lo largo de los años debido, en parte, a su simplicidad para sintonizar y presentar un buen desempeño para la mayoría de los sistemas.

Por otro lado, se hará una introducción a los principales conceptos del control difuso y a la lógica detrás de este. Se analizarán los pasos para diseñar un controlador difuso como son la fuzzificación, la inferencia y la defuzzificación.

Además, se introducirá el concepto de control supervisorio difuso además de algunos esquemas que procesan el error del sistema para generar acciones que mejoren el comportamiento general del mismo.

En la segunda parte de este capítulo El Robot manipulador tipo Delta construido tiene un esquema de control convencional para la posición de su efector final. Como se mencionó en lel capítulo 3 los 3 integrados LM629 son filtros PID, uno para cada articulación. Este esquema es insuficiente tomando en cuenta que el sistema es no lineal. En este capítulo, además de describir el control de posición actual con el que cuenta el Robot, se definirá un esquema de control supervisorio para su posición. Este esquema utiliza un controlador difuso para mejorar el desempeño del control actual en regiones donde la sintonía de este ha dejado de ser óptima.

4.2. Control Clásico

Cuando hablamos de Control Clásico, nos referimos a aquél control que utiliza controladores PID. En estos controladores, llamados controladores convencionales, se pueden distinguir tres acciones básicas de control: la acción Proporcional, la acción Integral y la acción Derivativa

[4]. Todas estas acciones, en conjunto, producen una señal de control para corregir el error en la variable del proceso (variable de interés a controlar). A continuación se describe cada una de estas acciones.

Figura 4.1. Diagrama de bloques de un esquema de control clásico.

u(t) y(t) +

- PID Planta

Referencia e(t)

46

a) Acción de control proporcional (P)

Básicamente se comporta como un amplificador con ganancia ajustable. Se genera una señal de control (acción de manipulación) proporcional al tamaño del error. A medida que el error crece o decrece la acción proporcional cambia el valor de la manipulación. Cuando el error deja de cambiar, la señal de manipulación también lo hace, por lo que se genera un error en estado estable. Matemáticamente esta señal de manipulación se expresa como se muestra en la ecuación (4.1).

)()( teKtu p=

(4.1) b) Acción de control proporcional Derivativo (PD)

La acción de este controlador en ocasiones se llama control de velocidad, y se presenta cuando el valor de salida del controlador es proporcional a la velocidad de variación de la señal de error. El tiempo derivativo dτ se refiere al intervalo de tiempo en el que la acción de

derivativa se adelanta al efecto de la acción proporcional. La acción de este controlador se representa como se muestra en la ecuación (4.2). Esta ecuación también se puede representar como aparece en la ecuación (4.3) donde dpd KK τ= .

+=

dt

tdetektu dp

)()()( τ

(4.2)

dt

tdeKtektu dp

)()()( +=

(4.3) c) Acción de control proporcional integral (PI)

Esta acción mantiene o regresa la variable del proceso al valor de la referencia, es decir elimina el error en estado estable causado por utilizar solamente la acción proporcional. Siempre que exista un error, la salida del manipulación se incrementará o decrementará (integrará) a una velocidad proporcional al tamaño del error existente. Mientras más grande sea el error, mayor será la velocidad de cambio en la salida. Matemáticamente, la acción integral se expresa como iτ (cte. de tiempo integral) como se muestra en las ecuaciones (4.4) y (4.5),

donde Ki=Kp/τi

+= ∫

t

oi

p dtteteKtu )(1

)()(τ

(4.4)

∫+=t

o

ip dtteKteKtu )()()(

(4.5)

47

Una modificación en KP afecta tanto a la parte integral como a la proporcional de la acción de control.

d) Acción de control proporcional integral derivativo (PID)

Básicamente esta acción tiene las ventajas y características de las acciones individuales arriba mencionadas. Así, esta acción se representa como se muestra en las ecuaciones (4.6) y (4.7).

++= ∫

t

d

i

pdt

tdedtteteKtu

0

)()(

1)()( τ

τ

(4.6)

∫ ++=t

dipdt

tdeKdtteKteKtu

0

)()()()(

(4.7)

Su representación en el dominio del Laplace queda descrita matemáticamente como se muestra en la ecuación (4.8).

)()( sEsKs

KKsU d

i

p

++=

(4.8)

4.3. Control Difuso

En esta sección se presenta de forma resumida las bases teóricas del control difuso (en inglés fuzzy control) que se basa en la teoría de lógica difusa. En el control difuso las variables de entrada y salida se procesan de forma cualitativa en vez de hacerlo cuantitativamente. Esto quiere decir que una acción de control deja de medirse en términos de litros, voltaje, grados centígrados, etc. para manejar términos como abundante agua, muy caliente, etc. Así, un control difuso emula el proceso de inferencia humana utilizando un conjunto de reglas lingüísticas como acciones de control sobre el proceso que satisfagan las necesidades y requerimientos del sistema.

Figura 4.2: Diagrama de bloques de un esquema de control difuso

u(t) y(t) +

-

Planta Referencia e(t)

Controlador Difuso

48

Para poder desarrollar un controlador difuso primero se toma como base el modelo FKBC (Fuzzy Knowledge Base Control)[6] que se divide en tres etapas: la fuzzificación, el mecanismo de inferencia y la defuzzificación (Figura 4.3). Primero se plantean los antecedentes, es decir traducir las variables cuantificables en elementos cualitativos. A esto se le conoce con el nombre de fuzzificación. Después, el mecanismo de inferencia obtiene conclusiones o consecuentes a partir de los antecedentes (variables fuzzificadas). Como éstas variables fuzzicadas todavía no son cuantificables, es necesario pasarlas a través de un proceso de defuzzificación para poder utilizarlas como una acción de control.

Para un mejor entendimiento de este esquema de control, a continuación se describen los antecedentes y cada una de las etapas incorporadas al FKBC.

Figura 4.3. Estructura del Controlador Difuso

Defuzzificación

Fuzzificación Conjuntos de

Entrada

Variables

µ

Conjuntos de Reglas Lingüísticas

Mecanismo de Inferencia

Conjuntos de Salida

49

4.3.1. Antecedentes teóricos en el diseño del FKBC

La lógica clásica se puede llamar como binaria o bivalente, es decir que solo acepta dos valores: verdadero y falso. En la lógica difusa una proposición admite varios valores de verdad posible: Si A es una proposición, se le puede asociar un número µA en el intervalo [0,1] tal que:

Si µA=0 entonces A es totalmente falso.

Si µA=1 entonces A es totalmente verdadero.

La veracidad de A aumenta con µA

Se podría decir que hay una semejanza con la teoría de la probabilidad, sin embargo persiguen distintos fines. La lógica difusa se centra en la pertenencia a un grado. Así, un delantero que anota 20 goles por torneo claramente es un delantero muy bueno (es muy bueno con grado 1) y un delantero que anota 0 goles por torneo no es en absoluto muy bueno (es muy bueno en grado 0). En cambio un delantero que anota 17 goles por torneo es muy bueno en grado 0.80 (es decir se está indicando que es bastante bueno). Por el contrario en la lógica clásica se definiría la pertenencia al conjunto de jugadores muy buenos hasta por un gol, es decir o es un jugador muy bueno (anotó 20 goles) o no es un jugador muy bueno (anotó 17 goles o anotó 0 goles).

Por otro lado, la vida diaria se encuentra llena de clasificaciones como “los delanteros muy buenos” o “los días con lluvia moderada. Para estas clasificaciones inciertas (¿cuánto tiene que llover para ser una lluvia moderada?) se hace uso de los conjuntos difusos para poder trabajar desde una base analítica. Así, un conjunto difuso puede contener elementos de forma parcial. Es decir que la propiedad de pertenencia puede ser cierta con un grado de verdad al que se le conoce como grado de membresía [19]. Este grado de membresía mide esta posibilidad de pertenencia con un número µA(x) (función de membresía) entre 0 y 1. Así, se define.

Conjuntos Difuso. Un conjunto difuso A en el universo X es un conjunto definido por una función de membresía:

}1,0{: →XAµ .

(4.9)

Donde el valor de µA(x) para el conjunto difuso A es llamado grado de membresía de Xx∈ .

En la teoría de conjuntos difusos se definen también las operaciones de unión, intersección, complemento, entre otras que se describirán en la sección 4.3.3.

4.3.2. Fuzzificación

En esta etapa se mapean los datos reales de entrada (variables cuantitativas) en conjuntos difusos (variables cualitativas) al utilizar funciones de membresía adecuadas para minimizar los posibles cambios pequeños en las variables de entrada. Por ejemplo, si medimos 25ºC de temperatura, ésta puede variar mientras se efectúa la inferencia (segunda etapa del proceso) por lo que puede ser más exacto considerar que la temperatura es “aproximadamente 25ºC”.

50

Dentro de las funciones de membresía la más utilizada es la trapezoidal, debido a que seleccionando adecuadamente sus parámetros puede configurarse para construir otras funciones de membresía como la triangular, la gamma y la L (ver Tabla 4.1)

Función de

Membresía Parámetros

Trapezoidal α≠β≠γ≠δ

Triangular β= γ

Γ γ=δ

L α=β

Tabla 4.1. Funciones de membresía más comunes en el Control Difuso

La función trapezoidal está definida por cuatro parámetros. En el primero y cuarto se define la base del trapecio y es ahí donde la variable posee un grado de membresía de 0, mientras que en los otros dos se define el segmento donde la variable posee un grado de membresía de 1.

4.3.3. Mecanismo de Inferencia

Esta etapa es el núcleo del controlador difuso, ya que infiere (como su nombre lo indica) las acciones de control simulando el proceso de decisión humano usando las implicaciones difusas y las reglas de inferencia de la lógica difusa. Al utilizar estos procedimientos se llega a la inferencia de resultados. La finalidad del mecanismo de inferencia es formar expresiones o reglas heurísticas de la siguiente forma:

Si [ antecedente 1 ] y…y [ antecedente n ] entonces [ consecuente 1 ] y…y [ consecuente n ]

51

Los antecedentes los obtiene de las variables de entrada que ya han pasado por el proceso de fuzzificación, mientras que los resultados que infiere se les llaman consecuentes. Tanto los antecedentes como los consecuentes son conjuntos difusos de entradas y de salidas respectivamente.

Para llegar a los consecuentes, el mecanismo de inferencia utiliza operadores e implicaciones difusas, los cuales toman en cuenta los grados de membresía de las variables de entrada. Al igual que en la lógica clásica se hacen uso de los operadores de unión, intersección y complemento. Zadeh definió estos operadores de la siguiente forma:

Unión

( ) ( ) ( )},{ uumáxu BABA µµµ =∪

(4.10)

Intersección

( ) ( ) ( )},{ uumínu BABA µµµ =∩

(4.11)

Complemento

( ) ( )uu AAµµ −=1'

(4.12)

Ahora bien, para relacionar los antecedentes con los consecuentes se hace uso de las implicaciones difusas; la más utilizada es la implicación de Mamdani que se muestra a continuación:

Implicación de Mamdani

( ) ( )},{),( yxmínyx BARm µµµ =

(4.13)

El uso de la implicación difusa y los operadores difusos resulta en reglas heurísticas en forma de predicados difusos:

Si [x1 es A1i] y [x2 es A2i] y…y [xn es Ani] entonces [y1 es B1i] y [y2 es B2i] y…y [yn es Bni]

Donde, x1, x2,…, xn son las variables de entrada, y1, y2,…,yn son las variables de salida, A1i, A2i,..,Ani son los antecedentes y B1i, B2i,..,Bni son los consecuentes. Tanto los antecedentes como los consecuentes presentan palabras como positivo, muy frío, etc. En la Tabla 4.2 se muestran las implicaciones difusas para dos variables y una salida con granularidad de 7 conjuntos difusos (PP: positivo pequeño; PM: positivo mediando; PG: positivo grande; 0: cero; NP: negativo pequeño; NM: negativo mediano; NG: negativo grande). Estos conjuntos difusos son los antecedentes y consecuentes en los predicados difusos.

52

x1/x2 NG NM NP 0 PP PM PG

PG 0 PP PM PG PG PG PG

PM NP 0 PP PM PG PG PG

PP NM NP 0 PP PM PG PG

0 NG NM NP 0 PP PM PG

NP NG NG NM NP 0 PP PM

NM NG NG NG NM NP 0 PP

NG NG NG NG NG NM NP 0

Nota: PP: positivo pequeño; PM: positivo mediando; PG: positivo grande; 0: cero; NP: negativo pequeño; NM: negativo mediano; NG: negativo grande.

Tabla 4.2. Tabla de implicaciones difusas para dos variables y una salida con granularidad de 7 conjuntos difusos.

4.3.4. Defuzzificación

Una vez formadas las reglas heurísticas y definidos los grados de membresía para cada una de las consecuentes, se deberá proceder a la cuantificación de estas variables para poder utilizarlas como acciones de control. Hay diferentes métodos por los cuales se logra esto. Los más utilizados son: Centroide, Promedio del centro de áreas, Centroide del área máxima, Singletons, entre otros.

Centroide.- consiste en determinar el centro de gravedad de todas las áreas generadas por el mecanismo de inferencia difusa.

Promedio del centro de áreas.- es similar al centroide, pero mucho más rápido en cuanto a tiempo de cómputo. Se calcula contribución de cada área en los conjuntos de salida, sin importar los traslapes que pudieran existir entre conjuntos adyacentes.

Centoide el área máxima.- Se utiliza cuando el conjunto de salida representa una región no convexa. Se calculan las áreas máximas de todos los conjuntos de salida para determinar el valor cuantitativo.

En este trabajo de tesis se aplicó el método de Singletons debido a que es sencillo de usar, programar y procesar en tiempo real. Esto es importante pensando en el tiempo de cómputo, de transferencia, de muestro, entre otros factores.

Singletons

Este método es el más sencillo de usar. Podría decirse que es puntual, es decir, concentra la acción de control de un conjunto difuso de salida (regla que se dispara) en un solo punto µi (ver Figura 4.4). De esta manera para cada conjunto de salida (PG, PP, etc.) se define un valor (cuantificable) de salida y así la acción de control se define por la media ponderada de cada

53

valor de singleton con el grado de membresía βi del implicante generado en el mecanismo de inferencia.

i

K

i

ii

K

i uu

ββ

1

1*

=

=

∑

∑=

(4.14)

Figura 4.4. Defuzzificación por Singletons

4.4. Control Supevisorio

Una aplicación muy importante de la teoría de control difuso es en aplicaciones de control supervisorio. La función de un control supervisorio es la de evaluar, mediante la información generada del sistema, el comportamiento del controlador para ajustar valores previamente definidos y así mejorar el desempeño general del sistema [20].

Esta supervisión puede realizarse de dos maneras: de forma física a través de un operador que revise el desempeño del sistema o a través de criterios de ajuste automatizados que estarán establecidos a partir de la información recopilada del mismo.

El segundo método es el que concierne a esta sección. Se enfocará la descripción a dos esquemas de control supervisorio. Todos los esquemas aquí planteados utilizan el error como indicador de desempeño y disparador de lo ajustes necesarios para mejorarlo.

4.4.1. Esquema I: Modificar la referencia del sistema

En este esquema se pretende modificar la referencia del sistema para acelerar o desacelerar la acción de control (Figura 4.5). Es decir, los cambios de referencia )(trd serán dictados por el

controlador supervisorio.

PG

PM

PM

0

NP

NM

NG

µ 7

µ 6

µ 5

µ 4

µ 3

µ 2

µ1

1

µ

54

Figura 4.5: Diagrama de bloques del esquema supervisorio I.

Este ajuste puede realizarse de dos maneras:

Esquema I.a. sumando una ganancia a la referencia original (Figura 4.6).

Esquema I.b. multiplicando una ganancia a la referencia original (Figura 4.7).

Figura 4.6. Esquema supervisorio I.a.

Las diferencias de aplicar el esquema I.a o de aplicar el esquema I.b radican en que en el primero el cambio en la referencia no es proporcional y a medida de que el cambio es más grande se vuelve menos significativo el factor de cambio. De igual forma ocurre hacia abajo, entre más pequeño el cambio se vuelve más significativo el factor de cambio. Por el contrario con el esquema I.b el cambio se vuelve proporcional al cambio en la referencia. Así un ganancia de .7 significaría una reducción en 30% de la referencia original independientemente si el cambio en referencia fue 10 o 50. La elección de uno u otro esquema dependerá exclusivamente del proceso a controlar. En [5] se aplicó con éxito el esquema I.a en un sistema para el control de temperatura.

r(t) +

+ u(t) y(t)

-

+ ed(t) Planta Controlador

Control Supervisorio

rd(t)

e(t) -

+

u(t) y(t)

+

-

+

-

ed(t) Planta Controlador


rd(t)

r(t)

55

Figura 4.7. Esquema supervisorio I.b.

4.4.2. Esquema II: Ajuste de ganancia de un PID

Este esquema pretende que el control supervisorio modifique la ganancia del PID. Es decir, contar con un PID que se ajuste automáticamente en función del error del sistema (Figura 4.8). Este esquema también se puede tomar como el ajuste del error del sistema para acelerar o desacelerar la respuesta del controlador. En esta visión, se trata de forzar al controlador generando un error mayor o menor al real para mejorar el desempeño del sistema.

Figura 4.8. Esquema Supervisorio II.

r(t) u(t) y(t)

-



k

r(t) +

u(t) y(t)

-



rd(t)

e(t) -

k

56

4.5. Control Convencional PID implementado

La expresión que utiliza el integrado LM629 en el dominio de Laplace es

( ) sKs

KKsG dpc ++= 1

(4.15) Donde,

=pK constante proporcional

==i

pi

KK τ constante integral

== dpd KK τ constante derivativo

=iτ constante de tiempo derivativa

=dτ constante de tiempo integral

Por otra parte, en el dominio discreto la ec. (4.15) se convierte en

( ) [ ])1()()()(0

−−++= ∑=

kekeT

KkeTKkeKku

s

d

K

k

ip

(4.16)

Donde T es el intervalo de muestro del microcontrolador y Ts el intervalo de muestreo derivativo.

En [3] se realizó una prueba escalón para identificar un modelo de segundo orden y lograr una sintonización del PID. Esta identificación se llevó a cabo en un área de trabajo específica. Sin embargo, en el prototipo es imposible realizarla, debido a que los integrados LM629 no tienen un modo de operación manual y porque la identificación que se realizaría sería de la velocidad no de la posición. Se procedió a probar diferentes sintonías, en una determinada área de trabajo, hasta encontrar la que presentara un mejor desempeño. Así, la sintonía final de los tres controladores resultó 278.0=pK , 618.0=iK , 0.0=dK . Dicha sintonía se probó para

cambios en referencia desde la posición articular ( ) )º15,15,15(º,, 321 =θθθ hasta la posición

articular ( ) )º30,30,30(º,, 321 =θθθ

4.6. Control Supervisorio Difuso

En [3] se propone un esquema de control supervisorio para mejorar el desempeño del control convencional para la posición del efector final del manipulador en regiones donde la sintonía del convencional ya no resulta óptima. El objetivo era utilizar un controlador difuso

57

para atenuar o amplificar una ganancia que modifique el error que observa el PID (sección 4.4.2). Este esquema presentó resultados satisfactorios en simulación. Es por esto que se toma como modelo para esta tesis. Sin embargo dicho esquema no es realizable en el prototipo debido que es imposible manipular el error del integrado LM629. A continuación se describe el esquema implementado y la sintonía de dicho esquema.

4.6.1. Implementación

La estrategia de control implementada sobre el prototipo es un esquema de control supervisorio difuso (para cada articulación) que genera una ganancia difusa. Esta ganancia permite atenuar o amplificar la referencia a partir del error articular y del cambio en este para mejorar su desempeño y por ende la respuesta global del sistema. Este esquema se presenta en la Figura 4.9.

Figura 4.9.Esquema de Control Supervisorio Difuso implementado en el prototipo Delta

Este esquema permite lidiar con la no linealidad que tiene el manipulador y mejorar la respuesta en varias zonas de trabajo. De igual forma permite subsanar los problemas que se tienen al ir en contra o favor de la gravedad.

Cabe señalar que en [3] se modifica la fase de defuzzificación para que sus valores se encuentren alrededor de 1.00 y no de 0.00 como ocurre normalmente. Esta modificación también es necesaria para este caso. Ya que se trata de mantener, atenuar o amplificar la referencia y un valor de 0.00 eliminaría la referencia en vez de mantenerla.

4.6.2. Sintonización del control supervisorio difuso

Debido a las características del controlador supervisorio difuso es necesario entender la manera como se comporta el manipulador en lazo cerrado del manipulador para conocer los efectos de referencias “grandes” y “pequeñas”. Así, la sintonía de controlador supervisorio difuso queda como sigue:

Fuzzificación

Las funciones de membresía propuestas en esta tesis se observan en la Figura 4.10. Tanto para el error como para el cambio en el error, se manejan tres conjuntos difusos con sus respectivas funciones de membresía. Estas funciones son: Positivo, Cero, Negativo.

u(t)

PC Planta

θ(t) Modelo Cinemático Inverso

k +

- PID Robot


Posición espacial deseada

Referencia articular

+

-

ed(t)

58

Figura 4.10. Conjuntos difusos de entrada

Inferencia

El controlador supervisorio debe manipular la referencia para guiar al sistema a la posición deseada. Como consecuencia de esto las reglas de inferencia (Tabla 4.3) se definen como:

1. Si e es Negativo y ∆e es Positivo entonces 1>µ .

2. Si e es Negativo y ∆e es Cero entonces 1>µ .

3. Si e es Negativo y ∆e es Negativo entonces 1>µ .

4. Si e es Cero y ∆e es Positivo entonces 1>µ .

5. Si e es Cero y ∆e es Cero entonces 1=µ .

6. Si e es Cero y ∆e es Negativo entonces 1<µ .

7. Si e es Positivo y ∆e es Positivo entonces 1<µ .

8. Si e es Positivo y ∆e es Cero entonces 1<µ .

9. Si e es Positivo y ∆e es Negativo entonces 1<µ .

Defuzzificación

Para la defuzzificación se utilizará la regla se Singletons. En la Tabla 4.3 se observa que la acción de control decrementará (D), mantendrá (M) y aumentará (A) la ganancia que multiplicará la referencia. Así se logrará atenuar o amplificar la misma. Lo que se busca es frenar la respuesta del sistema, ya que es muy rápido el movimiento articular y tiene sobretiro

a) Error

-20.00 -15.00 -10.00 -5.00 0.00 5.00 10.00 15.00 20.00

0

1P N C

e

b) Cambio en el error

-20.00 -15.00 -10.00 -5.00 0.00 5.00 10.00 15.00 20.00

0

1N C P

∆e

59

excesivo. De esta forma, para movimientos hacia abajo se disminuirá la referencia y para movimientos hacia arriba se incrementará para reducir la magnitud de los sobretiros.

e

N C P

P A A D

C A M D

N A D D

Tabla 4.3. Tabla de implicaciones difusas para el supervisorio.

Figura 4.11. Regla de defuzzificación por Singletons para la acción del supervisorio

4.7. Resumen

A lo largo del presente capítulo se ha dado un repaso a los conceptos fundamentales del control clásico, del control difuso y se ha descrito la función y algunos esquemas de control supervisorio. Además se ha descrito la ecuación discreta del PID digital para la posición angular de cada una de las articulaciones, así como la sintonía del mismo. Además, se ha expuesto el esquema de control supervisorio implementado en el Robot Delta. Su finalidad es atenuar, mantener o amplificar la referencia para mejorar el desempeño global del sistema. Para esto, también se ha presentado el diseño y sintonía del FKBC para generar la ganancia difusa. A continuación se expondrán las pruebas realizadas con el esquema implementado y un análisis comparativo entre el esquema supervisorio difuso y un esquema de control PID convencional.

0.83 1.00 1.270.65

0

1

∆ e

60

5. Pruebas y análisis de resultados

En este capítulo se presentan las pruebas realizadas tanto con el PID convencional como con el esquema de control supervisorio difuso. Al final del capítulo se presenta el análisis comparativo de ambos esquemas aplicados en el control de posición del Robot Delta. Se exponen las gráficas obtenidas y tablas con indicadores de desempeño en cada caso.

5

61

5.1. Introducción

En la siguiente sección se exponen las pruebas realizadas así como los resultados obtenidos de la implementación del control supervisorio difuso (CSD), en el prototipo real, presentado en el capítulo 3. Se comparan sus resultados con el desempeño de un control PID convencional. Las pruebas que a continuación se describen (Tabla 5.1) involucran solamente el movimiento de dos de las tres articulaciones y se realizaron con un tiempo de muestreo de 0.1s:

Prueba I: Cambio de referencia en posición de ( ) ( )8.189,4.10,18,, 111 −−=zyx mm a ( ) ( )239,3.27,25.47,, 222 −−=zyx mm y viceversa (subíndice “a” y “b” respectivamente como se muestra en la Tabla 5.1) con respecto al centro de la base fija. La prueba se realiza sin carga (prueba I.1.a) y con una carga de .540kg (prueba I.2.a y I.2.b).

Prueba II: Cambio de referencia en posición de ( ) ( )8.189,4.10,18,, 111 −−=zyx mm a ( ) ( )6.322,6.74,18.129,, 222 −−=zyx mm y viceversa con respecto al centro de la base fija. La prueba se realiza sin carga (prueba II.1.a y II.1.b) y con una carga de .540kg (prueba II.2.a).

Prueba III: Cambio de referencia en posición de ( ) ( )6.2282.1394.64,, 111 −−−=zyx mm ( ) ( )239,3.27,25.47,, 222 −−=zyx mm con respecto al centro de la base fija. La prueba se realiza sin carga (prueba III.1.a) y con carga (III.2.a).

En cada prueba se presentan los índices de desempeño obtenidos así como una discusión de los resultados obtenidos. Cabe resaltar, que el tiempo de establecimiento que se considera global, es el tiempo que tarda el último eje en entrar a la banda del ± 2% de su valor final. Lo anterior debido a que interesa saber cuál es el tiempo en que el efector final llega completamente a su posición final deseada. Por lo tanto, el tiempo de establecimiento global es el tiempo de establecimiento espacial más grande (en todas la tablas este se encuentra en negritas). Al final del capítulo se presentan comentarios generales de las pruebas realizadas.

Cambio en referencia de

posición(mm) 1 2 a b

I

( ) ( )8.189,4.10,18,, 111 −−=zyx ( ) ( )239,3.27,25.47,, 222 −−=zyx

II

( ) ( )8.189,4.10,18,, 111 −−=zyx

( ) ( )6.322,6.74,18.129,, 222 −−=zyx

Sin carga Con una carga de .540kg

III ( ) ( )6.2282.1394.64,, 111 −−−=zyx ( ) ( )239,3.27,25.47,, 222 −−=zyx

( )111 ,, zyx

( )222 ,, zyx

( )111 ,, zyx

( )222 ,, zyx

Tabla 5.1. Conjunto de pruebas realizadas.

62

Figura 5.1. Número de articulación en el Robot Delta

5.2. Resultados

5.2.1. Prueba I

Prueba I.1.a

En esta sección se realiza un cambio de referencia de posición sin carga de ( ) ( )8.189,4.10,18,, 111 −−=zyx mm a ( ) ( )239,3.27,25.47,, 222 −−=zyx mm con respecto al centro de la base fija.

Articulación 1 Articulación 2 Sin CSD Con CSD Sin CSD Con CSD Valor inicial (º) 15.00 15.00 14.99 14.98 Referencia (º) 30.00 30.00 29.99 29.99 Sobretiro (%) 5.32 2.13 4.44 3.34 T. Establecimiento (±2%) 1.90 2.70 1.90 2.70

Tabla 5.2. Índices de desempeño articular de la prueba I.1.a.

Eje Sobretiro (%)

T. Establecimiento (s)

x 5.38 1.70 y 7.10 1.90 Sin CSD z 4.88 1.60 x 3.84 2.00 y 3.53 2.70

Con CSD

z 2.71 2.00

Tabla 5.3. Índices de desempeño espacial por ejes de la prueba I.1.a.

Articulación 2

Articulación 3

Articulación 1

63

Respuesta articular 1

10.00

12.00

14.00

16.00

18.00

20.00

22.00

24.00

26.00

28.00

30.00

32.00

-0.3 0.0 0.3 0.6 0.9 1.2 1.5 1.8 2.1 2.4 2.7 3.0 3.3 3.6 3.9 4.2 4.5 4.8 5.1 5.4 5.7 6.0 6.3 6.6 6.9

Tiempo (s)

Grados

Referencia Sin CDS Con CDS

(a)


10.00

12.00

14.00

16.00

18.00

20.00

22.00

24.00

26.00

28.00

30.00

32.00

-0.3 0.0 0.3 0.6 0.9 1.2 1.5 1.8 2.1 2.4 2.7 3.0 3.3 3.6 3.9 4.2 4.5 4.8 5.1 5.4 5.7 6.0 6.3 6.6 6.9

Tiempo (s)

Grados

Referencia Sin CSD Con CSD

(b)

Figura 5.2. Respuesta articular para la prueba I.1.a.

64
Posición espacial 'x'

-55.00

-51.00

-47.00

-43.00

-39.00

-35.00

-31.00

-27.00

-23.00

-19.00

-15.00

-11.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

(a)

Posición espacial 'y'

5.00

9.00

13.00

17.00

21.00

25.00

29.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posicion (mm)

Sin CSD Con CSD

(b)

Posición espacial 'z'

-250.00

-244.00

-238.00

-232.00

-226.00

-220.00

-214.00

-208.00

-202.00

-196.00

-190.00

-184.00 -0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

(c)

Figura 5.3. Respuesta espacial prueba I.1.a.

65

Prueba I.2.a

En esta sección se realiza un cambio de referencia de posición con una carga de .540kg de ( ) ( )8.189,4.10,18,, 111 −−=zyx mm a ( ) ( )239,3.27,25.47,, 222 −−=zyx mm con respecto al centro de la base fija.


Tabla 5.4. Índices de desempeño articular para la prueba I.2.a

Eje Sobretiro (%)


X 5.20 1.70 Y 5.26 1.60 Sin CSD Z 4.38 1.70 X 3.42 2.20 Y 2.97 2.60

Con CSD

Z 2.78 2.10

Tabla 5.5. Índices de desempeño espacial para la prueba I.2.a

Prueba I.2.b

En esta sección se realiza un cambio de referencia en posición con una carga de .540kg de ( ) ( )239,3.27,25.47,, 222 −−=zyx mm a ( ) ( )8.189,4.10,18,, 111 −−=zyx mm con respecto al centro de la base fija.


Tabla 5.6. Índices de desempeño articular para la prueba I.2.b

Eje Sobretiro (%)


X 23.01 2.20 Y 37.74 2.20 Sin CSD Z 33.33 2.30 X 10.14 1.90 Y 14.94 2.10

Con CSD

Z 13.70 2.10 Tabla 5.7. Índices de desempeño espacial para la prueba I.2.b

66


7.00

9.00

11.00

13.00

15.00

17.00

19.00

21.00

23.00

25.00

27.00

29.00

31.00

33.00

-0.3 0.0 0.3 0.6 0.9 1.2 1.5 1.8 2.1 2.4 2.7 3.0 3.3 3.6 3.9 -0.4 -0.1 0.2 0.5 0.8 1.1 1.4 1.7 2.0 2.3 2.6 2.9 3.2 3.5 3.8

Tiempo (s)

Grados



10.00

12.00

14.00

16.00

18.00

20.00

22.00

24.00

26.00

28.00

30.00

32.00

-0.3 0.0 0.3 0.6 0.9 1.2 1.5 1.8 2.1 2.4 2.7 3.0 3.3 3.6 3.9 3.9 -0.1 0.2 0.5 0.8 1.1 1.4 1.7 2.0 2.3 2.6 2.9 3.2 3.5 3.8

Tiempo (s)

Grados


Figura 5.4. Respuesta articular para (a) la prueba I.2.a. (b) la prueba I.2.b.

(a.ii) (b.ii)

(a.i) (b.i)

67


-55.00

-51.00

-47.00

-43.00

-39.00

-35.00

-31.00

-27.00

-23.00

-19.00

-15.00

-11.00 -0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 -0.5 -0.1 0.3 0.7 1.1 1.5 1.9 2.3 2.7 3.1 3.5 3.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD


4.00

8.00

12.00

16.00

20.00

24.00

28.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 -0.5 -0.1 0.3 0.7 1.1 1.5 1.9 2.3 2.7 3.1 3.5 3.9

Tiempo (s)

Posicion (mm)

Sin CSD Con CSD


-250.00

-244.00

-238.00

-232.00

-226.00

-220.00

-214.00

-208.00

-202.00

-196.00

-190.00

-184.00

-178.00

-172.00-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 -0.5 -0.1 0.3 0.7 1.1 1.5 1.9 2.3 2.7 3.1 3.5 3.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

Figura 5.5. Respuesta espacial para (a) la prueba I.2.a. y (b) la prueba I.2.b

(a.i) (b.i)

(a.ii) (b.ii)

(a.iii) (b.iii)

68

Comentarios Pruebas I

Para el caso en los cambios en referencia sin carga en la región en la cuál se sintonizó el PID, el control supervisorio difuso prácticamente obtiene el mismo desempeño que el PID. Se puede notar una clara mejoría en el sobretiro en cada una de las pruebas, al costo de un mayor tiempo de establecimiento. La reducción del sobretiro se puede apreciar tanto en las repuestas articulares como en las respuestas espaciales. Cabe hacer notar que cuando se realiza el cambio articular hacia arriba, el control supervisorio reduce en mayor proporción el sobretiro en comparación con el PID.

El mismo fenómeno se observa cuando se tienen una carga de .540 kg. Sin embargo, aquí, el tiempo de establecimiento es prácticamente igual; inclusive en algunos casos como los presentados en las tablas 5.6 y 5.7 el tiempo de establecimiento es significativamente menor al obtenido con el control PID convencional. Se tiene que hacer notar que el PID está sintonizado para trabajar en esta región. Por lo que el CSD se enfrenta a un PID hecho para esta región.

5.2.2. Prueba II

Prueba II.1.a

En esta sección se realiza un cambio de referencia de posición sin carga de ( ) ( )8.189,4.10,18,, 111 −−=zyx mm a ( ) ( )6.322,6.74,18.129,, 222 −−=zyx mm con respecto al centro de la base fija.


Tabla 5.8. Índices de desempeño articular para la prueba II.1.a.

Eje Sobretiro (%)


X 10.17 1.50 Y 15.06 1.70 Sin CSD Z 6.51 1.40 X 1.63 1.50 Y 6.20 2.00

Con CSD

Z 1.07 1.30 Tabla 5.9. Índices de desempeño espacial para la prueba II.1.a.

69


5.00

10.00

15.00

20.00

25.00

30.00

35.00

40.00

45.00

50.00

55.00

60.00

65.00

0.3

0.0

0.3

0.6

0.9

1.2

1.5

1.8

2.1

2.4

2.7

3.0

3.3

3.6

3.9

-0.4

-0.1

0.2

0.5

0.8

1.1

1.4

1.7

2.0

2.3

2.6

2.9

3.2

3.5

3.8

Tiempo (s)

Grados



5.00

10.00

15.00

20.00

25.00

30.00

35.00

40.00

45.00

50.00

55.00

60.00

65.00

0.3 0.0 0.3 0.6 0.9 1.2 1.5 1.8 2.1 2.4 2.7 3.0 3.3 3.6 3.9 -0.4 -0.1 0.2 0.5 0.8 1.1 1.4 1.7 2.0 2.3 2.6 2.9 3.2 3.5 3.8

Tiempo (s)

Grados


Figura 5.6. Respuesta articular para (a) la prueba II.1.a. y (b) la prueba II.1.b.

(a.i) (b.i)

(a.ii) (b.ii)

70

Prueba II.1.b

En esta sección se realiza un cambio de referencia de posición sin carga de ( ) ( )6.322,6.74,18.129,, 222 −−=zyx mm a ( ) ( )8.189,4.10,18,, 111 −−=zyx mm con respecto al centro de la base fija.


Tabla 5.10. Índices de desempeño articular para la prueba II.1.b.

Eje Sobretiro (%)


X 9.15 1.60 Y 8.47 1.60 Sin CSD Z 16.25 1.90 X 4.09 1.80 Y 7.12 1.90

Con CSD

Z 8.47 2.00

Tabla 5.11. Índices de desempeño espacial para la prueba II.1.b.

Prueba II.2.a

En esta sección se realiza un cambio de referencia de posición con una carga de .540kg sin carga de ( ) ( )8.189,4.10,18,, 111 −−=zyx mm a ( ) ( )6.322,6.74,18.129,, 222 −−=zyx mm con respecto al centro de la base fija.


Tabla 5.12. Índices de desempeño articular para la prueba II.2.a.

Eje Sobretiro (%)


X 10.36 1.60 Y 15.03 1.80 Sin CSD Z 6.58 1.40 X 1.53 1.50 Y 7.03 2.20

Con CSD

Z 1.17 1.40 Tabla 5.13. Índices de desempeño espacial para la prueba II.2.a.

71


-150.00

-143.00

-136.00

-129.00

-122.00

-115.00

-108.00

-101.00

-94.00

-87.00

-80.00

-73.00

-66.00

-59.00

-52.00

-45.00

-38.00

-31.00

-24.00

-17.00

-10.00

-3.00-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 -0.5 -0.1 0.3 0.7 1.1 1.5 1.9 2.3 2.7 3.1 3.5 3.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD


0.00

5.00

10.00

15.00

20.00

25.00

30.00

35.00

40.00

45.00

50.00

55.00

60.00

65.00

70.00

75.00

80.00

85.00

90.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 -0.5 -0.1 0.3 0.7 1.1 1.5 1.9 2.3 2.7 3.1 3.5 3.9

Tiempo (s)

Posicion (mm)

Sin CSD Con CSD


-340.00

-330.00

-320.00

-310.00

-300.00

-290.00

-280.00

-270.00

-260.00

-250.00

-240.00

-230.00

-220.00

-210.00

-200.00

-190.00

-180.00

-170.00

-160.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 -0.5 -0.1 0.3 0.7 1.1 1.5 1.9 2.3 2.7 3.1 3.5 3.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

Figura 5.7. Respuesta espacial para (a) la prueba II.1.a. y (b) la prueba II.1.b.

(a.i)

(a.ii)

(a.iii)

(b.i)

(b.ii)

(b.iii)

72


10.00

15.00

20.00

25.00

30.00

35.00

40.00

45.00

50.00

55.00

60.00

65.00

-0.3-0.1

0.1

0.3

0.5

0.7

0.9

1.1

1.3

1.5

1.7

1.9

2.1

2.3

2.5

2.7

2.9

3.1

3.3

3.5

3.7

3.9

4.1

4.3

4.5

4.7

4.9

5.1

5.3

5.5

5.7

5.9

6.1

6.3

6.5

6.7

6.9

Tiempo (s)

Grados


(a)

Posición articular 2

10.00

15.00

20.00

25.00

30.00

35.00

40.00

45.00

50.00

55.00

60.00

65.00

-0.3 0.0 0.3 0.6 0.9 1.2 1.5 1.8 2.1 2.4 2.7 3.0 3.3 3.6 3.9 4.2 4.5 4.8 5.1 5.4 5.7 6.0 6.3 6.6 6.9

Tiempo (s)

Grados


(b)

Figura 5.8. Respuesta articular para la prueba II.2.a.

73

-150.00

-143.00

-136.00

-129.00

-122.00

-115.00

-108.00

-101.00

-94.00

-87.00

-80.00

-73.00

-66.00

-59.00

-52.00

-45.00

-38.00

-31.00

-24.00

-17.00 -0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

(a)


5.00

10.00

15.00

20.00

25.00

30.00

35.00

40.00

45.00

50.00

55.00

60.00

65.00

70.00

75.00

80.00

85.00

90.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posicion (mm)

Sin CSD Con CSD

(b)


-340.00

-330.00

-320.00

-310.00

-300.00

-290.00

-280.00

-270.00

-260.00

-250.00

-240.00

-230.00

-220.00

-210.00

-200.00

-190.00

-180.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

(c)

Figura 5.9. Respuesta espacial para la prueba II.2.a.

74

Comentarios Prueba II

Estas pruebas se realizaron en la región de operación para la cual el control PID no fue sintonizado. En la Figura 5.7 (b) se presenta un error en la comunicación en el CSD (se observa una ligera meseta), sin embargo a pesar de esto el tiempo de establecimiento es prácticamente igual al observado en el esquema de control PID convencional. Se observa una clara mejoría en los índices de desempeño por parte del control supervisorio difuso.

En todos los casos se presenta menor sobreimpulso haciéndose notar el caso en que las dos articulaciones realizan un movimiento hacia arriba (de 60º a15º). Tanto para el caso con carga como sin carga el supervisorio presenta un mejor desempeño. El tiempo de establecimiento en estos resultados es prácticamente el mismo tanto para el PID como para el supervisorio. Finalmente, a consecuencia de esto, el supervisorio mejora considerablemente la respuesta del desempeño espacial del manipulador. Nótese, que al igual que en las pruebas anteriores, los movimientos de las articulaciones hacia arriba presentan mayor sobreimpulso. Pero es ahí donde el supervisorio presenta mejor desempeño que el control PID convencional.

5.2.3. Prueba III

Prueba III.1.a

En esta sección se realiza un cambio de referencia en posición sin carga de ( ) ( )6.2282.1394.64,, 111 −−−=zyx mm a ( ) ( )239,3.27,25.47,, 222 −−=zyx mm con respecto al centro de la base fija.


Tabla 5.14. Índices de desempeño articular para la prueba III.1.a.

Eje Sobretiro (%)


X 9.92 1.70 Y 5.59 1.60 Sin CSD Z 4.89 2.00 X 3.43 3.20 Y 3.50 2.3

Con CSD

Z 83.00 1.80

Tabla 5.15. Índices de desempeño espacial para la prueba III.1.a.

75


10.00

12.00

14.00

16.00

18.00

20.00

22.00

24.00

26.00

28.00

30.00

32.00

-0.3-0.1

0.1

0.3

0.5

0.7

0.9

1.1

1.3

1.5

1.7

1.9

2.1

2.3

2.5

2.7

2.9

3.1

3.3

3.5

3.7

3.9

4.1

4.3

4.5

4.7

4.9

5.1

5.3

5.5

5.7

5.9

6.1

6.3

6.5

6.7

6.9

Tiempo (s)

Grados


(a)


25.00

26.00

27.00

28.00

29.00

30.00

31.00

32.00

33.00

34.00

35.00

36.00

37.00

38.00

39.00

40.00

41.00

-0.3 0.0 0.3 0.6 0.9 1.2 1.5 1.8 2.1 2.4 2.7 3.0 3.3 3.6 3.9 4.2 4.5 4.8 5.1 5.4 5.7 6.0 6.3 6.6 6.9

Tiempo (s)

Grados


(b)

Figura 5.10. Respuesta articular para la prueba III.1.a.

76

-68.00

-66.00

-64.00

-62.00

-60.00

-58.00

-56.00

-54.00

-52.00

-50.00

-48.00

-46.00

-44.00 -0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

(a)


-18.00

-14.00

-10.00

-6.00

-2.00

2.00

6.00

10.00

14.00

18.00

22.00

26.00

30.00

34.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posicion (mm)

Sin CSD Con CSD

(b)


-250.00

-248.00

-246.00

-244.00

-242.00

-240.00

-238.00

-236.00

-234.00

-232.00

-230.00

-228.00

-226.00 -0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

(c)

Figura 5.11. Respuesta espacial para la prueba III.1.a

77

Prueba III.2.a

En esta sección se realiza un cambio de referencia en posición con una carga de .540kg de ( ) ( )6.2282.1394.64,, 111 −−−=zyx mm a ( ) ( )239,3.27,25.47,, 222 −−=zyx mm con respecto al centro de la base fija.

Articulación 1 Articulación 2 Sin CSD Con CSD Sin CSD Con CSD

Valor inicial (º) 14.98 14.98 40.01 40.01 Referencia (º) 30.00 30.00 29.99 29.99 Sobretiro (%) 4.37 2.07 9.37 2.79

T. Establecimiento (±2%) 1.80 3.50 1.6 3.50

Tabla 5.16. Índices de desempeño articular para la prueba III.2.a

Eje Sobretiro (%)


X 10.05 1.60 Y 5.80 1.70

Sin CSD

Z 4.58 1.80 X 2.95 3.50 Y 2.40 2.50

Con CSD

Z 61.39 1.40

Tabla 5.17. Índices de desempeño espacial para la prueba III.2.a

Comentarios Pruebas III

En esta prueba se busca observar el desempeño del supervisorio para cambios contrarios en las articulaciones y pequeños en cuanto a su magnitud. De igual forma se observa una notable reducción en el sobretiro articular, tanto para movimientos con carga y sin carga. Se puede apreciar casi el mismo fenómeno que en las pruebas anteriores. Sin embargo, se nota una respuesta mucho más lenta en la articulación 2. Lo que perjudica notablemente al tiempo de establecimiento en su respuesta espacial. En estas pruebas el sobretiro en el eje z es mucho más grande en el supervisorio que en el desempeño del PID convencional. Aunque también, se debe observar que el sobreimpulso generado apenas rebasa el centímetro. La propuesta para este caso es programar el CSD para que no actúe para cambios pequeños en las articulaciones o implementar una estrategia de planeación de trayectorias.

78


10.00

12.00

14.00

16.00

18.00

20.00

22.00

24.00

26.00

28.00

30.00

32.00

-0.3-0.1

0.1

0.3

0.5

0.7

0.9

1.1

1.3

1.5

1.7

1.9

2.1

2.3

2.5

2.7

2.9

3.1

3.3

3.5

3.7

3.9

4.1

4.3

4.5

4.7

4.9

5.1

5.3

5.5

5.7

5.9

6.1

6.3

6.5

6.7

6.9

Tiempo (s)

Grados


(a)


25.00

27.00

29.00

31.00

33.00

35.00

37.00

39.00

41.00

-0.3 0.0 0.3 0.6 0.9 1.2 1.5 1.8 2.1 2.4 2.7 3.0 3.3 3.6 3.9 4.2 4.5 4.8 5.1 5.4 5.7 6.0 6.3 6.6 6.9

Tiempo (s)

Grados


(b)

Figura 5.12. Respuesta articular para la prueba III.2.b.

79

-70.00

-68.00

-66.00

-64.00

-62.00

-60.00

-58.00

-56.00

-54.00

-52.00

-50.00

-48.00

-46.00

-44.00 -0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

(a)


-15.00

-11.00

-7.00

-3.00

1.00

5.00

9.00

13.00

17.00

21.00

25.00

29.00

-0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posicion (mm)

Sin CSD Con CSD

(b)


-250.00

-248.00

-246.00

-244.00

-242.00

-240.00

-238.00

-236.00

-234.00

-232.00

-230.00

-228.00

-226.00 -0.3 0.1 0.5 0.9 1.3 1.7 2.1 2.5 2.9 3.3 3.7 4.1 4.5 4.9 5.3 5.7 6.1 6.5 6.9

Tiempo (s)

Posición (mm)

Sin CSD Con CSD

(c)

Figura 5.13. Respuesta espacial para la prueba III.2.b.

80

5.3. Análisis de Resultados

En general, se observa una considerable mejoría en los índices de desempeño. Sobre todo en lo que se refiere al porcentaje de sobretiro. En todos los casos tanto articular como espacialmente (con excepción de la prueba III en el caso del eje z) el supervisorio presenta un mejor desempeño que el control PID convencional. En algunos casos, esta mejoría se da al costo de un mayor tiempo de establecimiento debido a que la respuesta de las articulaciones es muy rápida y el CSD frena esta respuesta para evitar el sobreimpulso.

La mejoría más notoria se centra en los resultados obtenidos cuando hay una carga de por medio. En estos casos, el supervisorio denota una menor afectación por el aumento de carga a desplazar. En este sentido el desempeño del esquema de control supervisorio fue satisfactorio en comparación con el PID convencional.

Otra cuestión importante a considerar es lo observado para la prueba II.1.b (Figura 5.6 y Figura 5.7). Aquí se observa una ligera meseta en la gráfica correspondiente a la respuesta con el CDS. Pareciera que el CDS habría dejado de responder o que la sintonía sea la causante de dicho fenómeno. Sin embargo, después de varias pruebas realizadas se observó una falla en la comunicación del integrado LM629 y el microcontrolador (ver capítulo 3). A pesar de esto, en estas pruebas, el CDS mejoró el sobreimpulso y obtuvo prácticamente el mismo tiempo de establecimiento que el control PID convencional (Tabla 5.10 y Tabla 5.11).

Para el caso de la prueba III, donde el desempeño espacial del control PID presentó menor sobretiro y tiempo de establecimiento que el supervisorio, se tiene que tomar en cuenta que el supervisorio frena la respuesta de las articulaciones del robot por lo que para cambios pequeños el porcentaje de atenuación de la referencia es mucho más que fuerte para cambios grandes. Por eso la propuesta comentada anteriormente de programar el CSD para que deje de actuar en cambios pequeños o buscar una estrategia para la interpolación de trayectorias.

81

6. Conclusiones y perspectivas

En este capítulo se exponen las conclusiones de este trabajo de tesis, además de exponer las perspectivas a futuro en cuanto al desarrollo tecnológico del manipulador como a la investigación e implementación de otros esquemas de control no convencionales sobre el mismo.

6

82

6.1. Introducción

En todo este proceso que se llevo a cabo para el desarrollo de esta tesis se aportaron diferentes aspectos tanto tecnológicos como científicos. A continuación se enumeran tanto los primeros como los segundos, así como el camino por recorrer en este trabajo de investigación. Cabe recordar que esta es una continuación de un trabajo iniciado y se espera que sirva para investigaciones posteriores. Los programas para la implementación de los puntos 6.2 y 6.3 así como el programa de la interfaz utilizada se muestran en el apéndice de este trabajo.

6.2. Implementación de modelos cinemáticos

Como se ha mencionado, a lo largo de esta tesis, se ha continuado con el trabajo realizado en [3]. En ese trabajo se dedujeron los modelos cinemáticos del manipulador Delta tanto de su cinemática directa como de su cinemática inversa. En este trabajo se implementaron con éxito, en el prototipo real, estos modelos cinemáticos desarrollados. Los mismos fueron de utilidad para desarrollar en la interfaz la capacidad de mover el efector final del manipulador en el espacio. Es decir, se logró mover las tres articulaciones al mismo tiempo al ingresar la posición espacial final deseada. Además se puede graficar y monitorear la repuesta espacial del efector final conociendo la posición de cada articulación. La implementación resultó satisfactoria y se pudieron analizar ambos modelos.

6.3. Implementación de un esquema supervisorio difuso

Se ha desarrollado e implementado sobre un prototipo real un esquema de control difuso supervisorio que mejoró el desempeño de un controlador PID convencional en un sistema dinámico no lineal. Este esquema procesa el error y el cambio en el mismo para generar una ganancia que modifica la referencia vista por el PID. Debido a que el sistema es sumamente rápido, se buscó desacelerar la respuesta de la articulación para evitar los altos porcentajes de sobreimpulso que se tenían con el controlador PID convencional. En algunos casos esto provocó que el tiempo de establecimiento fuera un poco mayor.

Sin embargo, cabe hacer notar que esto no ocurrió en todos los casos. El supervisorio en muchas de las pruebas realizadas, sobre todo para cambios muy alejados de la región para la cuál se sintonizó el PID y variando la carga, presentó una reducción muy considerable en cuando al sobretiro generado y una ligera disminución en el tiempo de establecimiento.

En resumen, el control supervisorio difuso fue implementado con éxito en el prototipo del manipulador delta mejorando significativamente el desempeño del sistema. En el caso particular del cambio en referencia de ( ) ( )6.2282.1394.64,, 000 −−−=zyx a

( ) ( )239,3.27,25.47,, −−=fff zyx se continúa mejorando el sobretiro articular, pero con un

tiempo de establecimiento mucho mayor en una de las articulaciones lo que se traduce en un excesivo sobreimpulso sobre el eje ‘z’.

6.4. Interfaz humano-máquina

Se cuenta con una interfaz amigable con el usuario. La misma permite operar al robot mediante el empleo de la implementación de las librerías mencionadas en las secciones 6.2 y 6.3. Además se programaron e implementaron funciones para archivar los datos recibidos del robot, guardarlos y graficarlos directamente en un archivo de Excel. El proceso de recolección de los resultados al realizar pruebas se vuelve más sencillo.

83

Por otra parte, la interfaz permite interactuar con el control difuso mediante el empleo de una tabla para ingresar los valores de fuzzificación, las reglas de inferencia y la defuzzificación. Cabe resaltar la modularidad de esta sección de la interfaz. Es decir, esta sección de la interfaz se puede integrar a otras más que ocupen utilizar el control difuso para sus procesos. En resumen, esta interfaz abre nuevas posibilidades para la investigación en esquemas de control para el Robot Delta construido.

6.5. Prototipo delta

Se concluyó la construcción del prototipo delta en su fase inicial. Las pruebas realizadas para comparar el esquema supervisorio con el controlador PID convencional se realizaron sobre el prototipo descrito en el capítulo 3. Las funciones principales de operación se encuentran dentro del microcontrolador, este es el encargado de llevar a cabo todas las operaciones del robot: escritura, lectura, comunicación con la interfaz, comunicación con los LM629. En fin, la interfaz es solamente un observador de lo que ocurre. depende totalmente de lo que le microcontrolador le enviaba y de la comunicación entre este y los LM629. Todo lo anterior tiene como consecuencia que el esquema electrónico y de comunicación presenté diversas dificultades, lo que se reflejó en respuestas como las obtenidas en la prueba II.1.b (Figura 5.6), A pesar de esto se pudieron llevar a cabo las pruebas satisfactoriamente.

Sin embargo, se cuenta con un prototipo robusto y con total libertad para implementar otros esquemas de control avanzado como el control difuso, el control adaptivo predictivo, experto. En conclusión, se ha dejado un prototipo sobre el cuál se puede continuar la investigación con esquemas avanzados de control y contribuir, aún más, en el estado del arte de este tipo de configuraciones.

6.6. Perspectivas

A consecuencia de este trabajo se proponen las siguientes líneas de investigación:

Figura 6.1. Propuesta de comunicación y control para el Robot Delta construido.

Continuar con la nueva propuesta de comunicación y control para el prototipo Delta (figura tal. En ella, se pretenden eliminar los LM629 y pasar el control directamente a la computadora. Así, la computadora se convertiría en la encargada de ordenar todas las instrucciones. Al microcontrolador se le delegarán las funciones de recibir la señal de los encoders, traducirla y

Comunicación serial

GAL

L16V8

M 3

M 2

IHM Microcontrolador

ATMEL 89C51

Puente

H

LMD

18200

Puente

H

LMD

18200

Puente

H

LMD

18200

M 1

84

enviársela a la computadora. Además, generaría la manipulación en forma de ancho de pulso ordenado desde la computadora.

Llevar a cabo pruebas en lazo abierto. Se recomienda utilizar técnicas de identificación en base de entradas impulso (para el caso de identificar posición) debido a que la manipulación es un ancho de pulso que regula la velocidad del motor.

Eliminar, el controlador PID convencional e implementar un esquema de control difuso. Por otro, lado continuar con la implementación de otras estrategias de control no lineal como el control en modo deslizante, control adaptivo, entre otros.

Analizar el espacio de trabajo alcanzable del manipulador mediante el estudio de las singularidades que puede presentar matriz jacobiana para diferentes posiciones y velocidades de sus articulaciones.

Estudiar, desarrollar e implementar de un control de trayectorias. Es decir, la implementación de interpoladores para generar trayectorias lineales, circulares, entre otras. Más aún, la implementación de sistemas inteligentes para planeación de trayectorias, sea esto por medio de algoritmos computacionales o sistemas de visión. Por otro lado, validar desde la interfaz el espacio alcanzable del manipulador.

85

Bibliografía

[1] S.Negri, G. Di Bernardo, I. Fassi, L. Molinari Tosatti, G. Bianchi, C.R. Boër. Kinematic Analysis of Parallel Manipulators. En Parallel Kinematic Machines: Theoretical Aspects and Industrial Requirements, Springer, 1999.

[2] S.B. Niku. Introduction to Robotics: Analysis, Systems, Applications. Prentice Hall, New Jersey, 2001.

[3] Gilberto Reynoso Meza. Modelación de un Robot Manipulador tipo Delta y Diseño de un Control Supervisorio Difuso. Tesis de Maestría. ITESM Campus Monterrey, Dic de 2005.

[4] Katsuhiko Ogata. Ingeniería de Control Moderna. Prentice Hall, 1998.

[5] Antonio Favela Contreras. Control supervisorio para un proceso de temperatura. Tesis de Maestría. ITESM Campus Monterrey, Enero de 1995.

[6] Reinfrank Driankov, Hellendoorn. An introduction to fuzzy control. Springer-Verlag, 1993.

[7] Jean-Pierre Merlet. Parallel Robots. Kluwer Academic-Publishers, 2000.

[8] W. Khali, Dombre. Modeling, Identification & Control of Robots. Kogan Page Science, 2004.

[9] T. Higuchi, Ming. Study on multiple degree of freedom positioning mechanisms using wires, part I, concept design and control. Int. J. Japan Soc. Prec. Eng., 28(2):131-138, Junio de 1994.

[10] T. Higuchi, Ming. Study on multiple degree of freedom positioning mechanisms using wires, part II, development of a planar completely restrained position mechanism. Int. J. Japan Soc. Prec. Eng., 28(3):235-242, Septiembre de 1994.

[11] Eric Hemingson, Brantmark. Flexpicker with pickmaster revolutionizes picking operations. Industrial Robot: An International Journal, 28(5):414-419, 2001.

[12] C. Gosselin. Kinematic Análisis Optiomization and Programming of Parallel Robotic Manipulators, Tesis Doctoral. Mc Gill University, Junio de 1998.

[13] F. Sparacino J.M. Hervé. Star, a new concept in robotics. In ARK, pp. 176-183, Septiembre de 1992.

86

[14] John Lewis. Robots pack 1,200 cookies per minute. Design News, 57(1):31, 7 de Enero de 2002.

[15] D. McCloy. Some comparison of serial-driven and parallel-driven manipulators. Robotica, 1990.

[16] Jean-Pierre Merlet. Parallel robots: open problems. Extraído en Julio de 2006 desde www.inria.fr/coprin/equipe/merlet

[17] Lung-Wen Tsai. Robot analysis: the mechanics of serial and parallel manipulators. John Wiley & sons, 1999.

[18] S. G. Whitehall, Gough. Universal tire test machine. In Proceedings 9th Int. Technical Congress F.I.S.I.T.A. Vol. 117, pp. 117-135. Mayo, 1962.

[19] Kazuo Tonaka. An Introduction to fuzzy logic for practical applications. Springer-Velag, 1997

[20] Roberto Trujillo Viramontes. Desarrollo de un algoritmo de supervisión de ganancia para un controlador PID convencional. Tesis de Maestría. ITESM Campus Monterrey, Agosto de 1997.

[21] C. R. Boer, L Molinari-Tosatti, and K. S. Smith. The delta parallel robot. En Parallel Kinematic Machines: Theoretical Aspects and Industrial Requirements, pp. 271-273 Springer, 1999.

[22] Stewart D. A plataform with 6 degrees of freedom. En Proc. of the Institution of mechanical engineers, 180(Parte 1,15):371-386, 1965.

[23] Eric Hemmingson Hakan Brantmark. Flexpicker with pickmaster revoltionizes picking operations. Industrial Robot: An International Journal, 28(5):414-419, 2001.

[24] Codourey A., Dynamic Modelling and Mass Matrix Evaluation of the DELTA Parallel Robot for Axes Decoupling Control, En Proc. IEEE/RSJ Int. Conf. on Intelligent Robots and Systems, IROS'96, Osaka, Japan, Noviembre 4-8, 1996

87

Apéndice A

Programación del Controlador Supervisorio Difuso

A.1 Tesis_Sup_Difuso.c

#include <ansi_c.h> #include <formatio.h> #include "acerca_difusa.h" #include <cvirte.h> #include <userint.h> #include "Tesis_ParamDifus.h" #include "var_difuz.h" #include "Difuso.h" #include "disenio.h" #include "serial2.h" #include "Globals.h" double DifusoSup (double Error[3]); //Función que obtiene la ganancia difusa, a partir de la

//los conjuntos difusos, y el método de defuzzificación. void pid_difuso(); //Función que aplica el esquema III: multiplicar los //parémtros del PID por la ganancia obtenida //en DifusoSup void ref_difusa(); //Función que aplica el esquema II: multiplicar la //referencia por la ganancia obtenida en // DifusoSup void gain_diag(); //Función que dibuja los diagramas de fase para las

tres //articulaciones. /*********************************************************************** * Función que a partir de los valores muestreados del error genera el * * valor de la ganancia que multiplicará a las constantes del PID. * * * * Error[3]----> Consumo. Arreglo donde vienen los errores muestreados * * Gain--------> Producto. Valor a multiplicar. * * * ***********************************************************************/ double DifusoSup (double Error[3]) { IN_cuantitativas[0][0]=Error[2]; //Captura el valor del error. 1era variable

88

IN_cuantitativas[1][0]=Error[2]-Error[1]; //Captura el valor de la diferencia del error. //2da variable IN_cuantitativas[2][0]=0; //Tercera variable. Se inicializa en cero porque no c okupa. //Si se okupa hay ke pensar ke es lo ke va a

//kontener //Se manda a llamar la función para fuzzficar de Difuso.h. Con varmax=2 fuzzyfica(varmax,IN_cuantitativas,IN_conjuntos,IN_cualitativas); //Después de la fuzzificación sigue el proceso de Inferencia. Ver Difuso.h infiere (REGLA_implicante,REGLA_conjuncion,varmax,IN_cualitativas,CUBO_inferencias,OUT_cualitativas); //Por último se defuzzifica defuzzifica (REGLA_defuzz, pesos, OUT_conjuntos, OUT_cualitativas,OUT_cuantitativa); //ganancia difusa Gain=OUT_cuantitativa[0]; return Gain; } /******************************************************************** * Función que obtiene las ganancias obtenidas a partir del control * * difuso para obtener los nuevos valores de los PID's * * * * kp_difx-->gain*kp1 * * ki_difx-->gain*ki1 * * kp_difx-->gain*kd1 * ********************************************************************/ void pid_difuso() { double gain; SCREEN1 = LoadPanel (0, "serial2.uir", scr1); //PID lazo 1 (motor1) GetCtrlVal(SCREEN1,scr1_PIDGAIN_1,&gain); //Obtiene el valor de la ganacia para el motor 1 //que se guarda en la casilla de Gain. kp_dif1=gain*kp1; //Se modifica el PID del motor 1 SetCtrlVal(SCREEN1,scr1_KP_1,kp_dif1); ki_dif1=gain*ki1; SetCtrlVal(SCREEN1,scr1_ki_1,ki_dif1); kd_dif1=gain*kd1; SetCtrlVal(SCREEN1,scr1_kd_1,kd_dif1); //PID lazo 2 (motor 2) GetCtrlVal(SCREEN1,scr1_PIDGAIN_2,&gain); //Obtiene el valor de la ganancia para el motor 2

89

kp_dif2=gain*kp2; //Se modifica PID 2 SetCtrlVal(SCREEN1,scr1_KP_2,kp_dif2); ki_dif2=gain*ki2; SetCtrlVal(SCREEN1,scr1_ki_2,ki_dif2); kd_dif2=gain*kd2; SetCtrlVal(SCREEN1,scr1_kd_2,kd_dif2); //PID lazo 3 (motor 3) GetCtrlVal(SCREEN1,scr1_PIDGAIN_3,&gain); kp_dif3=gain*kp3; SetCtrlVal(SCREEN1,scr1_KP_3,kp_dif3); ki_dif3=gain*ki3; SetCtrlVal(SCREEN1,scr1_ki_3,ki_dif3); kd_dif3=gain*kd3; SetCtrlVal(SCREEN1,scr1_kd_3,kd_dif3); } /***************************************************************** * Función que obtiene las nueva referencia (referencia difusa) * * * * pos_brazo---->Gain_1*ref1 * * pos_brazo2--->Gain_2*ref2 * * pos_brazo3--->Gain_3*ref3 * * * * donde: * * Gain_1,2 y 3--> ganancia difusa obtenida de gain_diag * * ref1, 2 y 3---> referencia original * * pos_brazo,2 y 3--> posición en grados que c envía a los * * motores * * * *****************************************************************/ void ref_difusa() { double gain; //Ref lazo 1 (motor1) refdif1=Gain_1*ref1; //Ref lazo 2 (motor 2) refdif2=Gain_2*ref2; //Ref lazo 3 (motor 3) refdif3=Gain_3*ref3; }

90

/*********************************************************************** * Función que obtiene las ganancias difusas llamando a la función * * DifusoSup. Estas ganancias son las que modifican la referencia o a * * los parámetros del PID. * * Además,se dibuja el diagrama de fase para las tres aticulaciones y * * señala las reglas de inferencia que se van disparando. * * * ***********************************************************************/ void gain_diag() { Gain_1=DifusoSup (err1); Gain_2=DifusoSup (err2); Gain_3=DifusoSup (err3); }

91

Apéndice B

Programación de la interfaz

B.1 Interfaz humano-máquina

//Este programa fue escrito por Cristobal Topete Vargas //[email protected] //Modificado por Jorge Silvestre Avila semestre Enero-Mayo 2006 //[email protected] //Modificado por Pedro A. Juárez Pérez 30 de agosto 2006 //[email protected] /*---------------------------------------------------------------------------*/ /* Librerias utilizadas */ /*---------------------------------------------------------------------------*/ #include "disenio.h" #include <cviauto.h> #include <cvirte.h> #include <userint.h> #include <rs232.h> #include <utility.h> #include <formatio.h> #include <string.h> #include <ansi_c.h> #include <analysis.h> #include "toolbox.h" #include "serial2.h" #include "Globals.h" #include "DeltaRot.h" #include "Tesis_ParamDifus.h" #include "acerca_difusa.h" #include "var_difuz.h" #include "Tesis_Sup_Difuso.h" #include "disenio.h" #include "arch_guar.h" #include "var_interpolacion.h" /*---------------------------------------------------------------------------*/ /* Module-globals */ /*---------------------------------------------------------------------------*/ int panel_handle, config_handle, comport, stringsize, RS232Error,

92

port_open=0, com_status, inqlen, // Stores result from GetInQLen outqlen, // Stores result from GetOutQLen config_flag; int notifyCount, // Especifica por cuantos caracteres debe esperar eventChar, // Especifica el caracter que dispararia la interrupcion eventMask; // especifica el evento que ocasiona la interrupcion double timeout=5.0; char devicename[30], msg[100], statword[2]; /*Inicialización de algunas vriables importantes*/ //------------------------------------------------------------------------------ //Parámetros del Robot Delta, para los modelos cinemáticos y par la simulación double ParamDis[3][5]={150, 25, 200, 380, 0, 150, 25, 200, 380, 2*3.1416/3, 150, 25, 200, 380, -2*3.1416/3}; //------------------------------------------------------------------------------ /*---------------------------------------------------------------------------*/ /* Port config */ /*---------------------------------------------------------------------------*/ long baudrate=19200; #define QuitHelp 1 #define InputqHelp 2 #define parity 0 #define databits 8 #define stopbits 1 #define inputq 512 #define outputq 512 #define xmode 0 #define ctsmode 0 /*---------------------------------------------------------------------------*/ /* Internal function prototypes */ /*---------------------------------------------------------------------------*/ void DisplayRS232Error (void); void ComCallback(void *data); //void EnviarDatosRS232 (); /*---------------------------------------------------------------------------*/ /*Abre la comunicación con el puerto serial especificado */ /*---------------------------------------------------------------------------*/ void AbrirComunicacion(int puerto) { if(port_open==0) { comport=puerto; DisableBreakOnLibraryErrors (); RS232Error = OpenComConfig (comport, devicename, baudrate, parity,databits, stopbits, inputq, outputq);

93

EnableBreakOnLibraryErrors (); if (RS232Error) DisplayRS232Error (); if (RS232Error == 0) { port_open = 1; SetXMode(comport,xmode); SetCTSMode(comport,ctsmode); SetComTime(comport,timeout); notifyCount = 1; /* Wait for at least 3 bytes in queue. */ eventChar = 0; /* Wait for LF. */ eventMask = LWRS_RECEIVE; InstallComCallback(comport, eventMask, notifyCount,eventChar, (ComCallbackPtr) ComCallback, NULL); } } } /*---------------------------------------------------------------------------*/ /*Cierra la comunicación con el puerto serial */ /*---------------------------------------------------------------------------*/ void CerrarComunicacion() { if (port_open==1) { outqlen = GetOutQLen (comport); if (outqlen > 0) FlushOutQ(comport); RS232Error = CloseCom (comport); port_open=0; if (RS232Error) DisplayRS232Error (); } } /*---------------------------------------------------------------------------*/ /* Despliega un mensaje de error en la comunicacion serial */ /*---------------------------------------------------------------------------*/ void DisplayRS232Error (void) { char ErrorMessage[200]; switch (RS232Error) { default : if (RS232Error < 0) { Fmt (ErrorMessage, "%s<RS232 error number %i", RS232Error); MessagePopup ("RS232 Message", ErrorMessage); } break; case 0 : MessagePopup ("RS232 Message", "No errors."); break; case -2 : Fmt (ErrorMessage, "%s", "Invalid port number (must be in the " "range 1 to 5)."); MessagePopup ("RS232 Message", ErrorMessage); break; case -3 : Fmt (ErrorMessage, "%s", "No port is open.\n"

94

"Check COM Port setting in Configure."); MessagePopup ("RS232 Message", ErrorMessage); break; case -99 : Fmt (ErrorMessage, "%s", "Timeout error.\n\n" "Either increase timeout value,\n" " check COM Port setting, or\n" " check device."); MessagePopup ("RS232 Message", ErrorMessage); break; } } void desplegar(void) { // Desplegar la palabra a escribir en pantalla.... SetCtrlVal(status_com,statuscom_TXINICIO,databyte[0]); SetCtrlVal(status_com,statuscom_TXHI1,databyte[1]); SetCtrlVal(status_com,statuscom_TXLO1,databyte[2]); SetCtrlVal(status_com,statuscom_TXHI2,databyte[3]); SetCtrlVal(status_com,statuscom_TXLO2,databyte[4]); SetCtrlVal(status_com,statuscom_TXHI3,databyte[5]); SetCtrlVal(status_com,statuscom_TXLO3,databyte[6]); SetCtrlVal(status_com,statuscom_TXHI4,databyte[7]); SetCtrlVal(status_com,statuscom_TXLO4,databyte[8]); SetCtrlVal(status_com,statuscom_TXHI5,databyte[9]); SetCtrlVal(status_com,statuscom_TXLO5,databyte[10]); SetCtrlVal(status_com,statuscom_TXHI6,databyte[11]); SetCtrlVal(status_com,statuscom_TXLO6,databyte[12]); SetCtrlVal(status_com,statuscom_TXHI7,databyte[13]); SetCtrlVal(status_com,statuscom_TXLO7,databyte[14]); SetCtrlVal(status_com,statuscom_TXHI8,databyte[15]); SetCtrlVal(status_com,statuscom_TXLO8,databyte[16]); SetCtrlVal(status_com,statuscom_TXHI9,databyte[17]); SetCtrlVal(status_com,statuscom_TXLO9,databyte[18]); SetCtrlVal(status_com,statuscom_TXFIN,databyte[19]); } /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /*Notas para modificacion: En esta función se asignan los valores que se desean transmitar al array databyte si se desean transmitir nuevos tipos de datos (accel, vel, pid, etc), será necesario agregar mas argumentos a la función, después cada dato debera ser dividido en el numero de bytes que sea necesario y posteriormente asignar el valor de estos bytes a la posición deseada del array donde estarán listos para ser enviados. Hay que notar que para dvidir un entero en varios bytes hay que realizar corrimientos hacia la derecha y luego un and con 0x0ff para asegurarnos que solamente el byte de hasta la derecha queda intacto y el resto de la variable es cambiada a 0's. El databyte[]es un array de chars sin signo para asegurarnos de que cada posición del arreglo es de únicamente un byte. */ void enviar_pos(float pos_brazo){ int i; /* Nota, la variable pos_cuentas_enteras es solamente una variable temporal, y no

95

significa necesariamente posicion, pero si es una conversión a enteros para lo que se va a enviar. */ //Enviar posiciones de los Motores databyte[0]=0xAA; //byte inicio pos_cuentas_enteras=(unsigned int)(pos_brazo*reduccion*pulsos_por_revolucion)/360; databyte[1]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[2]=(unsigned char) pos_cuentas_enteras & 0x0ff; pos_cuentas_enteras=(unsigned int)(pos_brazo2*reduccion*pulsos_por_revolucion)/360; databyte[3]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[4]=(unsigned char) pos_cuentas_enteras & 0x0ff; pos_cuentas_enteras=(unsigned int)(pos_brazo3*reduccion*pulsos_por_revolucion)/360; databyte[5]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[6]=(unsigned char) pos_cuentas_enteras & 0x0ff; //databyte[7]=(unsigned int) sis_Gripper; databyte[7]=0x0F; //byte de fin //Atención, esto lo komenté porke me markaba un error //for(i=0;i<8;i++) ComWrtByte (comport, databyte[i]); //envio de 8 bytes desplegar(); } void enviar_pid(void) { int i; float gain,kp,ki,kd; databyte[0]=0xBB; if ((onof==1)&(ahora_difuso==1)&(esquema==2)) pid_difuso(); else { //PID Lazo 1 kp_dif1=kp1; ki_dif1=ki1; kd_dif1=kd1; //PID Lazo 2 kp_dif2=kp2; ki_dif2=ki2; kd_dif2=kd2; //PID Lazo 3 kp_dif3=kp3; ki_dif3=ki3; kd_dif3=kd3; ciclo=0; } // PID Lazo 1 pos_cuentas_enteras=(unsigned int)(kp_dif1*256); databyte[1]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[2]=(unsigned char) pos_cuentas_enteras & 0x0ff; pos_cuentas_enteras=(unsigned int)(ki_dif1*72.8593);

96

databyte[3]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[4]=(unsigned char) pos_cuentas_enteras & 0x0ff; pos_cuentas_enteras=(unsigned int)(kd_dif1*230269); databyte[5]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[6]=(unsigned char) pos_cuentas_enteras & 0x0ff; //PID Lazo 2 pos_cuentas_enteras=(unsigned int)(kp_dif2*256); databyte[7]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[8]=(unsigned char) pos_cuentas_enteras & 0x0ff; pos_cuentas_enteras=(unsigned int)(ki_dif2*72.8593); databyte[9]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[10]=(unsigned char) pos_cuentas_enteras & 0x0ff; pos_cuentas_enteras=(unsigned int)(kd_dif2*230269); databyte[11]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[12]=(unsigned char) pos_cuentas_enteras & 0x0ff; //PID lazo 3 pos_cuentas_enteras=(unsigned int)(kp_dif3*256); databyte[13]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[14]=(unsigned char) pos_cuentas_enteras & 0x0ff; pos_cuentas_enteras=(unsigned int)(ki_dif3*72.8593); databyte[15]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[16]=(unsigned char) pos_cuentas_enteras & 0x0ff; pos_cuentas_enteras=(unsigned int)(kd_dif3*230269); databyte[17]=(unsigned char) (pos_cuentas_enteras >> 8) & 0x0ff; databyte[18]=(unsigned char) pos_cuentas_enteras & 0x0ff; databyte[19]=0x0F; //byte de fin. //Atención!!!, esto lo komenté porke me markaba un error for(i=0;i<20;i++) ComWrtByte (comport, databyte[i]); //envio de 20 bytes desplegar(); } void enviar_ins(void) { int i; //Enviar posiciones de los Motores databyte[0]=0xCC; //byte inicio databyte[1]=(unsigned char) instresp; databyte[2]=0x0F; //byte de fin //Atención, esto lo komenté porke me markaba un error for(i=0;i<3;i++) ComWrtByte (comport, databyte[i]); //envio de 3 bytes desplegar(); } /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /*Notas para modificar esta funcion: Lo unico que se podria modificar en esta funcion seria el agregar mas bytes

97

al frame, esto con la finalidad de transmitir tambien velocidad y aceleracion. Se debera agregar un case por cada byte que se desee recibir. Al recibir cada uno de los bytes se debe asignar este valor a una variable. Muy probablemente un solo dato debera ser transmitido en mas de un byte. Hay que tomar en cuenta que para concatenar 2 bytes habra que multiplicar el byte alto por 256 y despues sumarle el byte bajo. La manipulacion de los datos y variables temporales de recepcion deberan ser ejecutadas hasta el ultimo case, es decir cuando se haya recibido el byte de fin, de este modo nos aseguramos que estamos recibiendo el frame justo como nosotros lo necesitamos y no cosas raras que manda el micro. */ void alrecibir() { while(GetInQLen (comport) > 0) //paranoico???? { rxvalue = ComRdByte(comport); //se lee un byte del puerto y se manda a una variable temporal RS232Error = ReturnRS232Err (); //se checa para ver su hay errores if(RS232Error) DisplayRS232Error (); switch(byte_index) { //dependiendo del byte recibido se ejecutara un caso case 0: //se checa que el primer byte sea el de inicio y se aumenta el indice SetCtrlVal(status_com,statuscom_RXINICIO,rxvalue); if(rxvalue==0xAA) { byte_index=1; SetCtrlVal(SCREEN1,scr1_LED,1); } else if(rxvalue==0xCC) { byte_index=8; SetCtrlVal(SCREEN1,scr1_LED,1); } else SetCtrlVal(SCREEN1,scr1_LED,0); break; case 1: // se guarda el 2 byte como la parte alta de la posicion pos_hi=rxvalue; SetCtrlVal(status_com,statuscom_RXHI1,rxvalue); byte_index=2; break; case 2: //se guarda el 3 byte como la parte baja de la posicion pos_lo=rxvalue; SetCtrlVal(status_com,statuscom_RXLO1,rxvalue); byte_index=3; break; case 3: // se guarda el 4 byte como la parte alta de la posicion2 pos_hi2=rxvalue; SetCtrlVal(status_com,statuscom_RXHI2,rxvalue); byte_index=4; break;

98

case 4: //se guarda el 5 byte como la parte baja de la posicion2 pos_lo2=rxvalue; SetCtrlVal(status_com,statuscom_RXLO2,rxvalue); byte_index=5; break; case 5: // se guarda el 6 byte como la parte alta de la posicion3 pos_hi3=rxvalue; SetCtrlVal(status_com,statuscom_RXHI3,rxvalue); byte_index=6; break; case 6: //se guarda el 7 byte como la parte baja de la posicion3 pos_lo3=rxvalue; SetCtrlVal(status_com,statuscom_RXLO3,rxvalue); byte_index=7; break; case 7: //se checa que el 8 byte sea el de fin SetCtrlVal(status_com,statuscom_RXFIN,rxvalue); if(rxvalue==0x0F) //se manipulan los datos para obtener las posiciones actuales en grados. { pos_cuentas_enteras_rx=(pos_hi*256)+(pos_lo); pos_brazo_rx=(pos_cuentas_enteras_rx*360)/(reduccion*pulsos_por_revolucion); pos_arr[0]=pos_brazo_rx; pos_arr[1]=pos_brazo; pos_cuentas_enteras_rx=(pos_hi2*256)+(pos_lo2); pos_brazo2_rx=(pos_cuentas_enteras_rx*360)/(reduccion*pulsos_por_revolucion); pos_arr2[0]=pos_brazo2_rx; pos_arr2[1]=pos_brazo2; pos_cuentas_enteras_rx=(pos_hi3*256)+(pos_lo3); pos_brazo3_rx=(pos_cuentas_enteras_rx*360)/(reduccion*pulsos_por_revolucion); pos_arr3[0]=pos_brazo3_rx; pos_arr3[1]=pos_brazo3; byte_index=0; //se regresa el indice a 0 para recibir mas frames } else byte_index=0; break; case 8: //statreport01 SetCtrlVal(status_com,statuscom_RXHI1,rxvalue); byte_index=9; break; case 9: //statreport02 SetCtrlVal(status_com,statuscom_RXLO1,rxvalue); byte_index=10;

99

break; case 10: //statreport03 SetCtrlVal(status_com,statuscom_RXHI2,rxvalue); byte_index=11; break; case 11: SetCtrlVal(status_com,statuscom_RXLO2,rxvalue); byte_index=12; break; case 12: SetCtrlVal(status_com,statuscom_RXHI3,rxvalue); byte_index=13; break; case 13: SetCtrlVal(status_com,statuscom_RXLO3,rxvalue); byte_index=14; break; case 14: SetCtrlVal(status_com,statuscom_RXFIN,rxvalue); if(rxvalue==0x0F) { GetCtrlVal(status_com,statuscom_RXHI1,&rxvalue); if (rxvalue!=0xFF) { statword[2] = (char) rxvalue; //desifrarerror(rxvalue); InsertListItem (SCREEN1,scr1_STATREP01,0,statword,0); } else { GetCtrlVal(status_com,statuscom_RXLO1,&rxvalue); if (rxvalue!=0xFF) { statword[2] = (char) rxvalue; //desifrarerror(rxvalue); InsertListItem (SCREEN1,scr1_STATREP02,0,statword,0); } else { GetCtrlVal(status_com,statuscom_RXHI2,&rxvalue); if (rxvalue!=0xFF) { statword[2] = (char) rxvalue; //desifrarerror(rxvalue); InsertListItem (SCREEN1,scr1_STATREP03,0,statword,0); } } } } byte_index=0; break; }

100

} SetCtrlVal(SCREEN1,scr1_RECEIVE,pos_brazo_rx); SetCtrlVal(SCREEN1,scr1_RECEIVE_2,pos_brazo2_rx); SetCtrlVal(SCREEN1,scr1_RECEIVE_3,pos_brazo3_rx); } /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ //Esta es la funcion que se ejecuta al recibir una interrupcion por recepcion //en este caso se manda llamar la funcion encargada de procesar la informacion //recibida de acuerdo al protocolo acordado. void ComCallback(void *data) { alrecibir(); } /*---------------------------------------------------------------------------*/ /* Programa para Convertir valores de XYZ en ángulos de los brazos del DELTA */ /*---------------------------------------------------------------------------*/ void CinematicaI() { double comp=0; //Compensación C[2]=C[2]+comp; //Comp es la compensación por el lugar en donde se encuentra el HOME alpha1=CinInversa (a,0,R,C,b); alpha2=CinInversa (a,DegToRad (120.00),R,C,b); alpha3=CinInversa (a,DegToRad (-120.00),R,C,b); alpha1=RadToDeg(alpha1); alpha2=RadToDeg(alpha2); alpha3=RadToDeg(alpha3); if((alpha1<90)&&(alpha2<90)&&(alpha3<90)&&(0<alpha1)&&(0<alpha2)&&(0<alpha3)) { SetCtrlVal(SCREEN1,scr1_SEND,alpha1); SetCtrlVal(SCREEN1,scr1_SEND_2,alpha2); SetCtrlVal(SCREEN1,scr1_SEND_3,alpha3); } else MessagePopup ("Trayectoria abortada", "El punto evaluado no cae dentro del espacio del trabajo del robot"); } /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/ int main (int argc, char *argv[]) { CAObjHandle plotsHandle = 0; graphHandle=0; plotHandle=0;

101

pulsos_por_revolucion=240; reduccion=200; byte_index=0; a=200; R=150; b=380; ciclo=0; i=0; instresp=0; //Prueba!!! Status Reports! zzz=0; //Prueba!!! Status Reports! //Compensaciones en grados para cada articulación comp1=0.2886; comp2=0.2886; comp3=0.2886; //Inicializando las posiciones iniciales de las articulaciones pos_brazo_rx=0+comp1; pos_brazo2_rx=0+comp2; pos_brazo3_rx=0+comp3; //tolerancia para pasar al siguiente punto al hacer la interpolación //Ahhh!!! ke valor será??? cont_cine=10000000000000; //inicialización para los torques que se utilizarán en simulación //torques[0][0]=-2.18592635; //torques[1][0]=-0.02411599688; //torques[2][0]=-1.78086035; if (InitCVIRTE (0, argv, 0) == 0) return -1; /* out of memory */ if ((SCREEN1 = LoadPanel (0, "serial2.uir", scr1)) < 0) return -1; //Esto se agregó if ((panel_difuso = LoadPanel (0, "Tesis_ParamDifus.uir", ParamDifus)) < 0) return -1; if ((panel_acercadif = LoadPanel (0, "acerca_difusa.uir", Acercadifu)) < 0) return -1; if ((panel_disenio = LoadPanel (0, "disenio.uir", Herr_disen)) < 0) return -1; if ((panel_disenio2 = LoadPanel (0, "disenio.uir", Herr_dise2)) < 0) return -1; if ((panel_disenio3 = LoadPanel (0, "disenio.uir", Herr_dise3)) < 0) return -1; if ((panel_disenio3 = LoadPanel (0, "disenio.uir", Herr_dise3)) < 0) return -1; if ((status_com = LoadPanel (0, "serial2.uir", statuscom)) < 0) return -1;

102

//Get Handle of Graph and first Plot from the ActiveX control DisplayPanel (SCREEN1); AbrirComunicacion(4); RunUserInterface (); CA_DiscardObjHandle (plotsHandle); DiscardPanel (SCREEN1); return 0; } int CVICALLBACK SETTIMER1 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_TIMER_TICK: if(tray==1) { while(cont_cine<nl) { C[0]=equis_sig[cont_cine]; C[1]=ye_sig[cont_cine]; C[2]=zeta_sig[cont_cine]; CinematicaI(); GetCtrlVal(SCREEN1,scr1_RECEIVE,&alphacomp1); GetCtrlVal(SCREEN1,scr1_RECEIVE_2,&alphacomp2); GetCtrlVal(SCREEN1,scr1_RECEIVE_3,&alphacomp3); valcomp1=alpha1-alphacomp1; valcomp2=alpha2-alphacomp2; valcomp3=alpha3-alphacomp3; // if(abs(valx)<tol && abs(valy)<tol && abs(valz)>tol) if(abs(valcomp1)<tol && abs(valcomp2)<tol && abs(valcomp3)<tol)//condición para esperar a que los motores lleguen a donde c les indicó { C[0]=equis_sig[cont_cine+1]; C[1]=ye_sig[cont_cine+1]; C[2]=zeta_sig[cont_cine+1]; CinematicaI(); SetCtrlVal(SCREEN1,scr1_SEND,alpha1); SetCtrlVal(SCREEN1,scr1_SEND_2,alpha2); SetCtrlVal(SCREEN1,scr1_SEND_3,alpha3); cont_cine++; } else i=i; break; } } GetCtrlVal(SCREEN1,scr1_SEND,/*&sentvalue*/&ref1);

103

GetCtrlVal(SCREEN1,scr1_SEND_2,/*&sentvalue*/&ref2); GetCtrlVal(SCREEN1,scr1_SEND_3,/*&sentvalue*/&ref3); //Obtiene los errores Shift(err1,3,-1,err1); err1[2]=ref1-pos_brazo_rx; SetCtrlVal(SCREEN1,scr1_ERR0,err1[0]); SetCtrlVal(SCREEN1,scr1_ERR1,err1[1]); SetCtrlVal(SCREEN1,scr1_ERR2,err1[2]); Shift(err2,3,-1,err2); err2[2]=ref2-pos_brazo2_rx; SetCtrlVal(SCREEN1,scr1_ERR0_2,err2[0]); SetCtrlVal(SCREEN1,scr1_ERR1_2,err2[1]); SetCtrlVal(SCREEN1,scr1_ERR2_2,err2[2]); Shift(err3,3,-1,err3); err3[2]=ref3-pos_brazo3_rx; SetCtrlVal(SCREEN1,scr1_ERR0_3,err3[0]); SetCtrlVal(SCREEN1,scr1_ERR1_3,err3[1]); SetCtrlVal(SCREEN1,scr1_ERR2_3,err3[2]); //************************************************* if ((onof==1)&(ahora_difuso==1)&(esquema==0)) //si está activado el control sup dif y el esquema de referencia { gain_diag(); //poner función para obtener las ganancias difusas y //pintar diagramas de fase. SetCtrlVal(SCREEN1,scr1_PIDGAIN_1,Gain_1); //Gain es la ganancia del supervisorio que es pasada a Gain_1 SetCtrlVal(SCREEN1,scr1_PIDGAIN_2,Gain_2); //Gain es la ganancia del supervisorio que es pasada a Gain_2 SetCtrlVal(SCREEN1,scr1_PIDGAIN_3,Gain_3); //Gain es la ganancia del supervisorio que es pasada a Gain_3 ref_difusa(); //función para obtener nuevos setpoints pos_brazo=refdif1; pos_brazo2=refdif2; pos_brazo3=refdif3; SetCtrlVal(SCREEN1,scr1_SP_difuso1,refdif1); SetCtrlVal(SCREEN1,scr1_SP_difuso2,refdif2); SetCtrlVal(SCREEN1,scr1_SP_difuso3,refdif3); } else { pos_brazo=ref1; pos_brazo2=ref2; pos_brazo3=ref3; } //************************************************* //Si está la opción de simulación entra a la función simula(), en caso contrario envía las posiciones;

104

if (simular==0) enviar_pos(pos_brazo); //Envía el punto de referencia else { simulacion(ParamDis); SetCtrlVal(SCREEN1,scr1_RECEIVE,Q_i[0]); SetCtrlVal(SCREEN1,scr1_RECEIVE_2,Q_i[1]); SetCtrlVal(SCREEN1,scr1_RECEIVE_3,Q_i[2]); pos_brazo_rx=Q_i[0]; pos_brazo2_rx=Q_i[1]; pos_brazo3_rx=Q_i[2]; } pos_arr[0]=pos_brazo_rx; pos_arr[1]=ref1; pos_arr2[0]=pos_brazo2_rx; pos_arr2[1]=ref2; pos_arr3[0]=pos_brazo3_rx; pos_arr3[1]=ref3; PlotStripChart(SCREEN1,scr1_PLOT,pos_arr,2,0,0,VAL_FLOAT); PlotStripChart(SCREEN1,scr1_PLOT2,pos_arr2,2,0,0,VAL_FLOAT); PlotStripChart(SCREEN1,scr1_PLOT3,pos_arr3,2,0,0,VAL_FLOAT); //************************************************* if ((onof==1)&(ahora_difuso==1)&(esquema==1)) //esto se agregó { gain_diag(); //poner función para obtener las ganancias difusas y //pintar diagramas de fase. enviar_pid(); } //************************************************* //Archiva datos si así se especifica if (logg==1) archivar(); else cont=0; break; } return 0; } int CVICALLBACK SETSEND (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: break; case EVENT_VAL_CHANGED:

105

GetCtrlVal(SCREEN1,scr1_SEND,/*&sentvalue*/&pos_brazo); break; } return 0; } int CVICALLBACK SETSEND2 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: GetCtrlVal(SCREEN1,scr1_SEND_2,/*&sentvalue*/&pos_brazo2); break; } return 0; } int CVICALLBACK SETSEND3 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: GetCtrlVal(SCREEN1,scr1_SEND_3,/*&sentvalue*/&pos_brazo3); break; } return 0; } int CVICALLBACK SETPIDGAIN (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: break; } return 0; } int CVICALLBACK SETEXIT (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: SuspendTimerCallbacks(); CerrarComunicacion(); QuitUserInterface (0); break; } return 0; }

106

int CVICALLBACK SETRATE (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { double rate; switch (event) { case EVENT_COMMIT: GetCtrlVal(SCREEN1,scr1_SAMPLINGRATE,&rate); SetCtrlAttribute(SCREEN1,scr1_TIMER1,ATTR_INTERVAL,rate); break; } return 0; } int CVICALLBACK SETX (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: break; } return 0; } int CVICALLBACK SETY (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: break; } return 0; } int CVICALLBACK SETZ (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: break; } return 0; } int CVICALLBACK CLOSE (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT:

107

RemovePopup(0); break; } return 0; } /****************************************************** * Callback que activa el control supervisorio difuso * * casillas de los PID's de los tres motores * ******************************************************/ int CVICALLBACK TOGGLE (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: //Se agregó GetCtrlVal(SCREEN1,scr1_BINARYSWITCH,&onof); if (onof==1) InstallPopup(panel_difuso); else ahora_difuso=0; break; } return 0; } int CVICALLBACK Poner_Sintonizar (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: ahora_difuso=0; InstallPopup(panel_difuso); break; } return 0; } int CVICALLBACK CLOCKONOFF (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { int clockrun; switch (event) { case EVENT_COMMIT: break; case EVENT_VAL_CHANGED: GetCtrlVal(SCREEN1,scr1_BINARYSWITCH_2,&clockrun); if(clockrun==0) SuspendTimerCallbacks (); if(clockrun==1) ResumeTimerCallbacks (); break; } return 0; }

108

/****************************************************************** * Callback que manda a cargar los valores ke c enkuentran en las * * casillas de los PID's de los tres motores * ******************************************************************/ int CVICALLBACK Poner_cargar_pid (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: if (onof==1) MessagePopup ("Precaución", "No se pueden modificar los parámetros del PID mientras el control supervisorio difuso se encuentre encendido. Coloca el selector en (off) para modificarlos"); else { //Parámetros PID del motor 1 GetCtrlVal(SCREEN1,scr1_KP_1,&kp1); GetCtrlVal(SCREEN1,scr1_ki_1,&ki1); GetCtrlVal(SCREEN1,scr1_kd_1,&kd1); //Parámetros PID del motor 2 GetCtrlVal(SCREEN1,scr1_KP_2,&kp2); GetCtrlVal(SCREEN1,scr1_ki_2,&ki2); GetCtrlVal(SCREEN1,scr1_kd_2,&kd2); //Parámetros PID del motor 3 GetCtrlVal(SCREEN1,scr1_KP_3,&kp3); GetCtrlVal(SCREEN1,scr1_ki_3,&ki3); GetCtrlVal(SCREEN1,scr1_kd_3,&kd3); enviar_pid(); } break; } return 0; } /******************************************************************* * Callback que manda a archivar todos los datos de los tres * * motores y de los diagramas de fase. * * Además archiva las posiciones absolutas y relativas de x, y y z * ******************************************************************/ int CVICALLBACK Poner_Archivar (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: GetCtrlVal(SCREEN1,scr1_Archivar,&logg); break; } return 0; }

109

/****************************************************************** * Callback que manda a guardar todos los datos de los tres * * motores y de los diagramas de fase. Esto c hace en Excel * * Además guarda las posiciones absolutas y relativas de x, y y z * ******************************************************************/ int CVICALLBACK poner_guardar (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: guardar(); break; } return 0; } /******************************************************** * Callback que manda a llamar la función de cinemática * ********************************************************/ int CVICALLBACK poner_boton_ir (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: { switch(tray) { case 0: //movimiento articular GetCtrlVal(SCREEN1,scr1_X,&C[0]); //Captura el pto al que hay ke ir GetCtrlVal(SCREEN1,scr1_Y,&C[1]); GetCtrlVal(SCREEN1,scr1_Z,&C[2]); CinematicaI(); break; case 1: // movimiento lineal nl=1000; //Captura el valor recibido para calcular las coordenadas espaciales actuales (pto_inicial) GetCtrlVal(SCREEN1,scr1_RECEIVE,&Q_i[0]); GetCtrlVal(SCREEN1,scr1_RECEIVE_2,&Q_i[1]); GetCtrlVal(SCREEN1,scr1_RECEIVE_3,&Q_i[2]); Q_i[0]=DegToRad (Q_i[0]); Q_i[1]=DegToRad (Q_i[1]); Q_i[2]=DegToRad (Q_i[2]);

110

CinematicaDirecta(ParamDis); GetCtrlVal(SCREEN1,scr1_X,&equis[1]); //Captura el punto final de x GetCtrlVal(SCREEN1,scr1_Y,&ye[1]); //Captura el punto final de y GetCtrlVal(SCREEN1,scr1_Z,&zeta[1]); //Captura el punto final de z interpolacion_lineal (); //función que genera todos los pto's cont_cine=0;//inicializa el contador break; } } } return 0; } int CVICALLBACK Poner_Boton_status_com (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { int stacom; switch (event) { case EVENT_COMMIT: GetCtrlVal(SCREEN1,scr1_Boton_status_com,&stacom); if (stacom==1) DisplayPanel(status_com); else HidePanel(status_com); break; } return 0; } /**************************************************************************** * Callback que pone en verde al LED al momento de comenzar la comunicación * * con el microcontrolador * ****************************************************************************/ int CVICALLBACK Poner_LED (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: break; } return 0; } /****************************************************************** * Callback que guarda el número del tipo de trayectoria a *

111

* ejecutarse: * * * * Joint (0)-----> Las articulaciones c mueven independienemente * * Lineal (1)----> Las articulaciones c mueven para generar una * * trayactoria lineal * * Circular (2)--> Las articulaciones c mueven para generar una * * trayectoria circular * * * ******************************************************************/ int CVICALLBACK Poner_Selec_trayec (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: GetCtrlVal(SCREEN1,scr1_Selec_trayec,&tray); if(tray==1) //interpolación lineal { GetCtrlVal(SCREEN1,scr1_X,&equis[0]); GetCtrlVal(SCREEN1,scr1_Y,&ye[0]); GetCtrlVal(SCREEN1,scr1_Z,&zeta[0]); } break; } return 0; } /******************************************************** * Callback que para saber que esquema utilizar: * * * * esquema=1---> Cambiar referencia (referencia difusa) * * esquema=2---> Cambiar parámetros PID (PID difuso) * * * ********************************************************/ int CVICALLBACK Poner_esquema (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: GetCtrlVal(SCREEN1,scr1_esquema,&esquema); break; } return 0; } /*************************************************** * Callback que captura el valor de los ángulos *

112

* recibidos y calcula la posición espacial actual * ***************************************************/ int CVICALLBACK poner_boton_donde (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: //Captura el valor recibido para calcular las coordenadas espaciales actuales (pto_inicial) GetCtrlVal(SCREEN1,scr1_RECEIVE,&Q_i[0]); GetCtrlVal(SCREEN1,scr1_RECEIVE_2,&Q_i[1]); GetCtrlVal(SCREEN1,scr1_RECEIVE_3,&Q_i[2]); Q_i[0]=DegToRad (Q_i[0]); Q_i[1]=DegToRad (Q_i[1]); Q_i[2]=DegToRad (Q_i[2]); CinematicaDirecta(ParamDis); SetCtrlVal(SCREEN1,scr1_X_actual,(SistemaVector[0]*1000)); SetCtrlVal(SCREEN1,scr1_Y_actual,(SistemaVector[1]*1000)); SetCtrlVal(SCREEN1,scr1_Z_actual,(SistemaVector[2]*1000)); break; } return 0; } /************************************************** * Callback que captura el valor del switch para * * simular o controlar el proceso real * * simula---> variable que si es 1, es que se * * simulará * * * **************************************************/ int CVICALLBACK Poner_a_simular_real (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: GetCtrlVal(SCREEN1,scr1_simular_real,&simular); break; } return 0; } int CVICALLBACK SetIrahome (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: instresp = 0x03; enviar_ins(); SetCtrlVal(SCREEN1,scr1_SEND,0.0); SetCtrlVal(SCREEN1,scr1_SEND_2,0.0); SetCtrlVal(SCREEN1,scr1_SEND_3,0.0);

113

SetCtrlVal(SCREEN1,scr1_X,0.0); SetCtrlVal(SCREEN1,scr1_Y,0.0); SetCtrlVal(SCREEN1,scr1_Z,-149.0); break; } return 0; } int CVICALLBACK SetCerrargrip (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: instresp = 0x02; enviar_ins(); break; } return 0; } int CVICALLBACK SetAbrirgrip (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: instresp = 0x01; enviar_ins(); break; } return 0; }

B.2 Archivar y guardar datos en Excel

#include <cviauto.h> #include "excelreport.h" #include <ansi_c.h> #include <formatio.h> #include "acerca_difusa.h" #include <cvirte.h> #include <userint.h> #include "Tesis_ParamDifus.h" #include "var_difuz.h" #include "serial2.h" #include "Globals.h" void archivar (); //Función que archiva los datos void guardar(); //Función que guarda los datos y los grafica en un archivo de excel. /*********************************************************************** * Función que archiva los datos de la posición angular y del valor de * * referencia de cada articulación, las coordenadas globales x, y y z. * * Además los valores del error y el cambio en el error, para poder *

114

*¨graficar los diagramas de fase de cada robot. * * * ***********************************************************************/ void archivar () { //Archivando datos de la articulación 1 reff1[cont]=pos_brazo; ang1[cont]=pos_brazo_rx; error1[cont]=err1[2]; derror1[cont]=err1[2]-err1[1]; //Archivando datos de la articulación 2 reff2[cont]=pos_brazo2; ang2[cont]=pos_brazo2_rx; error2[cont]=err2[2]; derror2[cont]=err2[2]-err2[1]; //Archivando datos de la articulación 3 reff3[cont]=pos_brazo3; ang3[cont]=pos_brazo3_rx; error3[cont]=err3[2]; derror3[cont]=err3[2]-err3[1]; cont=cont+1; //Contando elementos elementos=cont; //Archivando las unidades de tiempo tiempo[cont-1]=cont;//*rate; //checar si así c podría poner // log2[cont]=output; Esto c pone en el reloj // cont=cont+1; // elementos=cont; } void guardar() { static CAObjHandle appHandlexcel; static CAObjHandle workbookHandle; static CAObjHandle worksheetHandle; static CAObjHandle chartHandleArt1, chartHandleDiagF1, chartHandleArt2, chartHandleDiagF2, chartHandleArt3, chartHandleDiagF3; char pathNamex[MAX_PATHNAME_LEN]; char rangor1[MAX_PATHNAME_LEN], rangoa1[MAX_PATHNAME_LEN], rangoe1[MAX_PATHNAME_LEN], rangode1[MAX_PATHNAME_LEN], rangor2[MAX_PATHNAME_LEN], rangoa2[MAX_PATHNAME_LEN], rangoe2[MAX_PATHNAME_LEN], rangode2[MAX_PATHNAME_LEN], rangor3[MAX_PATHNAME_LEN], rangoa3[MAX_PATHNAME_LEN], rangoe3[MAX_PATHNAME_LEN], rangode3[MAX_PATHNAME_LEN], tiempom[MAX_PATHNAME_LEN], rangoArt1[MAX_PATHNAME_LEN], rangoArt2[MAX_PATHNAME_LEN], rangoArt3[MAX_PATHNAME_LEN], rangoDiagF1[MAX_PATHNAME_LEN], rangoDiagF2[MAX_PATHNAME_LEN], rangoDiagF3[MAX_PATHNAME_LEN]; /*Variables para el manejo de los archivos*/ //****************************************** static char nombre_archivo1[MAX_PATHNAME_LEN]; static int fileSaved1 = 1;

115

int popup1; //****************************************** sprintf(tiempom,"M2:M%d",elementos+1); sprintf(rangor1,"A2:A%d",elementos+1); sprintf(rangoa1,"B2:B%d",elementos+1); sprintf(rangoe1,"C2:D%d",elementos+1); sprintf(rangode1,"D2:D%d",elementos+1); sprintf(rangor2,"E2:E%d",elementos+1); sprintf(rangoa2,"F2:F%d",elementos+1); sprintf(rangoe2,"G2:G%d",elementos+1); sprintf(rangode2,"H2:H%d",elementos+1); sprintf(rangor3,"I2:I%d",elementos+1); sprintf(rangoa3,"J2:J%d",elementos+1); sprintf(rangoe3,"K2:K%d",elementos+1); sprintf(rangode3,"L2:L%d",elementos+1); popup1=FileSelectPopup ("", "*.xls", "","Selecciona el nombre y la ubicación para guardar los datos", VAL_SAVE_BUTTON, 0, 0, 1, 0, nombre_archivo1); switch (popup1) { case 0: return; } SetMouseCursor (VAL_HOUR_GLASS_CURSOR); ExcelRpt_ApplicationNew (VFALSE, &appHandlexcel); ExcelRpt_WorkbookNew (appHandlexcel, &workbookHandle); //Habilita el worksheet1 y elimina las otras dos con el archivo que está abierto ExcelRpt_GetWorksheetFromIndex (workbookHandle, 1, &worksheetHandle); ExcelRpt_SetWorksheetAttribute (worksheetHandle, ER_WS_ATTR_NAME, "Datos"); /*Escribir el tiempo*/ ExcelRpt_SetCellValue (worksheetHandle, "M1", ExRConst_dataString, "T. Mues"); ExcelRpt_WriteData (worksheetHandle, tiempom, ExRConst_dataDouble, elementos, 1, tiempo); /*Escribir en archivo nuevo lo de Lazo 1*/ //Referencia ExcelRpt_SetCellValue (worksheetHandle, "A1", ExRConst_dataString, "Ref 1"); ExcelRpt_WriteData (worksheetHandle, rangor1, ExRConst_dataDouble, elementos, 1, reff1); //ángulo real ExcelRpt_SetCellValue (worksheetHandle, "B1", ExRConst_dataString, "Áng 1"); ExcelRpt_WriteData (worksheetHandle, rangoa1, ExRConst_dataDouble, elementos, 1, ang1); //Error ExcelRpt_SetCellValue (worksheetHandle, "C1", ExRConst_dataString, "Error 1"); ExcelRpt_WriteData (worksheetHandle, rangoe1, ExRConst_dataDouble, elementos, 1, error1); //cambio en el error

116

ExcelRpt_SetCellValue (worksheetHandle, "D1", ExRConst_dataString, "DError 1"); ExcelRpt_WriteData (worksheetHandle, rangode1, ExRConst_dataDouble, elementos, 1, derror1); /****Escribir en archivo nuevo lo de Lazo 2****/ //Referencia ExcelRpt_SetCellValue (worksheetHandle, "E1", ExRConst_dataString, "Ref 2"); ExcelRpt_WriteData (worksheetHandle, rangor2, ExRConst_dataDouble, elementos, 1, reff2); //ángulo real ExcelRpt_SetCellValue (worksheetHandle, "F1", ExRConst_dataString, "Áng 2"); ExcelRpt_WriteData (worksheetHandle, rangoa2, ExRConst_dataDouble, elementos, 1, ang2); //Error ExcelRpt_SetCellValue (worksheetHandle, "G1", ExRConst_dataString, "Error 2"); ExcelRpt_WriteData (worksheetHandle, rangoe2, ExRConst_dataDouble, elementos, 1, error2); //cambio en el error ExcelRpt_SetCellValue (worksheetHandle, "H1", ExRConst_dataString, "DError 2"); ExcelRpt_WriteData (worksheetHandle, rangode2, ExRConst_dataDouble, elementos, 1, derror2); /****Escribir en archivo nuevo lo de Lazo 3****/ //Referencia ExcelRpt_SetCellValue (worksheetHandle, "I1", ExRConst_dataString, "Ref 3"); ExcelRpt_WriteData (worksheetHandle, rangor3, ExRConst_dataDouble, elementos, 1, reff3); //ángulo real ExcelRpt_SetCellValue (worksheetHandle, "J1", ExRConst_dataString, "Áng 3"); ExcelRpt_WriteData (worksheetHandle, rangoa3, ExRConst_dataDouble, elementos, 1, ang3); //Error ExcelRpt_SetCellValue (worksheetHandle, "K1", ExRConst_dataString, "Error 3"); ExcelRpt_WriteData (worksheetHandle, rangoe3, ExRConst_dataDouble, elementos, 1, error3); //cambio en el error ExcelRpt_SetCellValue (worksheetHandle, "L1", ExRConst_dataString, "DError 3"); ExcelRpt_WriteData (worksheetHandle, rangode3, ExRConst_dataDouble, elementos, 1, derror3); //Con los datos en Excel se grafican las curvas. //**Lazo 1 //Movimiento Articular sprintf(rangoArt1,"A2:B%d",elementos+1); ExcelRpt_ChartNew (workbookHandle, -1, &chartHandleArt1); ExcelRpt_ChartWizard (chartHandleArt1, worksheetHandle, rangoArt1, ExRConst_GalleryLine, 0, 0, 0, 0, 1, "Articulación 1", "Unidades de tiempo", "Ángulo", NULL); //**Lazo 1 //Movimiento Articular sprintf(rangoArt2,"E2:F%d",elementos+1); ExcelRpt_ChartNew (workbookHandle, -1, &chartHandleArt2); ExcelRpt_ChartWizard (chartHandleArt2, worksheetHandle, rangoArt2, ExRConst_GalleryLine, 0, 0, 0, 0, 1, "Articulación 2", "Unidades de tiempo", "Ángulo", NULL); //**Lazo 1

117

//Movimiento Articular sprintf(rangoArt3,"I2:J%d",elementos+1); ExcelRpt_ChartNew (workbookHandle, -1, &chartHandleArt3); ExcelRpt_ChartWizard (chartHandleArt3, worksheetHandle, rangoArt3, ExRConst_GalleryLine, 0, 0, 0, 0, 1, "Articulación 3", "Unidades de tiempo", "Ángulo", NULL); //Guarda el archivo en el archivo seleccionado allá arriba ExcelRpt_WorkbookSave (workbookHandle, nombre_archivo1, ExRConst_DefaultFileFormat); //Cerrar el workbook y la aplicación ExcelRpt_WorkbookClose (workbookHandle, 0); ExcelRpt_ApplicationQuit (appHandlexcel); //Descartando todos los handles de excel CA_DiscardObjHandle (chartHandleArt1); CA_DiscardObjHandle (worksheetHandle); CA_DiscardObjHandle (workbookHandle); CA_DiscardObjHandle (appHandlexcel); //Poner el cursor a normal SetMouseCursor (VAL_DEFAULT_CURSOR); }

B.3 Interfaz sintonía difuso

#include <windows.h> #include "word2000.h" #include "wordreport.h" #include "excelreport.h" #include <utility.h> #include "disenio.h" #include <ansi_c.h> #include <formatio.h> #include "acerca_difusa.h" #include <cvirte.h> #include <userint.h> #include "Tesis_ParamDifus.h" #include "var_difuz.h" #include "WordRpt.h" void cargar(void); void salva(void); /*Variables para el manejo de los archivos*/ //****************************************** static char nombre_archivo[MAX_PATHNAME_LEN]; static int fileSaved = 1; int popup; //****************************************** /*Inicializando variables difusas*/ int REGLA_defuzz=1;//Se inicializa en singletons

118

int varmax=2; //Se inicializa para que trabajen solo dos variables int REGLA_implicante=1; int REGLA_conjuncion=1; int CUBO_inferencias[7][7][7]={3}; //Se inicializa el cubo en 3, porke en tres es la parte central, es la regla del centro double IN_cuantitativas[3][1] = {0.0}; double IN_conjuntos[3][28]={0}; double IN_cualitativas[3][7]={0.0}; double OUT_cualitativas[344][7]={0.0}; double OUT_conjuntos[28]={0} ; double pesos[7]={0}; double OUT_cuantitativa[1]={1.0}; /*************************************************************** * Callback que asigna el método a utilizar para defuzzificar: * * - Singletons -> REGLA_defuzz=1 * * - Gravicentro -> REGLA_defuzz=2 * ***************************************************************/ int CVICALLBACK Poner_Defuzzi (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { //panel_difuso = LoadPanel (0, "Tesis_ParamDifus.uir", ParamDifus); //panel_acercadif = LoadPanel (0, "acerca_difusa.uir", Acercadifu); switch (event) { case EVENT_COMMIT: GetCtrlVal(panel_difuso,ParamDifus_Defuzzi,&REGLA_defuzz); if (REGLA_defuzz==1) { SetCtrlAttribute(panel_difuso,ParamDifus_Singletons, ATTR_VISIBLE,1); SetCtrlAttribute(panel_difuso,ParamDifus_Tabla_Fuzzyout, ATTR_DIMMED,1); } else { SetCtrlAttribute(panel_difuso,ParamDifus_Singletons, ATTR_VISIBLE,0); SetCtrlAttribute(panel_difuso,ParamDifus_Tabla_Fuzzyout, ATTR_DIMMED,0); } break; case EVENT_VAL_CHANGED: break; } return 0;

119

} /************************************************************************************************ * Callback para que al pulsar el botón de aceptar se cierre la ventana de parámetros difusos y * * le asigne un 1 a la variable listodifus (que es la que permite que se corra el difuso) * ************************************************************************************************/ int CVICALLBACK Poner_Aceptar_Cdifuso (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { int i,j, k; double valor_trapecio; double valor_trapecioout; double valor_inferenciad; int valor_inferencia; double valor_singleton; switch (event) //Este callback debe ir en a interfaz principal, donde se va a { // encontrar la habilitación para el control supervisorio case EVENT_COMMIT: // hay que agregarle otra variable. //Llenando las variables de las tablas //Primero la de fuzzificación for (i=1; i<=3; i=i+1) for(j=1; j<=28; j=j+1) { GetTableCellVal(panel_difuso, ParamDifus_Tabla_Fuzzy, MakePoint (j,i), &valor_trapecio); IN_conjuntos[i-1][j-1]=valor_trapecio; } //Después la de conjuntos de salida for (k=1; k<=28; k=k+1) {GetTableCellVal(panel_difuso, ParamDifus_Tabla_Fuzzyout, MakePoint (k,1), &valor_trapecioout); OUT_conjuntos[k-1]=valor_trapecioout;} //Después la de Inferencia for(i=1; i<=7; i=i+1) for(j=1; j<=7; j=j+1) {GetTableCellVal(panel_difuso, ParamDifus_Tabla_Infe, MakePoint(i,j),&valor_inferenciad); //Poner en tabla de inferencias de diseño 1 SetTableCellVal(panel_disenio, Herr_disen_Tabla_Infe_herr1, MakePoint(i,j),valor_inferenciad); //Poner en tabla de inferencias de diseño 2 SetTableCellVal(panel_disenio2, Herr_dise2_Tabla_Infe_herr2, MakePoint(i,j),valor_inferenciad);

120

//Poner en tabla de inferencias de diseño 3 SetTableCellVal(panel_disenio3, Herr_dise3_Tabla_Infe_herr3, MakePoint(i,j),valor_inferenciad); valor_inferencia = (int) valor_inferenciad; CUBO_inferencias[i-1][6-(j-1)][0]=valor_inferencia+3;} //Por último la de Singletons for(i=1; i<=7; i=i+1) {GetTableCellVal(panel_difuso, ParamDifus_Singletons, MakePoint(i,1),&valor_singleton); pesos[i-1]=valor_singleton; //Poner en tabla de singletons de diseño 1 SetTableCellVal(panel_disenio,Herr_disen_Singletons_herr1, MakePoint(i,1), valor_singleton); //Poner en tabla de singletons de diseño 2 SetTableCellVal(panel_disenio2,Herr_dise2_Singletons_herr2, MakePoint(i,1), valor_singleton); //Poner en tabla de singletons de diseño 3 SetTableCellVal(panel_disenio3,Herr_dise3_Singletons_herr3, MakePoint(i,1), valor_singleton);} //Tmb la del panel principal for (i=0; i<7; i=i+1) SetTableCellVal(panel_disenio, Herr_disen_Singletons_herr, MakePoint(i+1,1),pesos[i]); ahora_difuso=1; RemovePopup (0); break; } return 0; } /***************************************************************************************** * Callback que abre la rutina para abrir un archivo de Excel con los parámetros Difusos * *****************************************************************************************/ void CVICALLBACK Poner_Abrir (int menuBar, int menuItem, void *callbackData, int panel) { static CAObjHandle appHandlexcel; static CAObjHandle workbookHandle; static CAObjHandle worksheetHandle; char pathNamex[MAX_PATHNAME_LEN]; //asking for the file to load

121

popup=FileSelectPopup ("", "*.xls", "","Selecciona el archivo con los parámetros difusos que quieres abrir", VAL_LOAD_BUTTON, 0, 0, 1, 0, nombre_archivo); switch (popup) { case 0: return; } ExcelRpt_ApplicationNew (VTRUE, &appHandlexcel); ExcelRpt_WorkbookOpen (appHandlexcel, nombre_archivo, &workbookHandle); return; } /************************************************************************************************ * Callback que abre la rutina para cargar los datos del difuso de un archivo de Excel hacia las * * Tablas de Fuzzificación, inferencias y singletons. * ************************************************************************************************/ void CVICALLBACK Poner_CargarDifus (int menuBar, int menuItem, void *callbackData, int panel) { static CAObjHandle appHandlexcel; static CAObjHandle workbookHandle; static CAObjHandle worksheetHandle; //asking for the file to load popup=FileSelectPopup ("", "*.xls", "","Selecciona el archivo con los parámetros difusos", VAL_LOAD_BUTTON, 0, 0, 1, 0, nombre_archivo); switch (popup) { case 0: return; } ExcelRpt_ApplicationNew (VFALSE, &appHandlexcel); ExcelRpt_WorkbookOpen (appHandlexcel, nombre_archivo, &workbookHandle); //setting the mouse to hour glass SetMouseCursor (VAL_HOUR_GLASS_CURSOR); //Habilita el worksheet con el archivo que está abierto ExcelRpt_GetWorksheetFromIndex (workbookHandle, 1, &worksheetHandle); //LLena la tabla de fuzzificación ExcelRpt_ReadDataToTableControl (worksheetHandle, "A4:AB6", MakePoint (1, 1), ExRConst_Overwrite, panel_difuso, ParamDifus_Tabla_Fuzzy);

122

//Llena la tabla para la manipulación en caso de utilizar gravicentro ExcelRpt_ReadDataToTableControl (worksheetHandle, "A7:AB7", MakePoint (1, 1), ExRConst_Overwrite, panel_difuso, ParamDifus_Tabla_Fuzzyout); //LLena la tabla de inferencia ExcelRpt_ReadDataToTableControl (worksheetHandle, "V12:AB18", MakePoint (1, 1), ExRConst_Overwrite, panel_difuso, ParamDifus_Tabla_Infe); //Llena la tabla de singletons en caso de utilizarlas ExcelRpt_ReadDataToTableControl (worksheetHandle, "U26:AA26", MakePoint (1, 1), ExRConst_Overwrite, panel_difuso, ParamDifus_Singletons); //Cerrar el workbook y la aplicación ExcelRpt_WorkbookClose (workbookHandle, 0); ExcelRpt_ApplicationQuit (appHandlexcel); //Descartando todos los handles de excel CA_DiscardObjHandle (worksheetHandle); CA_DiscardObjHandle (workbookHandle); CA_DiscardObjHandle (appHandlexcel); //Poner el cursor a normal SetMouseCursor (VAL_DEFAULT_CURSOR); return; } /******************************************************************************************** * Callback que abre la rutina para guardar los datos del difuso desde las tablas de fuzzy, * * inferencias y singletons hacia un archivo de Excel * ********************************************************************************************/ void CVICALLBACK Poner_GuardarDifus (int menuBar, int menuItem, void *callbackData, int panel) { static CAObjHandle appHandlexcel; static CAObjHandle workbookHandle; static CAObjHandle worksheetHandle; //asking for the file to load popup=FileSelectPopup ("", "*.xls", "","Selecciona el archivo con los parámetros difusos", VAL_LOAD_BUTTON, 0, 0, 1, 0, nombre_archivo); switch (popup) { case 0: return; }

123

ExcelRpt_ApplicationNew (VFALSE, &appHandlexcel); ExcelRpt_WorkbookOpen (appHandlexcel, nombre_archivo, &workbookHandle); //setting the mouse to hour glass SetMouseCursor (VAL_HOUR_GLASS_CURSOR); //Habilita el worksheet con el archivo que está abierto ExcelRpt_GetWorksheetFromIndex (workbookHandle, 1, &worksheetHandle); //Llenar la tabla de fuzzificación ExcelRpt_WriteDataFromTableControl (worksheetHandle, "A4:AB6", panel_difuso, ParamDifus_Tabla_Fuzzy); //Llenar la tabla de manipulación (gravicentro) ExcelRpt_WriteDataFromTableControl (worksheetHandle, "A7:AB7", panel_difuso, ParamDifus_Tabla_Fuzzyout); //Llenar la tabla de inferencia ExcelRpt_WriteDataFromTableControl (worksheetHandle, "V12:AB18", panel_difuso, ParamDifus_Tabla_Infe); //Llenar la tabla de singletons ExcelRpt_WriteDataFromTableControl (worksheetHandle, "U26:AA26", panel_difuso, ParamDifus_Singletons); //Cerrar el workbook y la aplicación ExcelRpt_WorkbookClose (workbookHandle, 0); ExcelRpt_ApplicationQuit (appHandlexcel); //Descartando todos los handles de excel CA_DiscardObjHandle (worksheetHandle); CA_DiscardObjHandle (workbookHandle); CA_DiscardObjHandle (appHandlexcel); return; } /******************************************************************************************** * Callback que abre el archivo de word sobre la ayuda de la pantalla de parámetros difusos * ********************************************************************************************/ void CVICALLBACK Poner_Contenido (int menuBar, int menuItem, void *callbackData, int panel) { static CAObjHandle appHandle; static CAObjHandle docHandle; char pathName[MAX_PATHNAME_LEN]; WordRpt_ApplicationNew (VTRUE, &appHandle); GetProjectDir (pathName);

124

strcat (pathName, "\\ayuda.doc"); WordRpt_DocumentOpen (appHandle, pathName, &docHandle); //LaunchExecutable ("c:\\windows\\notepad.exe ayuda.txt"); } /************************************************************************************************** * Callback que abre el archivo de texto sobre la información del autor y la versión del programa * **************************************************************************************************/ void CVICALLBACK Poner_Acerca (int menuBar, int menuItem, void *callbackData, int panel) { InstallPopup(panel_acercadif); } /********************************************* * Callback que cierra el panel Acerca de... * *********************************************/ int CVICALLBACK Poner_ok_acercdifus (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: RemovePopup(0); break; } return 0; } /**************************************************** * Callback que despliega las heramientas de diseño * ****************************************************/ int CVICALLBACK poner_disenio_motor1 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: GetCtrlVal(panel_difuso,ParamDifus_disenio_motor1,&okas1); if (okas1==1) DisplayPanel(panel_disenio); else HidePanel(panel_disenio); break; } return 0; } int CVICALLBACK poner_disenio_motor2 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) {

125

switch (event) { case EVENT_COMMIT: GetCtrlVal(panel_difuso,ParamDifus_disenio_motor2,&okas2); if (okas2==1) DisplayPanel(panel_disenio2); else HidePanel(panel_disenio2); break; } return 0; } int CVICALLBACK poner_disenio_motor3 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: GetCtrlVal(panel_difuso,ParamDifus_disenio_motor3,&okas3); if (okas3==1) DisplayPanel(panel_disenio3); else HidePanel(panel_disenio3); break; } return 0; } /******************************************************************************************* *Callback que despliega un archivo con la información del controlador difuso implementado * *******************************************************************************************/ void CVICALLBACK MEN_SETCdifuso (int menuBar, int menuItem, void *callbackData, int panel) { } /********************************************************************* * Callbacks del popup de las herramientas de diseño para el motor 1 * *********************************************************************/ // * Callback que limpia el diagrama de fase del motor 1 * int CVICALLBACK Poner_Limpiar (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT:

126

DeleteGraphPlot (panel_disenio, Herr_disen_Diagrama_Fase,-1, VAL_IMMEDIATE_DRAW); break; } return 0; } // * Callback que cierra las herramientas de diseño del motor 1 * int CVICALLBACK Poner_Cerrar_herr (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: HidePanel(panel_disenio); break; } return 0; } /********************************************************************* * Callbacks del popup de las herramientas de diseño para el motor 2 * *********************************************************************/ // * Callback que limpia el diagrama de fase del motor 2 * int CVICALLBACK Poner_Limpiar2 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: DeleteGraphPlot (panel_disenio2, Herr_dise2_Diagrama_Fase2,-1, VAL_IMMEDIATE_DRAW); break; } return 0; } // * Callback que cierra las herramientas de diseño del motor 2 * int CVICALLBACK Poner_Cerrar_herr2 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: HidePanel(panel_disenio2); break; } return 0;

127

} /********************************************************************* * Callbacks del popup de las herramientas de diseño para el motor 3 * *********************************************************************/ // * Callback que limpia el diagrama de fase del motor 3 * int CVICALLBACK Poner_Limpiar3 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: DeleteGraphPlot (panel_disenio3, Herr_dise3_Diagrama_Fase3,-1, VAL_IMMEDIATE_DRAW); break; } return 0; } // * Callback que cierra las herramientas de diseño del motor 3 * int CVICALLBACK Poner_Cerrar_herr3 (int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: HidePanel(panel_disenio3); break; } return 0; }

tesis (5 de noviembre)

Documents