INDICE

INDICE...................................................................................................................2 Parte I

Memoria .............................................................................................4

Prólogo ...................................................................................................................5 Capítulo 1

Introdución ....................................................................................6

1

Estudio de los trabajos existentes / tecnologías existentes ........................ 6

2

Motivación del proyecto................................................................................... 6

3

Objetivos ............................................................................................................. 7

4

Metodología / Solución desarrollada ............................................................. 7

5

Recursos / herramientas empleadas ............................................................... 7

Capítulo 2

Introducción a LINUX .................................................................8

1

Historia de Linux ............................................................................................. 10

2

Características de Linux.................................................................................. 13

3

¿Qué son las "distribuciones" de GNU/Linux? .......................................... 17

4

Linux frente a los otros sistemas operativos............................................... 18

Capítulo 3

Introducción al PLC ...................................................................20

1

Controladores Lógico Programbles (PLC´S ).............................................. 20

2

Descripción y Funcionamiento de un PLC ................................................. 22

3

Campos de aplicación de un PLC ................................................................. 26

4

Lenguajes de Programación........................................................................... 28

Capítulo 4

Mat-PLC ......................................................................................33

1

¿ Qué es Mat-PLC ?.......................................................................................... 33

2

Arquitectura de MatPLC ................................................................................ 34

3

Modulo IL (Instruction List).......................................................................... 39

INDICE

3

3.1 Lista de Instrucciones ................................................................................................. 39 3.2 Transformación a un archivo en C ........................................................................... 44

4

Modulo HMI GTK ( GLADE ) ...................................................................... 50 4.1 Introducción ................................................................................................................. 50 4.2 Descripción módulo HMI (GLADE) ........................................................................ 51 4.3 Definición de entradas y salidas............................................................................... 52 4.4 Tipos de widgets.......................................................................................................... 55 4.4 Definición de proyecto en GLADE .......................................................................... 57

5

Modulo Puerto Paralelo.................................................................................. 58 5.1 CONFIGURACIÓN .................................................................................................... 59

Capítulo 5

Hardware Realizado ..................................................................61

Capítulo 6

Aplicaciones Desarrollados ......................................................63

1

Aplicación ascensor ......................................................................................... 63 1.1 Funcionamiento del ascensor .................................................................................... 63 1.2 Desarrollo del Interface Gráfico (HMI)................................................................... 66 1.3 Desarrollo del archivo de configuración matplc.conf...................................... 71 1.4 Código bajo Lista de Instrucciones .......................................................................... 74 1.5 Código transformado a C ........................................................................................... 81

2

Ejemplo Rapidez.............................................................................................. 97 2.1 Funcionamiento básico del ejemplo rapidez......................................................... 97 2.2 Desarrollo del interfaz gráfico (HMI)...................................................................... 98 2.3 Desarrollo del archivo de configuración matplc.conf.................................... 100 2.4 Código bajo Lista de Instrucciones ........................................................................ 102

Capítulo 7

Resultados Y Experimentos.....................................................107

Capítulo 8

Conclusiones..............................................................................109

Capítulo 9

Futuros Desarrollos..................................................................110

Parte II

Estudio Económico .......................................................................111

Parte III

Anexos ............................................................................................113

1

ANEXO MANUAL GLADE......................................................................... 114

2

ANEXO IEC 61131-3 ...................................................................................... 136

Gonzalo Julián Santander Palacios

INDICE

4

Parte I MEMORIA

Gonzalo Julián Santander Palacios

Prólogo

5

PRÓLOGO

En la memoria de este proyecto se recogen los análisis, estudios y trabajos realizados para conseguir un Sistea de Control Logico Programable (PLC) que trabaja bajos el S.O. LINUX; más concretamente sobre uno de las aplicaciones de simulación de PLC´s más potentes que se pueden encontrar bajo S.O. LINUX. más concretamente sobre el modulo IL (Lista de Instrucciones) el cual se encarga de transforman un código escrito bajo lista de instrucciones a un módulo en C que MatPLC pueda entender y utilizar. A lo largo de la memoria además se encontraran diferentes estudios de alguno de los módulos más importantes de MatPLC tal como el IL (Lista de Instrucciones), el cual se encarga de transforman un código escrito bajo lista de instrucciones a un módulo en C que MatPLC pueda entender y usar, o como el HMI_GTK, el cual se encarga del interfaz gráfico que se va ha servir de puente entre el operario y el sistema, otro de los módulos utilizados ha sido el del Parallel Port, el cual se encarga del manejo del puerto paralelo, la utilidad de este modulo ha sido la

de acercar lo

máximo posible a la realidad el simulador, de tal manera que las señales de entrada y salida fueran reales generadas por un hardware especifico para este propósito. En las aplicaciones reales desarrollados en la memoria se puede ver como el modulo IL funciona e interacciona perfectamente con los otros dos módulos expuestos anteriormente, asimismo se encontrará detalladamente como funciona

MatPLC y cuales son las operaciones que hay que

desarrollar par que todas las partes que lo forman trabajen correctamente.

Gonzalo Julián Santander Palacios

Introdución

6

Capítulo 1 INTRODUCIÓN

El proyecto “Sistema de Control Lógico Programable (PLC) sobre Hardware Embebido y bajo Sistema Operativo Linux” ha sido desarrollado para la empresa Sistemas Avanzados de Control S.A. (S.A.C. S.A.), dicho proyecto tiene el propósito la creación de Sistema de Control Lógico Programable, para ello se apoyo en el potente simulador de PLC´s MatPLC.

1 Estudio de los trabajos existentes / tecnologías existentes Hay que destacar que el proyecto se ha basado en el estudio sobre programas y aplicaciones ya existentes dentro de la industria de la automática; tanto LINUX como MatPLC, las dos aplicaciones más importantes que han impulsado el proyecto ya han sido desarrolladas, por lo tanto se paso a su estudio, dando gran importancia a MatPLC y más concretamente a algunos de sus módulos (módulo IL, HMI_GTK, Puerto Paralelo), gran parte de la información sobre MatPLC se ha encontrado en manual

desarrollado

en

la

pagina

web

http://mat.sourceforge.net/manual.

2 Motivación del proyecto La gran motivación ha sido el desarrollo de un Sistema de Control Lógico Programable (PLC) sobre Hardware Embebido y bajo Sistema Operativo Linux, dicho sistema al ser una aplicación que trabaja bajo LINUX es un sistema de Código Abierto y por lo tanto no tiene ningún coste adicional, lo cual supondría a la empresa S.A.C. S.A. un gran beneficio ya que se eliminarían costes de programas de simulaciones de PLC’s. Gonzalo Julián Santander Palacios

Introdución

3 Objetivos El objetivo Principal del proyecto es desarrollar Sistema de Control Lógico Programable (PLC) sobre Hardware Embebido y bajo Sistema Operativo Linux, apoyándose sobre aplicaciones existentes dentro de LINUX, más concretamente sobre la aplicación de simulación de PLC´s MatPLC

4 Metodología / Solución desarrollada El camino seguido para conseguir los objetivos ha sido el estudio de todos y cada uno de los componentes que forman MatPLC, empezando desde el sistema operativo con el cual se maneja, osease LINUX, continuando con el funcionamiento de MatPLC y todos los módulos más importantes que lo forman, destacando el Instruction List, HMI_GTK (Human Machina Intergface) y el Parallel Port (Puerto Paralelo). Para la verificación de MatPLC se han desarrollaron diferentes aplicaciones que englobaban los módulos mencionados.

5 Recursos / herramientas empleadas Las herramientas más destacadas han sido las siguientes: 1. Ordenador que contenía el sistema operativo LINUX y los programas MatPLC y GLADE. 2. El laboratorio de la empresa, en cual se realizó el Hardware necesario para comprobar el módulo IL de MatPLC. 3. Memoria Usb 4. Live-CD KNOPPIX 5.0

Gonzalo Julián Santander Palacios

7

Introducción a LINUX

8

Capítulo 2 INTRODUCCIÓN A LINUX

Linux e

s una implementación de libre

distribución UNIX para computadoras personales (PC), servidores, y estaciones de trabajo. Fue desarrollado para el i386 y ahora soporta los procesadores i486, Pentium, Pentium Pro y Pentium II, así como los clones AMD y Cyrix. También soporta máquinas basadas en SPARC, DEC Alpha, PowerPC/PowerMac, y Mac/Amiga Motorola 680x0.

Figura 2-1. Logo LINUX Como sistema operativo, Linux es muy eficiente y tiene un excelente diseño. Es multitarea, multiusuario, multiplataforma y multiprocesador; en las plataformas Intel corre en modo protegido; protege la memoria para que un programa no pueda hacer caer al resto del sistema; carga sólo las partes de un programa que se usan; comparte la memoria entre programas aumentando la velocidad y disminuyendo el uso de memoria; usa un sistema de memoria virtual por páginas; utiliza toda la memoria libre para cache;

permite

usar

bibliotecas

enlazadas

tanto

estática

como

dinámicamente; se distribuye con código fuente; usa hasta 64 consolas virtuales; tiene un sistema de archivos avanzado pero puede usar los de

Gonzalo Julián Santander Palacios

Introducción a LINUX los otros sistemas; y soporta redes tanto en TCP/IP como en otros protocolos.

Gonzalo Julián Santander Palacios

9

Introducción a LINUX

1 Historia de Linux LINUX hace su aparición a principios de la década de los noventa, era el año 1991 y por aquel entonces un estudiante de informática de la Universidad de Helsinki, llamado Linus Torvalds empezó, -como una afición y sin poderse imaginar a lo que llegaría este proyecto, a programar las primeras líneas de código de este sistema operativo llamado LINUX. Este comienzo estuvo inspirado en MINIX, un pequeño sistema Unix desarrollado por Andy Tanenbaum. Las primeras discusiones sobre Linux fueron en el grupo de noticias comp.os.minix, en estas discusiones se hablaba sobre todo del desarrollo de un pequeño sistema Unix para usuarios de Minix que querían más. Linus nunca anuncio la versión 0.01 de Linux (agosto 1991), esta versión no era ni siquiera ejecutable, solamente incluía los principios del núcleo del sistema, estaba escrita en lenguaje ensamblador y asumía que uno tenia acceso a un sistema Minix para su compilación. El 5 de octubre de 1991, Linus anuncio la primera versión " Oficial" de Linux, -versión 0.02. Con esta versión Linus pudo ejecutar Bash (GNU Bourne Again Shell) y gcc (El compilador GNU de C) pero no mucho mas funcionaba. En este estado de desarrollo ni se pensaba en los términos soporte, documentación, distribución. Después de la versión 0.03, Linus salto en la numeración hasta la 0.10, mas y mas programadores a lo largo y ancho de Internet empezaron a trabajar en el proyecto y después de sucesivas revisiones, Linus incremento el número de versión hasta la 0.95 ( Marzo 1992). Más de un año después (diciembre 1993) el núcleo del sistema estaba en la versión 0.99 y la versión 1.0 no llego hasta el 14 de marzo de 1994. Desde entonces no se ha parado de desarrollar, la versión actual del núcleo es la 2.2 y sigue avanzando día a día con la meta de perfeccionar y mejorar el sistema. Gonzalo Julián Santander Palacios

10

Introducción a LINUX

Linus Benedict Torvalds Linus Benedict Torvalds nació en Helsinki, Finlándia, el año 1969. Empezó a "trabajar" con ordenadores a los 10 años, cuando su abuelo le compró un Comodore el año 1980. Éste buen señor era un matemático y estadista. Trabajaba a la Universidad y fue quién "enganchó" al mundo de los computadores a nuestro buen amigo Linus. Con el paso del tiempo, Linus pasó a tener un Sinclair QL, un gran ordenador de Clive Sinclair (creador del conocido Spectrum), que tenía algún pequeño error de diseño. Linus se sintió especialmente atraído por esta máquina, después de crear aplicaciones para ésta computadora y de haber retocado su hardware con la finalidad de adaptarlo a sus necesidades. El problema que tenía dicha máquina era que los recursos eran insuficientes para poder llevar a la práctica los planes de Linus. Además, no era un equipo compatible. Así pues, el mes de enero de 1991 compró su primer PC, un 386. Retrocedamos otra vez en el tiempo, hasta 1988. Éste año fue cuando Linus entró a la Universidad. Este mismo año fue cuando un sistema operativo didáctico, basado en Unix y creado por Andy Tannenbaum, empezó a cobrar importancia. Dicho sistema operativo era el famoso Minix. Linus entró a formar parte de la comunidad de usuarios de Minix. Tannenbaum cometió un error en su sistema operativo. Era demasiado limitado, tanto técnicamente como políticamente, es decir, en ningún momento tuvo en cuenta la posibilidad de incluir Minix al proyecto GNU (creado el año 1983 por Richard Stallman). En realidad, la creación de Andy Tannenbaum estaba pensada para ser distribuida comercialmente. Su principal error fue ceder todos los derechos a Prentice Hall, que empezó a cobrar 150 dólares por licencia (unas 22.500 ptas. / 135.23 euros). Gonzalo Julián Santander Palacios

11

Introducción a LINUX Así pues, Linus tomó la decisión de cambiar esta política debido a que el sistema Minix era ideal para los estudiantes de sistemas operativos, y su precio era considerablemente alto. Llegamos de nuevo al año 1991, cuando Linus se acabó de comprar su primer 386. En aquellos momentos, la intención de nuestro amigo era clara: crear un nuevo Kernel de UNIX basado en el Kernel de Minix y modificarlo periódicamente de manera que fuera capaz de ejecutar aplicaciones GNU. A pesar de todo, no toda la vida del Sr. Linus ha estado dedicada exclusivamente al sistema operativo Linux... Actualmente Linus Torvalds vive desde el año 1997 en Santa Clara, California, junto con su esposa Tove y sus dos hijas, Patricia Miranda y Daniela. Le encanta jugar con sus dos pequeñas. Está trabajando para Transmeta, aunque nadie no sabe demasiado bién en qué trabaja. Parece ser que existe una cláusula en su contrato que le impide revelar dicha información. De todas formas, se sabe que Transmeta está desarrollando un nuevo procesador con un juego de instrucciones RISC capaz de ejecutar código x86. Tal vez una de las aficiones más conocidas de Linus es que le le gusta la cerveza, más aún si es Guinness. Así lo demostraron los miembros del SVLUG (Silicon Valley Linux User Group) cuando Linus fué a visitarlos para llevar a cabo una conferencia y le regalaron una caja de cerveza... Poca cosa más de sabe de este personaje que ha cambiado la forma de ver los ordenadores durante estos últimos años y que ha conseguido dar un buen empujón al proyecto GNU.

Gonzalo Julián Santander Palacios

12

Introducción a LINUX

2 Características de Linux

•

Multitarea: La palabra multitarea describe la habilidad de ejecutar varios programas al mismo tiempo. LINUX utiliza la llamada multitarea preventivas, la cual asegura que todos los programas que se están utilizando en un momento dado serán ejecutados, siendo el sistema operativo el encargado de ceder tiempo de microprocesador a cada programa.

•

Multiusuario: Muchos usuarios usando la misma maquina al mismo tiempo.

•

Multiplataforma: Las plataformas en las que en un principio se puede utilizar Linux son 386-, 486-. Pentium, Pentium Pro, Pentium II,Amiga y Atari, también existen versiones para su utilización en otras plataformas, como Alpha, ARM, MIPS, PowerPC y SPARC.

•

Multiprocesador: Soporte para sistemas con mas de un procesador esta disponible para Intel y SPARC.

•

Funciona en modo protegido 386.

•

Protección de la memoria entre procesos, de manera que uno de ellos no pueda colgar el sistema.

•

Carga de ejecutables por demanda: Linux sólo lee del disco aquellas partes de un programa que están siendo usadas actualmente.

•

Política de copia en escritura para la compartición de páginas entre ejecutables: esto significa que varios procesos pueden usar la misma zona de memoria para ejecutarse. Cuando alguno intenta escribir en esa memoria, la página (4Kb de memoria) se copia a otro lugar. Esta política de copia en escritura tiene dos beneficios: aumenta la velocidad y reduce el uso de memoria.

Gonzalo Julián Santander Palacios

13

Introducción a LINUX •

Memoria virtual usando paginación (sin intercambio de procesos completos) a disco: A una partición o un archivo en el sistema de archivos, o ambos, con la posibilidad de añadir más áreas de intercambio sobre la marcha Un total de 16 zonas de intercambio de 128Mb de tamaño máximo pueden ser usadas en un momento dado con un límite teórico de 2Gb para intercambio. Este limite se puede aumentar fácilmente con el cambio de unas cuantas líneas en el código fuente.

•

La memoria se gestiona como un recurso unificado para los programas de usuario y para el caché de disco, de tal forma que toda la memoria libre puede ser usada para caché y ésta puede a su vez ser reducida cuando se ejecuten grandes programas.

•

Librerías compartidas de carga dinámica (DLL's) y librerías estáticas.

•

Se realizan volcados de estado (core dumps) para posibilitar los análisis post-mortem, permitiendo el uso de depuradores sobre los programas no sólo en ejecución sino también tras abortar éstos por cualquier motivo.

•

Compatible con POSIX, System V y BSD a nivel fuente.

•

Emulación de iBCS2, casi completamente compatible con SCO, SVR3 y SVR4 a nivel binario.

•

Todo el código fuente está disponible, incluyendo el núcleo completo y todos los drivers, las herramientas de desarrollo y todos los programas de usuario; además todo ello se puede distribuir libremente. Hay algunos programas comerciales que están siendo ofrecidos para Linux actualmente sin código fuente, pero todo lo que ha sido gratuito sigue siendo gratuito.

•

Control de tareas POSIX.

•

Pseudo-terminales (pty's).

Gonzalo Julián Santander Palacios

14

Introducción a LINUX •

Emulación de 387 en el núcleo, de tal forma que los programas no tengan que hacer su propia emulación matemática. Cualquier máquina que ejecute Linux parecerá dotada de coprocesador matemático. Por supuesto, si el ordenador ya tiene una FPU (unidad de coma flotante), esta será usada en lugar de la emulación, pudiendo incluso compilar tu propio kernel sin la emulación matemática y conseguir un pequeño ahorro de memoria.

•

Soporte para muchos teclados nacionales o adaptados y es bastante fácil añadir nuevos dinámicamente.

•

Consolas virtuales múltiples: varias sesiones de login a través de la consola entre las que se puede cambiar con las combinaciones adecuadas de teclas (totalmente independiente del hardware de video). Se crean dinámicamente y puedes tener hasta 64.

•

Soporte para varios sistemas de archivo comunes, incluyendo minix-1, Xenix y todos los sistemas de archivo típicos de System V, y tiene un avanzado sistema de archivos propio con una capacidad de hasta 4 Tb y nombres de archivos de hasta 255 caracteres de longitud.

•

Acceso transparente a particiones MS-DOS (o a particiones OS/2 FAT) mediante un sistema de archivos especial: no es necesario ningún comando especial para usar la partición MS-DOS, esta parece un sistema de archivos normal de Unix (excepto por algunas restricciones en los nombres de archivo, permisos, y esas cosas). Las particiones comprimidas de MS-DOS 6 no son accesibles en este momento, y no se espera que lo sean en el futuro. El soporte para VFAT (WNT, Windows 95) ha sido añadido al núcleo de desarrollo y estará en la próxima versión estable.

•

Un sistema de archivos especial llamado UMSDOS que permite que Linux sea instalado en un sistema de archivos DOS.

Gonzalo Julián Santander Palacios

15

Introducción a LINUX •

Soporte en sólo lectura de HPFS-2 del OS/2 2.1

•

Sistema de archivos de CD-ROM que lee todos los formatos estándar de CD-ROM.

•

TCP/IP, incluyendo ftp, telnet, NFS, etc.

•

Appletalk.

•

Software cliente y servidor Netware.

•

Lan Manager / Windows Native (SMB), software cliente y servidor.

•

Diversos protocolos de red incluidos en el kernel: TCP, IPv4, IPv6, AX.25, X.25, IPX, DDP, Netrom, etc.

Gonzalo Julián Santander Palacios

16

Introducción a LINUX

17

3 ¿Qué son las "distribuciones" de GNU/Linux? Una distribución es un modo de facilitar la instalación, la configuración y el mantenimiento de un sistema GNU/Linux. Al principio, las distribuciones se limitaban a recopilar software libre, empaquetarlo en disquetes o CD-ROM y redistribuirlo o venderlo. Ahora las grandes distribuciones -RedHat, SuSE, Caldera, Mandrake, Corel Linux, TurboLinux...- son potentes empresas que compiten entre sí por incluir el último software, a veces también software propietario, con instalaciones gráficas capaces de auto detectar el hardware y que instalan un sistema entero en unos cuantos minutos sin apenas preguntas. Entre

las

distribuciones

de

GNU/Linux,

destaca

el

proyecto

Debian/GNU. Debian nace como una iniciativa no comercial de la FSF, aunque luego se independiza de ésta y va más allá del propio sistema GNU/Linux. Es la única de las grandes distribuciones que no tiene intereses comerciales ni empresariales. Son sus propios usuarios, muy activos, quienes mantienen la distribución de modo comunitario, incluidas todas sus estructuras de decisión y funcionamiento. Su objetivo es recopilar, difundir y promover el uso del software libre. Reúne el mayor catálogo de software libre, todos ellos probados, mantenidos y documentados por algún desarrollador voluntario. En una distribución hay todo el software necesario para instalar en un ordenador personal; servidor, correo, ofimática, fax, navegación de red, seguridad, etc.

Gonzalo Julián Santander Palacios

Introducción a LINUX

4 Linux frente a los otros sistemas operativos Linux es una muy buena alternativa frente a los demás sistemas operativos. Más allá de las ventajas evidentes de costo, ofrece algunas características muy notables. En comparación con las otras versiones de Unix para PC, la velocidad y confiabilidad de Linux son muy superiores. También está en ventaja sobre la disponibilidad de aplicaciones, ya que no hay mucha difusión de estos otros Unixes (como Solaris, XENIX o SCO) entre los usuarios de PC por sus altos costos. Comparado con sistemas operativos como los diferentes Microsoft Windows, Linux también sale ganando. Los bajos requisitos de hardware permiten hacer un sistema potente y útil de aquel 486 que algunos guardan en un armario. Esta misma característica permite aprovechar al máximo las capacidades de las computadoras más modernas. Es poco práctico tener una PC con 16 Mb de RAM y ponerle un sistema operativo que ocupa 13 (que es lo que reporta sobre Windows 95 el System Information de Symantec). No solo es superior respecto a el sistema de multitarea y de administración de memoria, sino también en la capacidades de networking (conectividad a redes) y de multiusuario (aún comparando con sistemas multiusuario como NT). La única desventaja de Linux frente a estos sistemas, es la menor disponibilidad de software, pero este problema disminuye con cada nuevo programa que se escribe para el proyecto GNU, y con algunas empresas que están desarrollando software comercial para Linux (por ejemplo Corel).

Gonzalo Julián Santander Palacios

18

Introducción al PLC

Gonzalo Julián Santander Palacios

19

Introducción al PLC

20

Capítulo 3 INTRODUCCIÓN AL PLC

1

Controladores Lógico Programbles (PLC´S )

Las empresas de hoy, que piensan en el futuro, se encuentran provistas de modernos dispositivos electrónicos en sus maquinas y procesos de control. Hoy las fábricas automatizadas deben proporcionar en sus sistemas, alta confiabilidad, gran eficiencia y flexibilidad. Una de las bases principales de tales fábricas es un dispositivo electrónico llamado Controlador Lógico Programable. Este dispositivo fue inicialmente introducido en 1970 y se ha sido refinando con nuevos componentes electrónicos, tales como Microprocesadores de alta velocidad, agregándole funciones especiales para el control de proceso más complejos. Hoy los Controladores Programables son diseñados usando lo ultimo en diseño de Micro-procesadores y circuiteria electrónica lo cual proporciona una mayor confiabilidad en su operación en aplicaciones industriales donde existen peligro debido al medio ambiente, alta repetibilidad, altas temperaturas, ruido ambiente o eléctrico, suministro de potencia eléctrica no confiable, vibraciones mecánicas etc. Este medio ambiente es el que el Control Lógico Programable se encuentra en su elemento, ya que fue diseñado y concebido para su uso en el medio ambiente industrial. Los

Controladores

Lógicos

Programables,

PLC

como

ellos

son

comúnmente llamados, ofrecen muchas ventajas sobre otros dispositivos de

control

tales

como

relevadores,

temporizadores

electrónicos,

contadores y controles mecánicos como del tipo tambor. El objetivo de esta introducción es mostrar el funcionamiento interno y de programación de

Gonzalo Julián Santander Palacios

Introducción al PLC

21

este tipo de controladores, además de mostrar algunas de sus aplicaciones en la industria.

Figura 3-1. Ejemplo de PLC´s

Gonzalo Julián Santander Palacios

Introducción al PLC

2 Descripción y Funcionamiento de un PLC Los Controladores Lógicos Programables, (PLC s, Programable Logic Controller), nacieron esencialmente como tales, a finales de la década de los 60s y principios de los 70s. Las industrias que propiciaron este desarrollo fueron las automotrices. Ellas usaban sistemas industriales basadas en reveladores, en sus sistemas de manufactura. Buscando reducir los costos de los sistemas de control por relevadores, la General Motor preparo en 1968 ciertas especificaciones detallando un "Controlador Lógico Programable", Estas especificaciones definían un sistema de control por relevadores que podían ser asociado no solamente a la industria automotriz, si no prácticamente a cualquier industria de manufactura. Estas especificaciones interesaron a ciertas compañías tales como GEFanuc, reliance Electric, MODICON, Digital Equipment Co., De tal forma que el resultado de su trabajo se convirtió en lo que hoy se conoce como Controlador Lógico Programable. Los PLCs surgen como equipos electrónicos sustitutos de los sistemas de control basados en relevadores, que se hacían más complejos y esto arrojaba ciertas dificultades en cuanto a la instalación de los mismos, los altos costos de los equipos. Losa altos costos de operación y mantenimiento y la foca Flexibilidad y confiabilidad de los equipos. Los primeros PLCs se usaron solamente como reemplazo de relevadores, es decir, su capacidad se reducía exclusivamente al control On -Off (de dos posiciones) en maquinas y procesos industriales. De echo todavía se siguen usando en muchos casos como tales. La gran diferencia con los controles por relevador fue su facilidad de instalación, ocupan menor espacio, costo reducido, y proporcionan autodiagnósticos sencillos. En la década de los 70s con el avance de la electrónica, la tecnología de los microprocesadores agrego facilidad e inteligencia adicional a los PLCs generando un gran avance y permitiendo un notorio incremento en la

Gonzalo Julián Santander Palacios

22

Introducción al PLC capacidad de interfase con el operador, se fue poco a poco mejorando la idea inicial de los PLCs convirtiéndose en lo que ahora son, Sistemas Electrónicos Versátiles y Flexibles. En su creación, los requerimiento sobre los cuales se han desarrollado los PLC s, los enumero la General Motors de la manera siguiente : 1. El dispositivo de control deberá ser fácil y rápidamente programable por el usuario con un mínimo de interrupción. 2. Todos los componentes del sistema deben ser capaces de operar en plantas industriales sin un especial equipo de soporte, de hardware o de ambiente. 3. El sistema debe ser de fácil mantenimiento y reparación. Deberá diseñarse con indicadores de status y modularidad para facilitar las reparaciones y la búsqueda de errores. 4. El sistema deberá ocupar menor espacio que los sistemas de relevador y deberá consumir menor potencia que los sistemas de control por relevadores. 5. El PLC deberá ser capaz de comunicarse con un sistemas central de datos para propósitos de monitoreo. 6. Deberá ser capaz de trabajar con 120 volts de corriente alterna y con elementos estándar de control, con interruptores de presión interruptores de limite, etc. 7. Las señales de salida deberán ser capaces de manejar arranques de motores y válvulas solenoides que operan a 120 volts de C.A. 8. Deberá ser expandible desde su mínima configuración hasta su máxima, con una mínima de alteración y de tiempo perdido. 9. Deberá ser competitivo en costo de venta e instalación, respecto de los sistemas en base a relevadores.

Gonzalo Julián Santander Palacios

23

Introducción al PLC 10. La estructura de memoria empleada deberá ser expandible a un mínimo de 4000 palabras o elementos de memoria. Los PLC actuales no solamente cumplen estos requisitos si no que lo superan. El PLC actual es una computadora de propósito especifico que proporciona una alternativa más flexible y funcional para los sistemas de control industriales. La figura 1 muestra en general las funciones básicas de un PLC.

Debido a la gran aceptación que ha tenido el PLC, se ha dado una definición formal por la NEMA (Nacional electrical Manufacturers Association), descrita como sigue: EL PLC es un aparato electrónico operado digitalmente que usa una memoria programable para el almacenamiento interno de instrucciones las cuales implementan funciones especificas tales como lógicas, secuénciales, temporización, conteo y aritméticas, para controlar a través de módulos de entrada /salida digitales y analógicas, varios tipos de maquinas o procesos. Una computadora digital que es usada para ejecutar las funciones de un controlador programable, se puede considerar bajo este rubro. Se excluyen los controles secuenciales mecánicos. De una manera general podemos definir al controlador lógico programable a toda maquina electrónica, diseñada para controlar en tiempo real y en medio industrial procesos secuenciales de control. Su programación y manejo puede ser realizado por personal con conocimientos electrónicos sin previos conocimientos sobre informática. También se le puede definir como una "caja negra" en la que existen unas terminales de entrada a los que se conectaran pulsadores, finales de carrera, foto celdas, detectores, etc... unos terminales de salida a los que se le conectaran bobinas de contactores, electro válvulas, lámparas., De tal forma que la actuación de estos ultimo están en función de las señales de

Gonzalo Julián Santander Palacios

24

Introducción al PLC entrada que estén activadas en cada momento, según el programa almacenado. Esto quiere decir auxiliares, relees de encallamiento, temporizadores, contadores… Son internos. La tarea del usuario se reduce a realizar el "programa que no es más que la relación entre las señales de entrada que se tienen cumplir para activar cada salida”.

Gonzalo Julián Santander Palacios

25

Introducción al PLC

26

3 Campos de aplicación de un PLC EL PLC por sus especiales características de diseño tiene un campo de aplicación muy extenso. La constante evolución del Hardware y Software amplia continuamente este campo para poder satisfacer las necesidades que se detectan en el aspecto de sus posibilidades reales. Su utilización se da fundamentalmente en aquellas instalaciones en donde es necesario realizar procesos de maniobra, control, señalización, etc., por tanto, su aplicación abarca desde procesos de fabricación industrial de cualquier

tipo

al

de

transformaciones

industriales,

control

de

instalaciones, etc. Sus reducidas dimensiones, las extremas facilidades de u montaje, la posibilidad de almacenar los programas para su posterior y rápida utilización, la modificación o alteración de los mismos, etc., hace que su eficiencia se aprecie fundamentalmente en procesos en que se reduce necesidades tales como: Espacio reducido. Procesos de producción periódicamente cambiantes Maquinaria de procesos variables. Instalación de procesos complejos y amplios. Chequeo de programación centralizada de las partes del proceso

EJEMPLOS DE APLICACIONES DE UN PLC A).-MANIOBRAS DE MAQUINAS. Maquinaria industrial del mueble y la madera. Maquinaria en proceso de grava, arena y cemento. Maquinaria en la industria del plástico. Maquinas-herramientas complejas. Maquinaria de ensamblaje. Maquinas de transferencia. Gonzalo Julián Santander Palacios

Introducción al PLC B).-MANIOBRA DE INSTALACIONES. Instalaciones de aire acondicionado y calefacción. Instalaciones de seguridad. Instalaciones de almacenamiento y transporte. Instalaciones de plantas embotelladoras. Instalaciones en la industria automotriz Instalación de tratamientos térmicos. Instalaciones de la industria azucarera.

Es interesante hacer notar que aunque el PLC fue originalmente diseñado como un dispositivo de reemplazo de control industrial que cumple las necesidades de los usuarios. Las necesidades de la aplicación pueden ser definidas solamente por un análisis detallado del sistema completo. Esto significa que los exámenes detallados deben ser ejecutados en todas las facetas de la maquina u operación del proceso. De nuevo, como nada aplicación es diferente, no hay una rutina clara y concisa que evalué las necesidades que todas las aplicaciones. Una ultima consideración importante en la aplicación de un PLC es el futuro crecimiento del sistema. Los PLC están diseñados modularmente y por lo tanto con posibilidades de poder expandirse para satisfacer las necesidades de la industria. Es importante que a la aplicación de un PLC se pueda considerar los beneficios de las Futuras expansiones.

Gonzalo Julián Santander Palacios

27

Introducción al PLC

28

4 Lenguajes de Programación Cuando surgieron los autómatas programables, lo hicieron con la necesidad de sustituir a los enormes cuadros de maniobra construidos con contactores y relees.

Por lo tanto, la comunicación hombre-maquina

debería ser similar a la utilizada hasta ese momento. El lenguaje usado, debería ser interpretado, con facilidad, por los mismos técnicos electricistas que anteriormente estaban en contacto con la instalación. Estos lenguajes han evolucionado en los últimos tiempos, de tal forma que algunos de ellos ya no tienen nada que ver con el típico plano eléctrico a relees. Los lenguajes más significativos son: 1. Lenguaje a contactos. (LD) Es el que más similitudes tiene con el utilizado por un electricista al elaborar cuadros de automatismos. Muchos autómatas incluyen módulos especiales de software para poder programar gráficamente de esta forma.

Figura 3-2. Lenguaje a contactos

Gonzalo Julián Santander Palacios

Introducción al PLC

29

2. Lenguaje por Lista de Instrucciones. (IL) En los autómatas de gama baja, es el único modo de programación. Consiste en elaborar una lista de instrucciones o nemónicos que se asocian a los símbolos y su combinación en un circuito eléctrico a contactos. También decir, que este tipo de lenguaje es, en algunos casos, la forma más rápida de programación e incluso la más potente.

Figura 3-3. Ejemplo de Lista de Instrucciones

3.

GRAFCET. (SFC)

Es el llamado Gráfico de Orden Etapa Transición. Ha sido especialmente diseñado para resolver problemas de automatismos secuenciales. Las acciones son asociadas a las etapas y las condiciones a cumplir a las transiciones. Este lenguaje resulta enormemente sencillo de interpretar por operarios

sin

conocimientos

de

automatismos

eléctricos.

Muchos de los autómatas que existen en el mercado permiten la programación en GRAFCET, tanto en modo gráfico o como por lista de instrucciones.

Gonzalo Julián Santander Palacios

Introducción al PLC

30

También podemos utilizarlo para resolver problemas de automatización de forma teórica y posteriormente convertirlo a plano de contactos.

Figura 3-4. GRAFCET

4.

Plano de funciones. (FBD)

El plano de funciones lógicas, resulta especialmente cómodo de utilizar, a técnicos habituados a trabajar con circuitos de puertas lógicas, ya que la simbología usada en ambos es equivalente.

Figura 3-5. Plano de Funciones

Gonzalo Julián Santander Palacios

Introducción al PLC 5.

Texto Estructurado

Es un lenguaje del tipo booleano de alto nivel y estructurado, incluye las típicas sentencias de selección (IF-THEN-ELSE) y de interacción (FOR, WHILE Y REPEAT), además de otras funciones específicas para aplicaciones de control. Su uso es ideal para aplicaciones en las que se requiere realizar cálculos matemáticos, comparaciones, emular protocolos, etc.

Figura 3-6 Ejemplo Texto Estructurado

Gonzalo Julián Santander Palacios

31

Introducción al PLC

Denominación de los lenguajes de programación de diferentes

6. PLC´s

Cada fabricante ha nombrado mediante siglas o palabras compuestas a su lenguaje de programación o software de programación que lo identifica del resto de PLCs. A continuación se presenta una Figura 3-6 donde se indican estos nombres.

Figura 3-6 Tabla que relacciona los fabricantes de PLC´s y su software para los diferentes lenguajes de programación

Gonzalo Julián Santander Palacios

32

Mat-PLC

33

Capítulo 4 MAT-PLC

1 ¿ Qué es Mat-PLC ? MatPLC (Machine automation tolls – Programmable Logic Controller) no es más que un programa de simulación de

Plc´s, con la clara

particularidad de que es abierto, extensible y manipulable por el usuario. En la Figura 4-1 se puede ver la estructura general de MatPLC.

Figura 4-1 Estructura básica de MatPLC

Gonzalo Julián Santander Palacios

Mat-PLC

34

2 Arquitectura de MatPLC La arquitectura de MatPLC se basa en los siguientes puntos: •

Es un sistema modular, esto quiere decir que una aplicación se divide en diferentes secciones encargadas de un tarea particular, con la peculiaridad de que cada una de las secciones puede ser depurada

por separado.

La base de la modularidad es

asegurarse de que cada sección realiza únicamente un trabajo y lo hace bien.

Figura 4-2. Modulos en MatPLC

•

Todos los módulos están gobernados por un módulo o Estado Global que se encarga de actualizar todas las entradas y salidas (“I/O points”) que forman el programa, todos los “I/O points” son almacenados en un espacio de memoria denominado “Global Memory Map”, esto quiere decir que cada uno de los módulos puede usar todas las I/O (points) pero solo uno de ellos esta autorizado para cambiarlo, de tal manera que si un módulo cambiará un “I/O point” el estado global la actualiza y a su vez otro módulo se puede ver afectado por dicho cambio.

Gonzalo Julián Santander Palacios

Mat-PLC

35

Figura 4-3. Estructura modular de MatPLC •

Los módulos pueden ser organizados en diferentes grupos dependiendo de la función que desempeñen, por ejemplo se podrían organizar los grupos como : o Logic Engines : son los encargados de realizar todas las operaciones lógicas de MatPLC. o I/O : módulos encargados de conectarse con el mundo real (ej: puerto paralelo, otro PC) . o HMI(Human Machine Interface): módulos encargados de interactuar con el usuario.

•

Además

se

puede

realizar

otra

pequeña

clasificación

dependiendo de los tipos: o Genéricos : módulos propios de MatPLC que no pueden ser modificados. o Específicos : módulos creados por otras personas. o Propios : los módulos que uno crea.

Gonzalo Julián Santander Palacios

Mat-PLC •

36 Archivo de Configuración

”matplc.conf”,

en este archivo se

define cuantos y que módulos están funcionando, además de las configuraciones generales y básicas que requiere cada uno de los módulos. Dentro de las configuraciones hay que destacar: o Los “I/O points” son las entradas, salidas o registros de MatPLC, cada uno de los “I/O points” tiene un nombre concreto y un tamaño que esta entre 1 y 32 bits; cada uno de los “I/O points” es modificado por un solo módulo pero puede ser leído por el resto de módulos. En la Figura 4-4 se puede ver como el

“I/O point” es

modificado en el modulo 1 y pasa a la memoria global con el fin de que los módulos 2 y 3 puedan leer y a posteriori utilizar el valor del “I/O point”.

Figura 4-4. Esquema del movimientos de los “points” o La sincronización, por defecto todos los módulos son definidos asíncronos, pero diferentes módulos se pueden sincronizar con el fin de que se siga un ciclo a la hora de actualizar los diferentes “I/O points”. o El periodo de escaneo, define que tiempo se dedicará en el escaneo de cada uno de los módulos, este proceso va regido por una serie de semáforos en los cuales no se ha profundizado. Gonzalo Julián Santander Palacios

Mat-PLC

37 o En el “Aplicación ascensor” se de la página 63 puede ver un ejemplo del archivo ”matplc.conf”.

Todos los módulos son cíclicos, esto significa que se están repitiendo constantemente hasta que el usuario termine la aplicación, esta estructura es igual que la de cualquier PLC; con esto se consigue que las salidas y entradas que afectan a cada uno de los módulos puedan ser actualizadas constantemente ante los cambios, en cualquiera de los módulos que contienen MatPLC se puede ver su estructura. En la Figura 4-5 se muestra el diagrama de flujo de cualquier módulo creado en MatPLC.

IN IC IO

IN IC IA L IZ A C IÓ N

I n ic ia liz a c ió n escaneo

A c tu a liz a c ió n d e la s I/O

P ro g ra m a p r in c ip a l

A c tu a liz a c ió n d e la s I/O

F in a liz a c ió n d e l escaneo

Figura 4-5 Diagrama de flujo de un módulo de MatPLC

Gonzalo Julián Santander Palacios

Mat-PLC

38

Lo primero que hace es realizar las inicializaciones oportunas de cada uno de los módulos, seguidamente se comienza con un escaneo general, y una actualización de las entradas y salidas, a continuación se crea el código propio de cada módulo donde se cambiaran las salidas dependiendo de las entradas, seguidamente se actualizan de nuevo las entradas y salidas con el fin de ratificar los cambios producidos en el módulo, la última acción es el escaneo y reiniciar el bucle.

Figura 4-6 Estrucurta de un módulo en C En la Figura 4-6 se puede ver

la estructura general de un módulo

cualquiera en C, osease tal y como sería en realidad, en el Capítulo 6 se describen una serie de aplicaciones desarrollados donde se puede ver claramente dicha estructura con todo detalle.

Gonzalo Julián Santander Palacios

Mat-PLC

3 Modulo IL (Instruction List) La mayor parte del proyecto se ha basado en el estudio de este modulo, en un principio la finalidad del proyecto era realizar este módulo con el fin de que la empresa (S.A.C.) para la cual se ha desarrollado el proyecto pudiera utilizarlo sin ningún tipo de coste, ya que los programas de simulación de PLC´s actuales son costos. Una vez se empezó con el estudio de MatPLC se descubrió que dicho programa ya contaba con un módulo capaz de simular un programa escrito en el lenguaje de Lista de Instrucciones por lo tanto se paso a su estudio y verificación. Hay que destacar que el lenguaje que implementa MatPLC como Lista de Instrucciones cumple con la norma IEC –61131, esta norma es el primer paso en la estandarización de los autómatas programables y sus periféricos, incluyendo los lenguajes de programación que se deben utilizar. En el ANEXO IEC 61131-3 de la página 136 se puede ver un documento más detallado que expone la norma IEC-61131. 3.1 Lista de Instrucciones Son instrucciones del tipo Booleanas, utilizando para su representación letras y números. Dado que se usan abreviaturas nemotécnicas, no se requiere gran memoria para tareas de automatización. La desventaja radica en la magnitud del trabajo que es necesario para su programación, especialmente si el programa consta de unos cientos de instrucciones. Representación de un programa en lista de instrucciones para diferentes marcas de PLCs.

Gonzalo Julián Santander Palacios

39

Mat-PLC

40

Siemens (Simatic) Telemecanique General Electric U E0.1

L I0.01

LD

%I0001

U E0.2

A I0.02

AND %I0002

O E0.3

O I0.03

OR

= A3.1

= O3.01

OUT %Q0031

%I0003

Figura 4-7 Ejemplos de Listas de Instrucciones En el caso de MatPLC se puede decir que la marca de PLC que más se aproxima es General Electric. En la Figura 4-8 se puede ver el parecido.

Figura 4-8. Ejemplo Lista de Instrucciones MatPLC

Gonzalo Julián Santander Palacios

Mat-PLC Instrucciones propias del lenguaje IL de MatPLC: •

LD contacto/registro => Comienza el acumulador con el valor del contacto o el registro.

•

LDI contacto/registro => Comienza el acumulador con el valor inverso del contacto o el registro.

•

K valor => Comienza el acumulador con el valor dado, ya puede ser on/off o un número.

•

AND contacto => Realiza la operación lógica de AND entre el acumulador y el contacto.

•

ANDI contacto => Realiza la operación lógica inversa de AND entre el acumulador y el contacto.

•

OR contacto => Realiza la operación lógica de OR entre el acumulador y el contacto.

•

ORI contacto => Realiza la operación lógica inversa de OR entre el acumulador y el contacto.

•

OUT bobina/registro => Pasa el valor del acumulador a u rele. Si la acumulador esta en on, el rele se pone en on , pero si el acumulador esta en off el rele se pone en off. Para valores numéricos, el valor es escrito en un registro.

•

OUTI bobina => Pasa el valor del acumulador a un rele. Si la acumulador esta en on, el rele se pone en off , pero si el acumulador esta en off el rele se pone en on. Para valores numéricos, el valor es escrito en un registro.

•

SET bobina => Conecta el valor del acumulador a la bobina de un rele. Si el acumulador esta en on el rele se pone en on.

•

RST bobina => Conecta el valor del acumulador a la bobina de un rele. Si el acumulador esta en on el rele se pone en off.

Gonzalo Julián Santander Palacios

41

Mat-PLC •

LT registro => Compara el valor del acumulador con el registro y si es menor, el acumulador se pone en on.

•

LE registro => Compara el valor del acumulador con el registro y si es menor o igual, el acumulador se pone en on.

•

GT registro => Compara el valor del acumulador con el registro y si es mayor, el acumulador se pone en on.

•

GE registro => Compara el valor del acumulador con el registro y si es mayor o igual, el acumulador se pone en on.

•

MCS => Master Control Start, a partir de esta instrucción y hasta que encuentre la instrucción MCE, se genera un nuevo acumulador que solo tendrá validez dentro de estas instrucciones.

•

MCE => final de el MCS (Master Control Start).

•

JMP label => si el acumulador esta en on, se transfiere la continuación del programa a la posición donde se encuentre el label; el salto se dará dentro de un mismo programa, y no podrá ser de programa a subrutinas. Si el acumulador esta en off esta instrucción no tiene efecto.

•

LBL label => es el label para la instrucción JMP, el programa se transferira hasta donde se encuentre esta instrucción.

•

JSR subnombre => Si el acumulador esta en on el programa salta a una subrutina, cuando la subrutina termina el programa salta hasta la siguiente instrucción después de JSR. Si el acumulador esta en off esta instrucción no tiene efecto.

•

SUB subnombre => Marca el comienzo de la subrutina, su final viene marcado por la instrucción END.

•

END => en el programa principal esta instrucción marca el final del escaneo y en una subrutina su final.

Gonzalo Julián Santander Palacios

42

Mat-PLC •

RET => si el acumulador esta en on se el programa salta al final del escaneo o si estuviera dentro de una subrutina salta al final de la subrutina. Si el acumulador esta en off esta instrucción no tiene efecto.

Las instrucciones pueden ser escritas tanto en mayúsculas como en minúsculas ya que tendrán el mismo significados, esto no ocurre con los nombres de las subrutinas o con los labels, para que el programa funciones correctamente tienen que tener exactamente el mismo nombre.

Gonzalo Julián Santander Palacios

43

Mat-PLC

44

3.2 Transformación a un archivo en C La lista de instrucciones ha de ser guardada en un archivo con el formato *.il

con el fin de que el modulo IL lo reconozca y lo transforme a un

archivo en C de tal manera que MatPLC pueda trabaja con él. Hay que recordar que MatPLC solo trabaja en el lenguaje C y por lo tanto si no existiera dicho modulo habría que crear el mismo programa escrito en vez de en Lista de instrucciones en lenguaje C. A continuación se puede ver un ejemplo de como el propio modulo realiza la transformación, no se

entró

en detalle de cómo internamente el

módulo ejecuta dicha transformación ya que se vio que resultaba demasiado complicado porque se usaba un lenguaje desconocido para el proyectista (PERL) y por lo tanto solo se centro en la transformación.

Gonzalo Julián Santander Palacios

Mat-PLC

Modulo en Lista de instrucciones (“ascensor.il”) LD Bot1 SET scroll_dir LD Bot2 RST scroll_dir # Now we do the scrolling LD scroll_dir JSR sube LDI scroll_dir JSR baja # Here are the subroutines SUB sube OUTI B1 OUTI P1 OUT B2 OUT P2 END

SUB baja OUTI B2 OUTI P2 OUT B1 OUT P1 END ###

Gonzalo Julián Santander Palacios

45

Mat-PLC

46

Módulo Transformado a lenguaje C (“ascensor.c”) #define stk_depth 8 /* stack depth - eight is normal */

/* a couple of shortcuts */ #define acc stack[top] /* accumulator == top of stack */ #define next stack[(top + 1) % stk_depth] /* one beyond top of stack */ #define push top = (top + 1) % stk_depth #define pop top = (top + stk_depth - 1) % stk_depth

static unsigned char top=0; /* top of stack (ie, stack “I/O points”er) */ static u32 stack[stk_depth]; static u32 master=1; /* for the MCS instruction */

static void IL_main(void) { master=1; /* reset MCS */

/************************************** chaser_il.il */ # 1 "chaser_il.il" # 35 "chaser_il.il" push; acc = master ? plc_get(Bot1) : 0;/* LD Bot1 */ # 36 "chaser_il.il" if (acc) plc_set(scroll_dir,1);

/* SET scroll_dir */

# 38 "chaser_il.il" push; acc = master ? plc_get(Bot2) : 0;/* LD Bot2 */ # 39 "chaser_il.il" if (acc) plc_set(scroll_dir,0);

/* RST scroll_dir */ /* Now we do the scrolling */

# 43 "chaser_il.il" push; acc = master ? plc_get(scroll_dir) : 0;/* LD scroll_dir */ # 44 "chaser_il.il" if (acc) {pop; IL_sub_sube();}

Gonzalo Julián Santander Palacios

/* JSR sube */

Mat-PLC

47

# 45 "chaser_il.il" push; acc = master ? !plc_get(scroll_dir) : 0;/* LDI scroll_dir */ # 46 "chaser_il.il" if (acc) {pop; IL_sub_baja();}

/* JSR baja */ /* Here are the subroutines */

# 50 "chaser_il.il" }

static void IL_sub_sube(void) {

/* SUB sube */

# 51 "chaser_il.il" plc_set(B1,!acc);

/* OUTI B1 */

# 52 "chaser_il.il" plc_set(P1,!acc);

/* OUTI P1 */

# 53 "chaser_il.il" plc_set(B2,acc);

/* OUT B2 */

# 54 "chaser_il.il" plc_set(P2,acc);

/* OUT P2 */

# 55 "chaser_il.il" return;

/* END */

# 57 "chaser_il.il" }

static void IL_sub_baja(void) {

/* SUB baja */

# 59 "chaser_il.il" plc_set(B2,!acc);

/* OUTI B2 */

# 60 "chaser_il.il" plc_set(P2,!acc);

/* OUTI P2 */

# 61 "chaser_il.il" plc_set(B1,acc);

/* OUT B1 */

# 62 "chaser_il.il" plc_set(P1,acc); # 63 "chaser_il.il"

Gonzalo Julián Santander Palacios

/* OUT P1 */

Mat-PLC

48

return;

/* END */ /* ### */

/************************************** [end] */ # 1 "../../logic/il/il2c:template3" }

La aplicación desarrollado no es más que un ascensor de dos plantas con una botonera que corresponde a cada una de las dos plantas y dos señalizadores de cada una de las plantas. Como se puede ver en el archivo

ascensor.c

se realizá una trasformación

completa del código en lista de instrucciones a lenguaje C , a su vez durante la transformación MatPLC crea las variables internas que tiene que usar el programa para que funcione correctamente:

#define acc stack[top]

La variable

acc

es el acumulador propio de un PLC, esté tiene la

particularidad de que durante un mismo programa se pueden utilizar 8 acumuladores diferentes, estos son acumulados en un vector (stack[

])

tal y como se puede ver en su definición.

#define push top = (top + 1) % stk_depth

La variable

push

realiza la operación

top = (top + 1) % stk_depth

que se

encarga de aumentar la posición del vector de acumuladores siempre que haga falta, en la aplicación del ascensor sólo se uso un acumulador con lo cual el valor de top es siempre de 0.

Gonzalo Julián Santander Palacios

Mat-PLC

49

#define pop top = (top + stk_depth - 1) % stk_depth

La variable stk_depth

pop

realiza la operación

top

=

(top

+

stk_depth

-

1)

%

que se encarga de disminuir la posición del vector de

acumuladores siempre que haga falta, en la aplicación del ascensor sólo se uso un acumulador con lo cual el valor de top es simpre de 0. Una vez definidas las variables, MatPLC se transforma cada una de las líneas de código bajo Lista de Instrucciones a C; en el archivo ascensor.c se ve como cada línea de código en C tiene un comentario que corresponde a su símil en Lista de Instrucciones, por ejemplo:

push; acc = master ? plc_get(Bot1) : 0;

/* LD Bot1 */

En esta línea de código lo que se esta haciendo es una lectura de la variable de

Bot1,

que no es más que el botón del ascensor de la primera

planta. En el caso de que este pulsado el valor del acumulador será de 1 y en caso contrario el valor será de 0, en Lista de Instrucciones la línea de código que tiene el mismo significado es

LD Bot1,

si se mira el apartado

Lista de Instrucciones en este mismo capítulo se verá un amplio desarrollo de cada una de las instrucciones.

if (acc) {pop; IL_sub_baja();}

/* JSR baja */

En este otro ejemplo se puede ver como se realizara la instrucción

pop

y

además se llamará a la función IL_sub_baja() la cual se encarga de bajar el ascensor a la planta inferior si el valor del acumulador es ON. En lista de instrucciones esto se ejecuta mediante la instrucción que un salto hasta la etiqueta baja.

Gonzalo Julián Santander Palacios

JSR

que no es mas

Mat-PLC

50

4 Modulo HMI GTK ( GLADE )

4.1 Introducción Todos los sistemas de control incluso los más simples están previstos de algún tipo de HMI (Human Machina Interface), se podría decir que el ejemplo más básico es conectar LEDs al puerto paralelo como salidas, actualmente y gracias a los ordenadores los HMI son muy sofisticados y en muchos casos son la parte mas importante de los proyectos ya que es la única parte del proyecto que es visible por el usuario. Un buen HMI debe proporcionar al operario toda la información necesaria para el control de las operaciones por esto ha de ser: •

Fácil de entender.

•

Debe contribuir a la seguridad y la eficiencia del sistema.

•

Debe proporcionar ayuda.

•

Propondrá soluciones ante los diferentes problemas que surjan.

Gonzalo Julián Santander Palacios

Mat-PLC

51

4.2 Descripción módulo HMI (GLADE) El propósito de este módulo es la creación de un interfaz gráfico que sea de fácil manejo para un usuario y a su vez que sea manejado por MatPLC, más concretamente por sus “I/O points” (entradas y salidas). Para ello utiliza un programa denominado GALDE con el cual se crean todos los visores gráficos que usará el operario, este programa se podría comparar con “Visual Basic” desarrollado para Windows. Sin entrar mucho en detalle Glade genera un archivo

*.glade,

este archivo

es leído e interpretado por el modulo HMI_GTK de tal manera que es capaz de conectar las entradas y salidas que corresponden del programa principal a el interfaz gráfico desarrollado en GLADE.

Figura 4-9 Ejemplo de HMI de un ascensor de dos plantas

Gonzalo Julián Santander Palacios

Mat-PLC

52

4.3 Definición de entradas y salidas Las entradas y salidas que son conectadas con las diferentes partes de inteface (widgets “ botones, selectores, etc.”) son definidas de una forma especial con la función de que MatPLC reciba la información necesaria para poderlos unir al programa principal. Las entradas y salidas son definidas de la siguiente forma: _pointname[.number[.type][.parameter1[.parameter2]]]

Todas las I/O que corresponden a HMI GTK en GLADE han de llevar delante un guión bajo “_” de esta manera MatPLC sabrá que este Widget va ha ser manejado por él. Todo widget el cual no empiece por “_” no será usado por MatPLC. point

El “I/O points” de MatPLC que será conectado con su widget.

widget

Normalmente es 0, pero si desea que un mismo “I/O points”

number

sea controlado por diferentes widgets, solo hay que poner un número el cual corresponda a la cantidad de widget que utilizarán ese “I/O points”

type

El tipo de “I/O points” al que será conectado, por ejemplo boleano, entero, char, etc.. Si no introduce este parámetro se supondrá que es de tipo boleano bool, i32, i16, i8, u32, u16, u8 ó f32

parameter 1

El significado de este parámetro depende del tipo definido, por ejemplo si es boleano este podrá se usado para definir una Imagen o texto cuando su valor este en ON.

parameter 2

El significado de este parámetro depende del tipo definido, por ejemplo si es boleano este podrá se usado para definir una Imagen o texto cuando su valor este en OFF.

Gonzalo Julián Santander Palacios

Mat-PLC

53

Un buen ejemplo de cómo saber nombrar los diferentes widget para que MatPLC sepa usarlo es el siguiente:

Con

GnomePixmap-widget se puede mostrar diferentes imágenes

dependiendo del estado de la entrada, el formato de la imagen ha de ser .xpm.

Ejemplo => _abcd.0.bool.on.off plc-point = abcd tipo= boleana El resultado de la operación es: PLC-Point(s) valor Imagen Pixmap abcd

== 0 off.xpm

abcd

>0

on.xpm

Tabla 4-1 GnomePixmap En la siguiente figura se muestra como se define realmente un widget en GLADE.

Gonzalo Julián Santander Palacios

Mat-PLC

Figura 4-10 Ejemplo de definición de un widget como entrada

Figura 4-11 Ejemplo de definición de un widget como salida

Gonzalo Julián Santander Palacios

54

Mat-PLC

4.4 Tipos de widgets MatPLC únicamente soporta los siguientes widgets, cada uno de los siguientes cumple una función diferente: GtkLabel (Salida) Soportado por todas las variables param1 = mensaje de texto cuando este en on. param2 = mensaje de texto cuando este en off. GtkProgressBar (Salida) Soportado por variable de tipo float. Rango limitado por usuario. GnomePixmap (Salida) Soportado por todas las variables. param1 = pone la imagen cuando este en on ( la imagen ha de tener la extensión .xpm) param2 = pone la imagen cuando este en off ( la imagen ha de tener la extensión .xpm) GtkPlotCanvas (Salida) Soportado por todas las variables. GtkToggleButton (Entrada) Soportado por todas las variables. Señal: toggled, Manejador: update_value GtkRadioButton (Entrada) Soportado por todas las variables. Señal: toggled, Manejador: update_value GtkCheckButton (Entrada) Soportado por variables de tipo boleano. Señal: toggled, Manejador: update_value Gonzalo Julián Santander Palacios

55

Mat-PLC GtkButton (Entrada) Soportado por variables de tipo boleano. Señal: pressed, Manejador: update_value Señal: released, Manejador: reset_value GtkEntry (Entrada) Supports all types. Señal: activate or changed, Manejador: update_value GtkHScale and GtkVScale (Entrada) Soportado por variables de tipo f32, u32, u16, u8, i32, i16 and i8. Señal: button-release-event, Manejador: update_value GtkSpinButton (Entrada) Soportado por variables de tipo f32, u32, u16, u8, i32, i16 and i8. Señal: changed, Manejador: update_value

Gonzalo Julián Santander Palacios

56

Mat-PLC

4.4 Definición de proyecto en GLADE Hay que destacar que el archivo que guarda el proyecto ha de ser el mismo para todas las aplicaciones que quieran funcionar dentro de MatPLC, dicho archivo es “hmi_gtk2” de esta manera MatPLC reconocerá que el proyecto creado en GLADE esta dirigido a él, véase la Figura 4-12.

Figura 4-12 Nombre del archivo de un proyecto en GLADE

Gonzalo Julián Santander Palacios

57

Mat-PLC

58

5 Modulo Puerto Paralelo El uso de este módulo no ha sido otro que la comprobación visual de los diferentes módulos creados para justificar que MatPLc era viable. Al principio todos las pruebas se realizaron con un Hardware (vease capitulo 5) que hacia las funciones de HMI (Human Machine Interface) el cual se conectaba al puerto paralelo y el cual constaba de 8 diodos leds que hacían de entradas. El puerto paralelo consta de 17 bit utilizables como I/O, algunos de ellos pueden ser configurados como entradas o salidas. Para tener acceso al puerto paralelo hay que especificar su dirección de memoria pertinente. Los bits son definidos en tres tipos diferentes, D, S y C. Los de tipo D pueden ser usados como entradas y salidas, S siempre son salidas y lo de tipo C suelen usarse como salidas pero se da opción de poder usarse como entradas siempre y cuando se conozcan directamente la dirección de memoria y el hardware que se va ha utilizar lo permita. El formato de cada una de los direcciones que se encuentran definidas en MatPLC es el “R.x” donde “R” son los tipos y “x” es el numero de bit.

Tipo

Rango

Numero

Estado

Pins

D

D.0 – D.7

8

I/O

2-9

S

S.3 – S.7

5

I

10/11/12/13/15

C

C.0 – C.3

4

Normalmente O 1/14/16/17

Tabla 4-2Rango de direcciones aceptadas por el puerto paralelo

Gonzalo Julián Santander Palacios

Mat-PLC

5.1 CONFIGURACIÓN Los siguientes parámetros que se han desarrollado han de ser configurados en el programa principal y más concretamente en el archivo de configuración conocido como matplc.conf. io_addr Se define la dirección base del puerto paralelo. Por defecto se usa la 0x378 pero también se puede usar la 0x278 si no se puede trabajar con la primera.

dev_file Se define el lugar donde se encuentran los drivers del puerto paralelo.

Ddir Se define la dirección (I/O) de los bits tipo D. Cdir Se define la dirección (I/O) de los bits tipo C. Los bits de tipo S no han de ser definidos ya que son siempre salidas y la dirección no es configurable.

Gonzalo Julián Santander Palacios

59

Mat-PLC

60

EJEMPLO El siguiente código iría en el archivo de configuración matplc.conf

Dev_file= /dev/plc_parpot0 del

//dirección donde se encuentran los drivers

uerto paralelo

Io_addr=0x278

//dirección de memoria del puerto

// En este caso se ha definido

salidas conocidas por MatPLC como L1 L2

L3 L4, las cuales usan lógica inversa map inv out D.0 L1 map inv out D.1 L2 map inv out D.2 L3 map inv out D.3 L4

Gonzalo Julián Santander Palacios

Hardware Realizado

61

Capítulo 5 HARDWARE REALIZADO

La misión principal del hardware realizado es la de

comprobara el

correcto funcionamiento del Sistema de Control Lógico Programable (PLC) apoyado en MatPLC y a su vez efectuar pruebas o ejemplos lo más reales posible, osease los más parecido a lo que es en la actualidad a un PLC comercial, para ello se creo una placa que pudiera trabajar con el puerto paralelo, donde se contaba con 8 entradas digitales reflejadas mediante LEDs de color verde y 4 salidas como interruptores. En la Figura 5-1 se muestra la primera placa que se fabricó la cual únicamente contaba con 8 salidas como LEDs, todos los LEDs cuentan con una resistencia de carga que hace que la tensión que cae en el LED sea la correcta y por lo tanto luzca a pleno rendimiento si la salida se pone en on.

Figura 5-1 Primera placa de pruebas

Una vez se comprobó que la placa funcionaba correctamente se creo una nueva placa la cual contaba con las 8 LEDs (salidas) y 4 interruptores

Gonzalo Julián Santander Palacios

Hardware Realizado como (entradas),

62

en la siguiente tabla se muestra que como quedan

definidas los pines :

Dirección

Tipo

Pins

Entradas

D.0 – D.7

2-9

Salidas

S.3 – S.7

10 - 13

En la siguiente Figura 5-2 se puede ver la segunda placa, en ella se puede apreciar una pila de 9 V, está es la encargada de alimentar los interruptores de tal manera que se esta cerrado dicho interruptor se la entrada este en ON y si esta abierto la entrada este en OFF.

La placa en si ya se encontró hecha ya que esta se comercializó en el año 2003 por la revista “PC y aplicaciones electrónicas” la cual te daba todos los componentes (placa con todas las pistas, puerto, LED´s y resistencias ) para fabricarte una placa de comprobación de puerto paralelo, lo único que hubo que hacer fue soldar todos los componentes y alimentar la placa con la pila de 9 V para los interruptores.

Gonzalo Julián Santander Palacios

Aplicaciones Desarrollados

Capítulo 6 APLICACIONES DESARROLLADOS

1 Aplicación ascensor 1.1 Funcionamiento del ascensor Este aplicación tiene como fin verificar el correcto funcionamiento del módulo IL (Instruction List) para ello se creo un ascensor de 4 plantas, el cual consta de una botonera de 4 botones uno por cada planta, 4 finales de carrera uno por cada planta, 4 luces que indican el piso en cual se encuentra el ascensor en cada momento.

Figura 6-1 Esquema ascensor Gonzalo Julián Santander Palacios

63

Aplicaciones Desarrollados

64

Figura 6-2 Grafcet Ascensor En la Figura 6-2 se puede ver el grafcet del ascensor de 4 plantas las etapas están distribuidas de la siguiente forma: ETAPA

Descripción

2

Sube de la planta 1 a la 2

3

Sube de la planta 1 a la 3

4

Sube de la planta 1 a la 4

5

Baja de la planta 2 a la 1

6

Sube de la planta 2 a la 3

7

Sube de la planta 2 a la 4

8

Baja de la planta 3 a la 1

9

Baja de la planta 3 a la 2

10

Sube de la planta 3 a la 4

11

Baja de la planta 4 a la 1

12

Baja de la planta 4 a la 2

13

Baja de la planta 4 a la 3

Tabla 6-1 Etapas ascensor de cuatro plantas

Gonzalo Julián Santander Palacios

Aplicaciones Desarrollados

El funcionamiento es el siguiente, siempre que se le pulse cualquier botón (Bot1, Bot2, Bot3, Bot4) y que no sea el mismo que la planta en la cual se encuentra el ascensor, este subirá o bajara dependiendo de su situación; los finales de carrera (FC1 FC2 FC3 FC4) son los que indican la situación del ascensor, estos además están unidos con las luces que indican la situación del ascensor (B1 B2 B3 B4). Por ejemplo si estamos en la planta 3 y se pulsa el botón 1 el ascensor bajará planta por planta dependiendo de los finales de carrera y abrirá sus puertas en el momento que se llegue al final de carrera 1. Además se cuenta dos luces señalizadotas del estado del ascensor cuando este está en movimiento, subiendo o bajando.

Gonzalo Julián Santander Palacios

65

Aplicaciones Desarrollados

1.2 Desarrollo del Interface Gráfico (HMI) La función de este interfaz (capitulo 4) es la de poder visualizar lo que ocurre en la aplicación con el fin de que el usuario lo pueda comprender e interactuar fácilmente con la aplicación. Para realizar se ha utilizado el programa GLADE . En este caso se ha desarrollado un interfaz de un ascensor de cuatro plantas:

Figura 6-3 Interface Ascensor de 4 plantas

Gonzalo Julián Santander Palacios

66

Aplicaciones Desarrollados Dicho interfaz cuenta con: 1. SALIDAS •

Una botonera : son los botones exteriores e interiores de un ascensor y tienen la utilidad avisar al ascensor a donde debe ir, el widget encargado de manipular dichos botones “GtkButton”.

Figura 6-4 Botonera y lista de propiedades •

unos finales de carrera: controlados por el usuario, los cuales avisan de la situación del ascensor. El widget encargado de su manipulación “GtkRadioButton”.

Figura 6-5 Finales de carrera

Gonzalo Julián Santander Palacios

67

Aplicaciones Desarrollados •

Un botón para poder cerrar la aplicación. En la siguente figura también se muestra la señal y el manejador de este boton. EL widgete encargado de su manipulación es “Gtktoggledbotton”.

Figura 6-6 Botón de cierre de aplicación

Gonzalo Julián Santander Palacios

68

Aplicaciones Desarrollados 2. ENTRADAS •

Luces de movimiento, indican si el ascensor esta subiendo o bajando. Son controlados por el widget “GnomePixmap”, en la Figura 6-7 se puede aprecia como son nombrados todos los GnomePixmap, esto ha sido explicado en el apartado 4.3 .

Figura 6-7 Widget de movimiento •

Luces de Posición del ascensor, indican la situación exacta del ascensor.

Figura 6-8 Luces de posición

•

Puertas del ascensor las puertas solo se abran cuando el ascensor haya llegado a la planta que le ha llamado, o lo que es lo mismo el momento en el cual llegue al final de carrera de la planta que le ha llamado

Gonzalo Julián Santander Palacios

69

Aplicaciones Desarrollados

Figura 6-9 Puertas del ascensor

Gonzalo Julián Santander Palacios

70

Aplicaciones Desarrollados

71

1.3 Desarrollo del archivo de configuración matplc.conf En el archivo de configuración hay que destacar las diferentes partes que lo forman: Definición de los módulos que se van ha utilizar Aquí se ponen las direcciones donde se encuentra los módulos que se van a usar durante la aplicación, hay que destacar el modulo plcshutdown el cual se encarga de cerrar la aplicación cuando el usuario decida. [PLC] # a corer los modulos!!! module chaser_il "./chaser_il" module hmi_gtk2 "../../mmi/hmi_gtk2/hmi_gtk2" module plcshutdown "../../lib/util/plcshutdown"

Sincronización Esta es una de las partes más importantes, es la que se encarga de sincronizar los diferentes módulos para que trabajen uno detrás de otro y no tengan ningún tipo de problema. Como se puede apreciar solo se sincronizan dos módulos el de transformación de Lista de Instrucciones a codigo C (modulo IL llamado chaser_il)

y el módulo HMI (llamado

hmi_gtk_2). El módulo seleccionado para empezar ha sido HMI.

[PLC] #sincronización de los módulos synch hmi_gtk2

-> chaser_il

synch chaser_il -> hmi_gtk2 #empieza el modulo hmi_gtk2 synch_start hmi_gtk2

Gonzalo Julián Santander Palacios

Aplicaciones Desarrollados Points Definición de los “I/O points” que podrán ser utilizados por el resto de módulos pero solo modificados por el módulo que se indica en este archivo. #

P O I N T S

#

-----------

# “I/O points” # name

= 'point' identificativo

= nombre que usa el PLC

# full name = Descripción de la variable # owner

= nombre del modulo que tiene permisos pa modificarlo

# bit

= tipo de variable

point B1

"Luz de senalizacion de planta 11" chaser_il

point B2

"Luz de senalizacion de planta 2" chaser_il

point B3

"Luz de senalizacion de planta 3" chaser_il

point B4

"Luz de senalizacion de planta 4" chaser_il

point P1

"Puerta ascensor Planta 1" chaser_il

point P2

"Puerta ascensor Planta 2" chaser_il

point P3

"Puerta ascensor Planta 3" chaser_il

point P4

"Puerta ascensor Planta 4" chaser_il

point sube

"Subir" chaser_il

point baja

"bajar" chaser_il

point Botex1 "Botonera" hmi_gtk2 point Botex2 "Botonera" hmi_gtk2 point Botex3 "Botonera" hmi_gtk2 point Botex4 "Botonera" hmi_gtk2

point final1 "Final de carrera 1" hmi_gtk2 point final2 "Final de carrera 2" hmi_gtk2

Gonzalo Julián Santander Palacios

72

Aplicaciones Desarrollados point final3 "Final de carrera 3" hmi_gtk2 point final4 "Final de carrera 4" hmi_gtk2

point quit

"quit" hmi_gtk2

point_alias quit_app1 "quit" quit

#Variables intermedias que no son salidas ni entradas que usa el programa internamete para que funcione bien point scroll_dir "scrolling direction" chaser_il point bot1 "boton 1" chaser_il point bot2 "boton 2" chaser_il point bot3 "boton 3" chaser_il point bot4 "boton 4" chaser_il #escaneo inicial del ascensor point first_scan "scaneo inicial" chaser_il #estado del ascensor si esta en movimiento o parado point Estado "estado del ascensor" chaser_il

Periodo Se especifica el periodo de scaneo de cada uno de los modulos el tiempo esta en milisegundos. hmi_gtk2: scan_period = 0.01 chaser_il: scan_period = 0.01 plcshutdown: scan_period = 0.01

Cierre de PLC Se indica que “I/O points” es el encargado de apagar el PLC [plcshutdown] quit_pt = quit

Gonzalo Julián Santander Palacios

73

Aplicaciones Desarrollados

1.4 Código bajo Lista de Instrucciones A continuación se muestra el código bajo lista de instrucciones desarrollado para el ascensor de 4 plantas, si se miran las Figura 6-1, Figura 6-2 y el apartado anterior (página 71)se podrá entender más claramente todo lo expuesto en las siguientes páginas.

LDI first_scan SET P4 SET first_scan

# Botones superiores van con los finasles de carrera

LD final1 OUT B1 LD final2 OUT B2 LD final3 OUT B3 LD final4 OUT B4

#Variable Estado del ascensor #Estado =1 -> En movimiento #Estado =0 -> Parado

# Funciones repecto al boton 1

LD Botex1 ANI Estado SET bot1

Gonzalo Julián Santander Palacios

74

Aplicaciones Desarrollados RST bot2 RST bot3 RST bot4

LD bot1 AND final2 SET Estado JSR subir

LD bot1 AND final3 SET Estado JSR subir

LD bot1 AND final4 SET Estado JSR subir

# Funciones repecto al boton 2

LD Botex2 ANI Estado SET bot2 RST bot1 RST bot3 RST bot4

LD bot2 AND final1 SET Estado JSR bajar

Gonzalo Julián Santander Palacios

75

Aplicaciones Desarrollados LD bot2 AND final3 SET Estado JSR subir

LD bot2 AND final4 SET Estado JSR subir

# Funciones repecto al boton 3

LD Botex3 ANI Estado SET bot3 RST bot1 RST bot2 RST bot4

LD bot3 AND final1 SET Estado JSR bajar

LD bot3 AND final2 SET Estado JSR bajar

LD bot3 AND final4 SET Estado JSR subir

Gonzalo Julián Santander Palacios

76

Aplicaciones Desarrollados

# Funciones repecto al boton 4

LD Botex4 ANI Estado SET bot4 RST bot1 RST bot2 RST bot3

LD bot4 AND final1 SET Estado JSR bajar

LD bot4 AND final2 SET Estado JSR bajar

LD bot4 AND final3 SET Estado JSR bajar

# Apertura de Puertas

LD bot1 AND final1 RST Estado RST bot1 JSR apertura1

Gonzalo Julián Santander Palacios

77

Aplicaciones Desarrollados LD bot2 AND final2 RST Estado RST bot2 JSR apertura2

LD bot3 AND final3 RST Estado RST bot3 JSR apertura3

LD bot4 AND final4 RST Estado RST bot4 JSR apertura4

# Subrutinas de funcionamiento

SUB subir

OUT P1 OUT P2 OUT P3 OUT P4

OUT sube OUTI baja

RST bot1 END

Gonzalo Julián Santander Palacios

78

Aplicaciones Desarrollados SUB bajar

OUT P1 OUT P2 OUT P3 OUT P4 OUTI sube OUT baja END

# Subrutinas de apertura de puertas

SUB apertura1

OUTI P1 OUT P2 OUT P3 OUT P4 OUT sube OUT baja END

SUB apertura2

OUTI P2 OUT P1 OUT P3 OUT P4 OUT sube OUT baja END

SUB apertura3

Gonzalo Julián Santander Palacios

79

Aplicaciones Desarrollados

OUTI P3 OUT P2 OUT P1 OUT P4 OUT sube OUT baja END

SUB apertura4

OUTI P4 OUT P2 OUT P3 OUT P1 OUT sube OUT baja END

###

Gonzalo Julián Santander Palacios

80

Aplicaciones Desarrollados

1.5 Código transformado a C Hay que destacar algunas de las funciones que usa MatPLC: •

plc_init(module_name,argc,argv)

Inicializa las librerías. El nombre del modulo ha de ser una cadena. •

pt_handle = plc_pt_by_name(pt_name)

Obtiene el módulo que maneja un “I/O points” cualquiera. La variable pt_name debe ser una cadena,la variable pt_handle ha de ser una estructura de tipo plc_pt_t. El suceso de si se ha recibido correctamen el manejador se guarda pt_handle.valid si no es cero significa que esta bien. •

plc_update()

Actualiza todos los “ “I/O points” que se almacena en la memoria global, de tal manera que si ha habido algún cambio en alguno de los

“I/O points” por parte del módulo que los maneja se

refresquen rápidamente y resto de módulos trabaje con los “I/O points” actuales. •

value = plc_get(pt_handle)

Lee el valor de cualquier “I/O “I/O points””, devuelve un entero de 32-bits. •

plc_set(pt_handle, new_value)

Escribe un entero de 32 bits en el “I/O “I/O points”” indicado. •

plc_scan_beg()

Comienzo del escaneo. •

plc_scan_end()

Fin del escaneo.

Gonzalo Julián Santander Palacios

81

Aplicaciones Desarrollados

# 1 "../../logic/il/il2c:template1"

/************************************************************** * DO NOT EDIT - This file is automatically generated by il2c * **************************************************************/

#include

#define stk_depth 8 /* stack depth - eight is normal */

/* a couple of shortcuts */ #define acc stack[top] /* accumulator == top of stack */ #define next stack[(top + 1) % stk_depth] /* one beyond top of stack */ #define push top = (top + 1) % stk_depth #define pop top = (top + stk_depth - 1) % stk_depth

/* * Should probably use `n&7' instead of `n%8' but never mind for now. * Alternatively, switch to using the bits of a single char for the stack * and shifts for push and pop. */

# 1 "../../logic/il/il2c:subroutine_declaration" static void IL_sub_subir(void); static void IL_sub_bajar(void); static void IL_sub_apertura1(void); static void IL_sub_apertura2(void); static void IL_sub_apertura3(void); static void IL_sub_apertura4(void);

Gonzalo Julián Santander Palacios

82

Aplicaciones Desarrollados

83

# 1 "../../logic/il/il2c:point_handle_declaration" static plc_pt_t sube; static plc_pt_t bot1; static plc_pt_t P2; static plc_pt_t Botex2; static plc_pt_t B4; static plc_pt_t bot2; static plc_pt_t P1; static plc_pt_t Botex1; static plc_pt_t baja; static plc_pt_t Botex3; static plc_pt_t Botex4; static plc_pt_t P3; static plc_pt_t bot4; static plc_pt_t final3; static plc_pt_t B2; static plc_pt_t B1; static plc_pt_t final2; static plc_pt_t B3; static plc_pt_t final1; static plc_pt_t Estado; static plc_pt_t P4; static plc_pt_t first_scan; static plc_pt_t final4; static plc_pt_t bot3;

# 1 "../../logic/il/il2c:template2"

static

unsigned

char

top=0;

/*

top

of

stack

points”er) */ static u32 stack[stk_depth]; static u32 master=1; /* for the MCS instruction */

Gonzalo Julián Santander Palacios

(ie,

stack

“I/O

Aplicaciones Desarrollados

84

static void IL_main(void) { master=1; /* reset MCS */

/************************************** chaser_il.il */ # 1 "chaser_il.il"

# 27 "chaser_il.il" push;

acc

=

master

?

!plc_get(first_scan)

:

0;/*

LDI

first_scan */ # 28 "chaser_il.il" if (acc) plc_set(P4,1);

/* SET P4 */

# 29 "chaser_il.il" if (acc) plc_set(first_scan,1);

/* SET first_scan */ /* Botones superiores

van con los finasles de carrera */

# 34 "chaser_il.il" push; acc = master ? plc_get(final1) : 0;/* LD final1 */ # 35 "chaser_il.il" plc_set(B1,acc);

/* OUT B1 */

# 36 "chaser_il.il" push; acc = master ? plc_get(final2) : 0;/* LD final2 */ # 37 "chaser_il.il" plc_set(B2,acc);

/* OUT B2 */

# 38 "chaser_il.il" push; acc = master ? plc_get(final3) : 0;/* LD final3 */ # 39 "chaser_il.il" plc_set(B3,acc);

# 40 "chaser_il.il"

Gonzalo Julián Santander Palacios

/* OUT B3 */

Aplicaciones Desarrollados

85

push; acc = master ? plc_get(final4) : 0;/* LD final4 */ # 41 "chaser_il.il" plc_set(B4,acc);

/* OUT B4 */

/* Variable Estado del ascensor */

/* Estado =1 -> En movimiento */ /* Estado =0 -> Parado */ /* Funciones repecto al boton 1 */

# 50 "chaser_il.il" push; acc = master ? plc_get(Botex1) : 0;/* LD Botex1 */ # 51 "chaser_il.il" acc = acc && !plc_get(Estado);

/* ANI Estado */

# 52 "chaser_il.il" if (acc) plc_set(bot1,1);

/* SET bot1 */

# 53 "chaser_il.il" if (acc) plc_set(bot2,0);

/* RST bot2 */

# 54 "chaser_il.il" if (acc) plc_set(bot3,0);

/* RST bot3 */

# 55 "chaser_il.il" if (acc) plc_set(bot4,0);

/* RST bot4 */

# 57 "chaser_il.il" push; acc = master ? plc_get(bot1) : 0;/* LD bot1 */ # 58 "chaser_il.il" acc = acc && plc_get(final2);

/* AND final2 */

# 59 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 60 "chaser_il.il" if (acc) {pop; IL_sub_subir();}

# 62 "chaser_il.il"

Gonzalo Julián Santander Palacios

/* JSR subir */

Aplicaciones Desarrollados

86

push; acc = master ? plc_get(bot1) : 0;/* LD bot1 */ # 63 "chaser_il.il" acc = acc && plc_get(final3);

/* AND final3 */

# 64 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 65 "chaser_il.il" if (acc) {pop; IL_sub_subir();}

/* JSR subir */

# 67 "chaser_il.il" push; acc = master ? plc_get(bot1) : 0;/* LD bot1 */ # 68 "chaser_il.il" acc = acc && plc_get(final4);

/* AND final4 */

# 69 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 70 "chaser_il.il" if (acc) {pop; IL_sub_subir();}

/* JSR subir */

/* Funciones repecto al boton 2 */

# 75 "chaser_il.il" push; acc = master ? plc_get(Botex2) : 0;/* LD Botex2 */ # 76 "chaser_il.il" acc = acc && !plc_get(Estado);

/* ANI Estado */

# 77 "chaser_il.il" if (acc) plc_set(bot2,1);

/* SET bot2 */

# 78 "chaser_il.il" if (acc) plc_set(bot1,0);

/* RST bot1 */

# 79 "chaser_il.il" if (acc) plc_set(bot3,0);

/* RST bot3 */

# 80 "chaser_il.il" if (acc) plc_set(bot4,0);

# 82 "chaser_il.il"

Gonzalo Julián Santander Palacios

/* RST bot4 */

Aplicaciones Desarrollados

87

push; acc = master ? plc_get(bot2) : 0;/* LD bot2 */ # 83 "chaser_il.il" acc = acc && plc_get(final1);

/* AND final1 */

# 84 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 85 "chaser_il.il" if (acc) {pop; IL_sub_bajar();}

/* JSR bajar */

# 87 "chaser_il.il" push; acc = master ? plc_get(bot2) : 0;/* LD bot2 */ # 88 "chaser_il.il" acc = acc && plc_get(final3);

/* AND final3 */

# 89 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 90 "chaser_il.il" if (acc) {pop; IL_sub_subir();}

/* JSR subir */

# 92 "chaser_il.il" push; acc = master ? plc_get(bot2) : 0;/* LD bot2 */ # 93 "chaser_il.il" acc = acc && plc_get(final4);

/* AND final4 */

# 94 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 95 "chaser_il.il" if (acc) {pop; IL_sub_subir();}

/* JSR subir */

/* Funciones repecto al boton 3 */

# 99 "chaser_il.il" push; acc = master ? plc_get(Botex3) : 0;/* LD Botex3 */ # 100 "chaser_il.il" acc = acc && !plc_get(Estado); # 101 "chaser_il.il"

Gonzalo Julián Santander Palacios

/* ANI Estado */

Aplicaciones Desarrollados if (acc) plc_set(bot3,1);

88 /* SET bot3 */

# 102 "chaser_il.il" if (acc) plc_set(bot1,0);

/* RST bot1 */

# 103 "chaser_il.il" if (acc) plc_set(bot2,0);

/* RST bot2 */

# 104 "chaser_il.il" if (acc) plc_set(bot4,0);

/* RST bot4 */

# 106 "chaser_il.il" push; acc = master ? plc_get(bot3) : 0;/* LD bot3 */ # 107 "chaser_il.il" acc = acc && plc_get(final1);

/* AND final1 */

# 108 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 109 "chaser_il.il" if (acc) {pop; IL_sub_bajar();}

/* JSR bajar */

# 111 "chaser_il.il" push; acc = master ? plc_get(bot3) : 0;/* LD bot3 */ # 112 "chaser_il.il" acc = acc && plc_get(final2);

/* AND final2 */

# 113 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 114 "chaser_il.il" if (acc) {pop; IL_sub_bajar();}

/* JSR bajar */

# 116 "chaser_il.il" push; acc = master ? plc_get(bot3) : 0;/* LD bot3 */ # 117 "chaser_il.il" acc = acc && plc_get(final4);

/* AND final4 */

# 118 "chaser_il.il" if (acc) plc_set(Estado,1); # 119 "chaser_il.il"

Gonzalo Julián Santander Palacios

/* SET Estado */

Aplicaciones Desarrollados if (acc) {pop; IL_sub_subir();}

89 /* JSR subir */

/* Funciones respecto al botón 4 */

# 123 "chaser_il.il" push; acc = master ? plc_get(Botex4) : 0;/* LD Botex4 */ # 124 "chaser_il.il" acc = acc && !plc_get(Estado);

/* ANI Estado */

# 125 "chaser_il.il" if (acc) plc_set(bot4,1);

/* SET bot4 */

# 126 "chaser_il.il" if (acc) plc_set(bot1,0);

/* RST bot1 */

# 127 "chaser_il.il" if (acc) plc_set(bot2,0);

/* RST bot2 */

# 128 "chaser_il.il" if (acc) plc_set(bot3,0);

/* RST bot3 */

# 130 "chaser_il.il" push; acc = master ? plc_get(bot4) : 0;/* LD bot4 */ # 131 "chaser_il.il" acc = acc && plc_get(final1);

/* AND final1 */

# 132 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 133 "chaser_il.il" if (acc) {pop; IL_sub_bajar();}

/* JSR bajar */

# 135 "chaser_il.il" push; acc = master ? plc_get(bot4) : 0;/* LD bot4 */ # 136 "chaser_il.il" acc = acc && plc_get(final2);

/* AND final2 */

# 137 "chaser_il.il" if (acc) plc_set(Estado,1); # 138 "chaser_il.il"

Gonzalo Julián Santander Palacios

/* SET Estado */

Aplicaciones Desarrollados if (acc) {pop; IL_sub_bajar();}

90 /* JSR bajar */

# 140 "chaser_il.il" push; acc = master ? plc_get(bot4) : 0;/* LD bot4 */ # 141 "chaser_il.il" acc = acc && plc_get(final3);

/* AND final3 */

# 142 "chaser_il.il" if (acc) plc_set(Estado,1);

/* SET Estado */

# 143 "chaser_il.il" if (acc) {pop; IL_sub_bajar();}

/* JSR bajar */

/* Apertura de Puertas */

# 147 "chaser_il.il" push; acc = master ? plc_get(bot1) : 0;/* LD bot1 */ # 148 "chaser_il.il" acc = acc && plc_get(final1);

/* AND final1 */

# 149 "chaser_il.il" if (acc) plc_set(Estado,0);

/* RST Estado */

# 150 "chaser_il.il" if (acc) plc_set(bot1,0);

/* RST bot1 */

# 151 "chaser_il.il" if (acc) {pop; IL_sub_apertura1();}

/* JSR apertura1 */

# 153 "chaser_il.il" push; acc = master ? plc_get(bot2) : 0;/* LD bot2 */ # 154 "chaser_il.il" acc = acc && plc_get(final2);

/* AND final2 */

# 155 "chaser_il.il" if (acc) plc_set(Estado,0);

/* RST Estado */

# 156 "chaser_il.il" if (acc) plc_set(bot2,0); # 157 "chaser_il.il"

Gonzalo Julián Santander Palacios

/* RST bot2 */

Aplicaciones Desarrollados

91

if (acc) {pop; IL_sub_apertura2();}

/* JSR apertura2 */

# 159 "chaser_il.il" push; acc = master ? plc_get(bot3) : 0;/* LD bot3 */ # 160 "chaser_il.il" acc = acc && plc_get(final3);

/* AND final3 */

# 161 "chaser_il.il" if (acc) plc_set(Estado,0);

/* RST Estado */

# 162 "chaser_il.il" if (acc) plc_set(bot3,0);

/* RST bot3 */

# 163 "chaser_il.il" if (acc) {pop; IL_sub_apertura3();}

/* JSR apertura3 */

# 165 "chaser_il.il" push; acc = master ? plc_get(bot4) : 0;/* LD bot4 */ # 166 "chaser_il.il" acc = acc && plc_get(final4);

/* AND final4 */

# 167 "chaser_il.il" if (acc) plc_set(Estado,0);

/* RST Estado */

# 168 "chaser_il.il" if (acc) plc_set(bot4,0);

/* RST bot4 */

# 169 "chaser_il.il" if (acc) {pop; IL_sub_apertura4();}

/* JSR apertura4 */

/* Subrutinas de funcionamiento */

# 176 "chaser_il.il" } static void IL_sub_subir(void) {

/* SUB subir */

# 178 "chaser_il.il" plc_set(P1,acc);

/* OUT P1 */

# 179 "chaser_il.il" plc_set(P2,acc);

Gonzalo Julián Santander Palacios

/* OUT P2 */

Aplicaciones Desarrollados

92

# 180 "chaser_il.il" plc_set(P3,acc);

/* OUT P3 */

# 181 "chaser_il.il" plc_set(P4,acc);

/* OUT P4 */

# 183 "chaser_il.il" plc_set(sube,acc);

/* OUT sube */

# 184 "chaser_il.il" plc_set(baja,!acc);

/* OUTI baja */

# 186 "chaser_il.il" if (acc) plc_set(bot1,0);

/* RST bot1 */

# 187 "chaser_il.il" return;

/* END */

# 189 "chaser_il.il" } static void IL_sub_bajar(void) {

/* SUB bajar */

# 191 "chaser_il.il" plc_set(P1,acc);

/* OUT P1 */

# 192 "chaser_il.il" plc_set(P2,acc);

/* OUT P2 */

# 193 "chaser_il.il" plc_set(P3,acc);

/* OUT P3 */

# 194 "chaser_il.il" plc_set(P4,acc);

/* OUT P4 */

# 196 "chaser_il.il" plc_set(sube,!acc);

/* OUTI sube */

# 197 "chaser_il.il" plc_set(baja,acc);

/* OUT baja */

# 199 "chaser_il.il" return;

/* Subrutinas de apertura de puertas */

Gonzalo Julián Santander Palacios

/* END */

Aplicaciones Desarrollados

93

# 203 "chaser_il.il" } static void IL_sub_apertura1(void) {

/* SUB apertura1 */

# 205 "chaser_il.il" plc_set(P1,!acc);

/* OUTI P1 */

# 206 "chaser_il.il" plc_set(P2,acc);

/* OUT P2 */

# 207 "chaser_il.il" plc_set(P3,acc);

/* OUT P3 */

# 208 "chaser_il.il" plc_set(P4,acc);

/* OUT P4 */

# 210 "chaser_il.il" plc_set(sube,acc);

/* OUT sube */

# 211 "chaser_il.il" plc_set(baja,acc);

/* OUT baja */

# 214 "chaser_il.il" return;

/* END */

# 216 "chaser_il.il" } static void IL_sub_apertura2(void) {

/* SUB apertura2 */

# 218 "chaser_il.il" plc_set(P2,!acc);

/* OUTI P2 */

# 219 "chaser_il.il" plc_set(P1,acc);

/* OUT P1 */

# 220 "chaser_il.il" plc_set(P3,acc);

/* OUT P3 */

# 221 "chaser_il.il" plc_set(P4,acc);

/* OUT P4 */

# 223 "chaser_il.il" plc_set(sube,acc);

Gonzalo Julián Santander Palacios

/* OUT sube */

Aplicaciones Desarrollados

94

# 224 "chaser_il.il" plc_set(baja,acc);

/* OUT baja */

# 226 "chaser_il.il" return;

/* END */

# 228 "chaser_il.il" } static void IL_sub_apertura3(void) {

/* SUB apertura3 */

# 230 "chaser_il.il" plc_set(P3,!acc);

/* OUTI P3 */

# 231 "chaser_il.il" plc_set(P2,acc);

/* OUT P2 */

# 232 "chaser_il.il" plc_set(P1,acc);

/* OUT P1 */

# 233 "chaser_il.il" plc_set(P4,acc);

/* OUT P4 */

# 235 "chaser_il.il" plc_set(sube,acc);

/* OUT sube */

# 236 "chaser_il.il" plc_set(baja,acc);

/* OUT baja */

# 238 "chaser_il.il" return;

/* END */

# 240 "chaser_il.il" } static void IL_sub_apertura4(void) {

/* SUB apertura4 */

# 242 "chaser_il.il" plc_set(P4,!acc);

/* OUTI P4 */

# 243 "chaser_il.il" plc_set(P2,acc);

Gonzalo Julián Santander Palacios

/* OUT P2 */

Aplicaciones Desarrollados

95

# 244 "chaser_il.il" plc_set(P3,acc);

/* OUT P3 */

# 245 "chaser_il.il" plc_set(P1,acc);

/* OUT P1 */

# 247 "chaser_il.il" plc_set(sube,acc);

/* OUT sube */

# 248 "chaser_il.il" plc_set(baja,acc);

/* OUT baja */

# 250 "chaser_il.il" return;

/* END */

/* ### */

/************************************** [end] */ # 1 "../../logic/il/il2c:template3"

}

int main(int argc,char *argv[]) { plc_init("chaser_il",argc,argv); # 1 "../../logic/il/il2c:point_handle_initialization" sube = plc_pt_by_name("sube"); bot1 = plc_pt_by_name("bot1"); P2 = plc_pt_by_name("P2"); Botex2 = plc_pt_by_name("Botex2"); B4 = plc_pt_by_name("B4"); bot2 = plc_pt_by_name("bot2"); P1 = plc_pt_by_name("P1"); Botex1 = plc_pt_by_name("Botex1"); baja = plc_pt_by_name("baja"); Botex3 = plc_pt_by_name("Botex3");

Gonzalo Julián Santander Palacios

Aplicaciones Desarrollados Botex4 = plc_pt_by_name("Botex4"); P3 = plc_pt_by_name("P3"); bot4 = plc_pt_by_name("bot4"); final3 = plc_pt_by_name("final3"); B2 = plc_pt_by_name("B2"); B1 = plc_pt_by_name("B1"); final2 = plc_pt_by_name("final2"); B3 = plc_pt_by_name("B3"); final1 = plc_pt_by_name("final1"); Estado = plc_pt_by_name("Estado"); P4 = plc_pt_by_name("P4"); first_scan = plc_pt_by_name("first_scan"); final4 = plc_pt_by_name("final4"); bot3 = plc_pt_by_name("bot3");

# 1 "../../logic/il/il2c:template4" while (1) { plc_scan_beg(); plc_update();

IL_main();

plc_update(); plc_scan_end(); } }

Gonzalo Julián Santander Palacios

96

Aplicaciones Desarrollados

2 Aplicación Rapidez 2.1 Funcionamiento básico de la aplicación rapidez El objetivo básico de este aplicación es medir el tiempo de reacción del ser humano, para ello lo que se hace es medir el duración desde que se enciende una luz en la pantalla hasta que pulsamos la tecla que esta ligada a la luz. Además este aplicación tiene la finalidad de mostrar como se realiza un módulo en MatPLC si utilizar el módulo IL, por tanto hay que destacar que esta íntegramente desarrollado bajo lenguaje C.

Figura 6-10 Aplicación rapidez

Gonzalo Julián Santander Palacios

97

Aplicaciones Desarrollados

2.2 Desarrollo del interfaz gráfico (HMI) El interfaz cuenta con diferentes widgets cumple las funciónes de: SALIDAS •

Un botón para realizar un juego nuevo. EL widget encargado de su manipulación es “Gtktoggledbotton”.

Figura 6-11 Boton de Juego Nuevo •

Un botón para pulsar cuando se encienda la luz. El widget encargado de su manipulación es “Gtktoggledbotton”.

Figura 6-12 Boton de reacción •

Un botón para poder cerrar la aplicación. EL widget encargado de su manipulación es “Gtktoggledbotton”.

Figura 6-13 Boton de cierre de aplicación

Gonzalo Julián Santander Palacios

98

Aplicaciones Desarrollados

99

ENTRADAS •

Un marcador de tiempos donde se muestran los tiempos de reacción del operario y los de ejecución del programa, este último es el tiempo que tarda el programa desde que se pulsa el botón hasta que se enciende la luz roja. El widget encargado de su manipulación es “Gtklabel”.

Figura 6-14 Tiempos de reacción y ejecución •

Luces de señalización la luz verde indícale momento en cual se ha de pulsar el botón, mientras que la roja indica que se ha pulsado el botón.

El

widget

encargado

de

su

“GnomoPixmap”.

Figura 6-15 Luces indicativas

Gonzalo Julián Santander Palacios

manipulación

es

Aplicaciones Desarrollados

2.3 Desarrollo del archivo de configuración matplc.conf En el archivo de configuración hay que destacar las diferentes partes que lo forman: Definición de los módulos que se van ha utilizar Aquí se ponen las direcciones donde se encuentra los módulos que se van a usar durante la aplicación, hay que destacar el modulo plcshutdown el cual se encarga de cerrar la aplicación cuando el usuario decida. [PLC] # a correr los módulos!!! module Chaser "./chaser" module hmi_gtk2 "../../mmi/hmi_gtk2/hmi_gtk2" module plcshutdown "../../lib/util/plcshutdown""

“I/O points” Definición de los “I/O points” que podrán ser utilizados por el resto de módulos pero solo modificados por el módulo que se indica en este archivo. #

P O I N T S

#

-----------

# “I/O points” # name

= 'point' identificativo

= nombre que usa el PLC

# full name = Descripción de la variable # owner

= nombre del modulo que tiene permisos pa modificarlo

# bit

= tipo de variable

point L1

"light 1" Chaser

point L3

"light 3" Chaser

point in1

"tiempo de reacción" Chaser 32

point in2

"tiempo de ejecución" Chaser 32

point keyA

"key L" hmi_gtk2

Gonzalo Julián Santander Palacios

100

Aplicaciones Desarrollados point nuevo

"" hmi_gtk2

point quit

"quit" hmi_gtk2

point_alias quit_app1 "quit" quit

Periodo Se especifica el periodo de escaneo de cada uno de los módulos el tiempo esta en milisegundos. hmi_gtk2: scan_period = 0.001 Chaser: scan_period = 0.001 plcshutdown: scan_period = 0.001

Cierre de PLC Se indica que “I/O points” es el encargado de apagar el PLC [plcshutdown] quit_pt = quit

Gonzalo Julián Santander Palacios

101

Aplicaciones Desarrollados

2.4 Código bajo Lista de Instrucciones A continuación se muestra el código en C desarrollado para el aplicación ascensor. #include #include

#include #include

/* * Get a handle to a “I/O points”, checking that it's valid. Abort if the handle * could not be obtained. */ plc_pt_t get_pt(const char *pt_name) { plc_pt_t pt_handle; pt_handle = plc_pt_by_name(pt_name);

if (!pt_handle.valid) { plc_log_errmsg(1, "Could not get handle to %s, aborting.", pt_name); printf("Could not get valid handle to %s.\n", pt_name); exit(1); } return pt_handle; }

Gonzalo Julián Santander Palacios

102

Aplicaciones Desarrollados

/* Obtain the chasing delay from the config, default 0.5 seconds. */ double get_delay(void) { double res; /* * Get the value "delay", of type double, into res. * Minimum 0, maximum HUGE_VAL (ie, no maximum), default 0.5 */ if (conffile_get_value_d("delay", &res, 0, HUGE_VAL, 0.5) == 0) { /* a return value of 0 means OK - return the value obtained */ return res; } /* some sort of problem - log it, and use half a second */ plc_log_wrnmsg(1, "Could not get delay from config, using 0.5s"); return 0.5; }

void chase(void) { plc_pt_t in1,in2,L1,L3,keyA,nuevo; plc_timer_t timer,timer2; double x=0,z=0,i=0,j=0; /* get the “I/O points” handles */ in1= get_pt("in1"); in2= get_pt("in2"); L1= get_pt("L1");

L3= get_pt("L3");

keyA= get_pt("keyA"); nuevo= get_pt("nuevo");

Gonzalo Julián Santander Palacios

103

Aplicaciones Desarrollados

/*now chase!*/ while (1) { /*beginning of scan*/ plc_scan_beg(); plc_update(); plc_set(L3,0);

if(plc_get(nuevo)){ plc_set(L1,0);

x=0; do{

z=1; if(i==100000){ plc_set(L3,1); plc_timer_start(timer); z=0; i=0; } plc_update(); i=i+1; while(z==0){ if (plc_get(keyA)==1 && j==0) { plc_set(L1,1); plc_timer_start(timer2); plc_set_f32(in1,plc_timer_get(timer)); x=1; z=1; j=1; }

Gonzalo Julián Santander Palacios

104

Aplicaciones Desarrollados plc_update(); if (plc_get(keyA)==0 && j==1) { plc_set(L1,1); plc_timer_start(timer2); plc_set_f32(in1,plc_timer_get(timer)); x=1; z=1; j=0; } plc_update(); } plc_set_f32(in2,plc_timer_get(timer2)); plc_timer_clear(timer2);

}while(x==0);

} /* end of scan */ plc_update(); plc_scan_end(); } }

int main(int argc, char **argv) { /* initialise the MatPLC library */ if (plc_init("Chaser", argc, argv) < 0) { printf("Error initializing PLC\n"); return -1; } chase(); return 0; }

Gonzalo Julián Santander Palacios

105

Aplicaciones Desarrollados

Hay que destacar algunas de las funciones que usa matplc: •

plc_init(module_name,argc,argv)

Inicializa las libreirias. El nombre del modulo ha de ser una cadena. •

pt_handle = plc_pt_by_name(pt_name)

Obtiene el módulo que maneja un “I/O points” cualquiera,. La variable pt_name debe ser una cadena,la variable pt_handle ha de ser una estructura de tipo plc_pt_t. El suceso de si se ha recibido correctamen el manejador se guarda pt_handle.valid si no es cero significa que esta bien. •

plc_update()

Actualiza todos los “I/O “I/O points”s”que se almacena en la memoria global, de tal manera que si ha habido algún cambio en alguno de los “I/O “I/O points”s”por parte del módulo que los maneja se refresquen rápidamente y resto de módulos trabaje con los “I/O “I/O points”s”actuales.

•

value = plc_get(pt_handle)

Lee el valor de cualquier “I/O points”, devuelve un entero de 32bits. •

plc_set(pt_handle, new_value)

Escribe un entero de 32 bits en el “I/O points” indicado. •

plc_scan_beg()

Comienzo del escaneo. •

plc_scan_end()

Fin del escaneo.

Gonzalo Julián Santander Palacios

106

Resultados Y Experimentos

Capítulo 7 RESULTADOS Y EXPERIMENTOS

Los resultados obtenidos han sido satisfactorios ya que se ha confirmado que MatPLC es un buen Sistema recontrol Lógico Programable. Todas los aplicaciones desarrollados los cuales muestran el potencial de MatPLC han cumplido las expectativas propuestas; se ha logrado que todos los módulos que se han estudiado (IL, HMI_GTK, Puerto Paralelo) trabajen conjuntamente consiguiendo unas aplicaciones muy completos.

Figura 7-1 Aplicación ascensor 4 plantas Los estudios realizados han sido reflejados en el proyecto, se ha creado una documentación

que la empresa SAC S.A. podrá utilizarla en un

futuro cercano y podrá realizar estudios más avanzados de la estructura que forma MatPLC.

Gonzalo Julián Santander Palacios

107

Resultados Y Experimentos

108

Además hay que destacar que todos estos estudios has servido al proyectista a coger conocimientos sobre el mundo del software abierto llámese LINUX, GLADE, MatPLC y otras muchas aplicaciones que lo engloban. Uno de los problemas del proyecto fue que se empezó trabajando con un Live-CD exactamente KANOPPIX, el cual brindaba la posibilidad de poder trabajar con MatPLC en cualquier ordenador, pero este ofrecía la desventaja de que no contaba con la aplicación GLADE y además no podía instalarse ya KNOPPIX trabaja sobre un DVD y la memoria RAM, por lo tanto se opto por instalar FEDORA CORE 3.0 en el ordenador portátil del proyectista el cual contaba con GLADE y todas las librerías que utiliza el módulo HMI_GTK de MatPLC, aún así esto tenia otra desventaja,

el portátil no contaba con puerto paralelo con lo cual en un

principio no se pudo probar la aplicación ascensor con el módulo del Puerto Paralelo, ante esto se busco un ordenador de la empresa (SAC S.A.) que contará con el sistema operativo LINUX y que tuviera

puerto

paralelo, de esta manera se comprobó de modo satisfactoria en todo su conjunto la aplicación “Ascensor de 4 plantas”.

Gonzalo Julián Santander Palacios

Conclusiones

Capítulo 8 CONCLUSIONES

Como conclusión principal es que se han cumplido todos los objetivos propuestos, se ha conseguido un Sistema de Control Lógico Programable (PLC) concretamente MatPLC y se he realizado una documentación de su estructura y de alguno de sus modulos más importantes (IL, HMI_GTK, Parallel Port), así como una serie de aplicaciones que lo confirman funcionalidad de MatPLC.

También hay que destacar que la falta de conocimiento por parte del proyectista sobre LINUX, MatPLC y GLADE ha hecho que las aplicaciones no sean excesivamente complejos y no se pueda medir con exactitud todo el potencial que puede ofrecer MatPLC, pero se ha creado una base sólida que podrá ser usada.

Gonzalo Julián Santander Palacios

109

Futuros Desarrollos

Capítulo 9 FUTUROS DESARROLLOS

Ya que al principio se empezó trabajando con un Live-CD ( KNOPPIX) y luego no se pudo continuar con él se propone como futuro desarrollo realizar un Live-CD que cuente con MatPLC y todas las aplicaciones que hacen falta como por ejemplo GLADE y las librerías gráficas. Otro futuro desarrollo podría ser crean aplicaciones más complejas y que engloben la mayoría de los módulos con el fin de medir el potencial de MatPLC.

Gonzalo Julián Santander Palacios

110

Parte II ESTUDIO ECONÓMICO

Estudio Económico

El proyecto realizado es rentable en el sentido de que los costes para la empresa serían nulos en cuanto a que las actuales aplicaciones de simulación de PLCs que hay en el mercado son costosas, MatPLC al ser una aplicación de código abierto no trae ningún coste adicional. El único coste sería las horas que ha dedicado el ingeniero para verificar que MatPLC es un buen simulador.

Gonzalo Julián Santander Palacios

112

Anexos

113

Parte III ANEXOS

Anexos

1 ANEXO MANUAL GLADE

Gonzalo Julián Santander Palacios

114

Anexos

Gonzalo Julián Santander Palacios

115

Anexos

Gonzalo Julián Santander Palacios

116

Anexos

Gonzalo Julián Santander Palacios

117

Anexos

Gonzalo Julián Santander Palacios

118

Anexos

Gonzalo Julián Santander Palacios

119

Anexos

Gonzalo Julián Santander Palacios

120

Anexos

Gonzalo Julián Santander Palacios

121

Anexos

Gonzalo Julián Santander Palacios

122

Anexos

Gonzalo Julián Santander Palacios

123

Anexos

Gonzalo Julián Santander Palacios

124

Anexos

Gonzalo Julián Santander Palacios

125

Anexos

Gonzalo Julián Santander Palacios

126

Anexos

Gonzalo Julián Santander Palacios

127

Anexos

Gonzalo Julián Santander Palacios

128

Anexos

Gonzalo Julián Santander Palacios

129

Anexos

Gonzalo Julián Santander Palacios

130

Anexos

Gonzalo Julián Santander Palacios

131

Anexos

Gonzalo Julián Santander Palacios

132

Anexos

Gonzalo Julián Santander Palacios

133

Anexos

Gonzalo Julián Santander Palacios

134

Anexos

Gonzalo Julián Santander Palacios

135

Anexos

2 ANEXO IEC 61131-3

Gonzalo Julián Santander Palacios

136

Anexos

Gonzalo Julián Santander Palacios

137

Anexos

Gonzalo Julián Santander Palacios

138

Anexos

Gonzalo Julián Santander Palacios

139

Anexos

Gonzalo Julián Santander Palacios

140