Controlador modular programable, basado en procesador de ... · Controlador modular programable,...

Alberto Martínez Inchusta

Controlador modular programable, basado en procesadorde 32 bits y CAN bus

Javier Esteban Vicuña Martínez

Escuela Técnica Superior de Ingeniería Industrial

Proyecto Fin de Carrera

Ingeniería Eléctrica

2012-2013

Título

Autor/es

Director/es

Facultad

Titulación

Departamento

PROYECTO FIN DE CARRERA

Curso Académico

© El autor© Universidad de La Rioja, Servicio de Publicaciones, 2013

publicaciones.unirioja.esE-mail: [email protected]

Controlador modular programable, basado en procesador de 32 bits y CANbus, proyecto fin de carrera

de Alberto Martínez Inchusta, dirigido por Javier Esteban Vicuña Martínez (publicado por la Universidad de La Rioja), se difunde bajo una Licencia

Creative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0 Unported. Permisos que vayan más allá de lo cubierto por esta licencia pueden solicitarse a los

titulares del copyright.

CONTROLADOR MODULAR PROGRAMABLE BASADO EN PROCESADOR DE 32 BITS Y CAN

BUS.

TITULACIÓN: Ingeniería Industrial Superior.

AUTOR: Alberto Martínez Inchusta.

DIRECTOR DEL PROYECTO: Javier Esteban Vicuña Martínez.

DEPARTAMENTO: Departamento de Ingeniería Eléctrica.

CURSO ACADÉMICO: 2012/2013

Índice General

Índice de la memoria. 1. Introducción. .............................................................................................1

2. Objeto ........................................................................................................2

3. Alcance.......................................................................................................3

4. Antecedentes..............................................................................................4

5. Normas y referencias ..................................................................................6

6. Definiciones y abreviaturas.........................................................................8

7. Análisis de soluciones................................................................................10

8. Resultados finales......................................................................................24

9. Posibles vías de ampliación. ....................................................................134

Índice de Anexos. 1. Anexo 1. Características técnicas de los componentes electrónicos usados en

el hardware de las placas...............................................................................1

2. Anexo 2. Hardware y software del CAN bus..................................................14

3. Anexo 3. Código de la aplicación SCADA........................................................73

4. Anexo 4. Contenido del cd adjunto. ..............................................................74

Índice de Planos. 1. Plano 1. Entradas digitales............................................................................1

2. Plano 2. Salidas digitales...............................................................................2

3. Plano 3. Entradas analógicas .........................................................................3

4. Plano 4. Estructura hardware del autómata..................................................4

5. Plano 5. Placa principal.................................................................................5

6. Plano 6. Esquema electrónico de las salidas digitales rápidas........................6

7. Plano 7. Esquema electrónico de las salidas digitales a triac..........................7

8. Plano 8. Esquema electrónico de las entradas analógicas. .............................8

9. Plano 9. Esquema electrónico de las entradas digitales..................................9

Índice del pliego de condiciones. 1. Disposiciones Generales...............................................................................1

2. Disposiciones legales y normativa aplicable..................................................4

3. Condiciones facultativas................................................................................6

4. Condiciones de ejecución y montaje..............................................................8

5. Condiciones de materiales y equipos...........................................................28

6. Manual de usuario.......................................................................................34

7. Disposición final...........................................................................................48

Índice de Presupuesto. 1. Introducción.................................................................................................1

2. Mediciones...................................................................................................2

3. Cuadros de precios unitarios.........................................................................4

4. Presupuesto parcial.......................................................................................6

5. Presupuesto total........................................................................................10

Memoria

Índice de la memoria. 1. Introducción. ............................................................................................................. 1 2. Objeto ........................................................................................................................... 2 3. Alcance ......................................................................................................................... 3 4. Antecedentes. ............................................................................................................ 4 5. Normas y referencias .............................................................................................. 6 5.1 Disposiciones legales y normas aplicadas. ........................................................ 6 5.2 Bibliografía. .................................................................................................................. 6 5.3 Programas. .................................................................................................................... 7

6. Definiciones y abreviaturas. ................................................................................. 8 7. Análisis de soluciones. ......................................................................................... 10 7.1 Comparativa de soluciones para la placa interfaz. ....................................... 10 7.1.1 Análisis de la plataforma Atmel AVR .......................................................................... 10 7.1.2 Análisis de la plataforma Microchip PIC. ................................................................... 11

7.2 Análisis de soluciones para la estructura del autómata alternativo. ..... 12 7.3 Análisis del protocolo de comunicaciones CAN. ............................................ 15 7.3.1 Elementos que componen el sistema CAN Bus. ...................................................... 16 7.3.2 Proceso de transmisión de datos. ................................................................................. 17 7.3.3 Mensajes y tipos de tramas. ............................................................................................ 18 7.3.4 Formato de tramas. ............................................................................................................. 19 7.3.5 Errores en la comunicación. ........................................................................................... 22

8. Resultados finales. ................................................................................................ 24 8.1 Descripción del hardware. ................................................................................... 24 8.1.1 Placa principal (CPU). ........................................................................................................ 24 8.1.2 Módulos de entrada/salida. ............................................................................................ 27

8.2 Descripción del software. ..................................................................................... 39 8.2.1 Programación formulario Zonas. .................................................................................. 39 8.2.2 Programación del formulario Paso1. .......................................................................... 41 8.2.3 Programación del formulario Controles. ................................................................... 49 8.2.4 Manual de usuario del panel SCADA. .......................................................................... 86

8.3 Descripción de las comunicaciones. .................................................................. 98

9. Posibles vías de ampliación. ............................................................................... 135

Controlador modular programable basado en procesador de 32 bits y CAN bus

Memoria. 1

1. Introducción.

• TITULO: “Controlador modular programable basado en procesador de 32 bits y CAN bus”

• EMPLAZAMIENTO: Escuela de Enseñanzas Científicas y Técnicas de la Universidad de La Rioja.

• PETICIONARIO: Universidad de La Rioja. • AUTOR DEL PROYECTO.

Alberto Martínez Inchusta. Razón Social: Logroño (La Rioja) Director del Proyecto: Javier Esteban Vicuña Martínez, profesor del departamento de Ingeniería Eléctrica de la Universidad de La Rioja. E-‐mail: [email protected]


Memoria. 2

2. Objeto

El objeto de este proyecto consiste en el diseño hardware de un controlador lógico programable (PLC), basado en microcontrolador de 32 bits, escalable modularmente por medio de CAN bus y compatible con plataforma ARDUINO, que cuente con prestaciones técnicas equiparables a las de los PLC´s industriales básicos, y también el desarrollo de una aplicación software de código abierto, para el desarrollo de aplicaciones de control y monitorización industrial, como alternativa abierta de bajo coste.

Partiendo de que una de las principales premisas es obtener una solución económica, dicho software de supervisión, no requiere de la compra de ninguna licencia para el usuario, más adelante se explicará de manera detenida como se ha llevado a cabo y se entenderá el porqué de esta cualidad tan ventajosa.

Así mismo, como la placa del microcontrolador elegida no trabaja con los niveles requeridos en el ámbito industrial, se deberá confeccionar una placa de potencia que nos permita adaptar estos niveles a cualquier planta industrial.

Otro de los objetos del presente proyecto es dotar al equipo de control alternativo de la mayor modularidad, para ello se empleará el CAN bus que permitirá ir añadiendo al autómata nuevos módulos (placas microcontroladoras).

Como se desprende de las líneas anteriores, con este proyecto se va a

conseguir una alternativa fiable a los autómatas programables, tanto a nivel económico como técnico, ya que el microcontrolador de 32 bits elegido junto con la placa de potencia que le acompaña, están a la altura de cualquiera de los PLC´s actuales tanto en coste como prestaciones técnicas.

Así mismo, el software de supervisión SCADA desarrollado que se facilita al

usuario, le permitirá realizar todas las labores de control y supervisión necesarias para tener el dominio absoluto sobre la planta y todo ello a coste cero, sin la necesidad de adquirir licencias propietarias del fabricante del autómata.


Memoria. 3

3. Alcance

Se trata de un proyecto de diseño industrial de un sistema prototipo y comprende las etapas de diseño electrónico, diseño de tarjetas PCB, comunicaciones y software de programación de tarjetas chipKIT, junto con el diseño de software de supervisión a través de lenguaje de programació visual, así como su posterior puesta en marcha e integración en las comunicaciones creadas y diseñadas (Puerto USB y CAN Bus).

Dada la extensión del proyecto, y los medios disponibles en el departamento, quedan fuera del alcance del mismo la realización física de las tarjetas electrónicas diseñadas para el prototipo, que se encargarían a una empresa especializada.

La solución integral de control y supervisión a implementar, es un sistema innovador en la medida que se está trabajando con los componentes electrónicos más novedosos, lo que permite al usuario obtener un producto de tamaño reducido con unos tiempos de procesamiento de datos muy altos.

Dicha solución permite disponer en todo momento de información referente al funcionamiento y rendimiento de las instalaciones, así como de las posibles anomalías que puedan producirse.


Memoria. 4

4. Antecedentes.

PLC son las iniciales de Programmable Logic Controller, que traducido resulta Controlador Lógico programable. También puede ser usado el término Autómata programable para referirse a este tipo de dispositivos. A lo largo de este documento se usará indistintamente cada uno de estos términos.

Hace algunos años las soluciones de automatización que se podían encontrar en el mercado pasaban indefectiblemente por el uso de tecnologías cableadas incluyendo relés electromecánicos o módulos lógicos neumáticos entre otros. El uso de esta tecnología resultaba muy caro y voluminoso.

A finales de la década de los años 60, consciente de estos problemas, la General Motors encarga el diseño de equipos que cumplieran las siguientes especificaciones:

• Flexibles: Debían adaptarse a una gran variedad de situaciones. • Estado sólido: Los nuevos equipos debían estar realizados usando

componentes electrónicos. • Ambiente: Debían poder soportar los ambientes industriales. • Sencillos: Debían poder ser programados por personas sin

conocimientos informáticos. • Lógicos.

La aparición de los PLC´s o autómatas programables, supuso una revolución en este mundo, permitiendo la posibilidad de almacenar una secuencia de órdenes en su interior y ejecutarlo de forma cíclica con el fin de realizar una tarea. El impulso inicial es pensar que se trata de un PC, pero existen múltiples diferencias entre ambos, ya que el PLC está diseñado para trabajar en ambientes industriales y ejecutar su programa de forma indefinida siendo menos propenso a fallos que un ordenador convencional. Además, su programación está más orientada al ámbito electromecánico, incluso existen lenguajes que simulan el comportamiento de un sistema de relés y temporizadores.

La generalización del uso de estos PLC ha conllevado la diversificación de los modelos existentes en el mercado. Hoy en día los equipos son capaces de realizar complicadas operaciones, incluso en coma flotante, privilegio disponible hasta hace poco sólo en equipos muy costosos. Además, cada vez es más usual que los autómatas de gama baja sean capaces de gestionar un gran número de entradas y salidas, analógicas o digitales, así como controlar varios encoders por poner un ejemplo.

Esta diversificación en los autómatas hace que cada vez se vea más abierto los campos de aplicación de estos, así como las tecnologías de las que se nutre para llevar a cabo su propósito.


Memoria. 5

En el punto en que se encuentra el mundo de la automatización, lleva a definir el presente proyecto, como un proyecto de fusión de conocimientos que permitan dar luz verde a un sistema de control de bajo coste, con las mismas prestaciones que los actuales autómatas programables. Demostrando que existen alternativas al PLC convencional a la hora de realizar el control sobre distintos procesos industriales.


Memoria. 6

5. Normas y referencias 5.1 Disposiciones legales y normas aplicadas.

5.2 Bibliografía.

Para la realización del presente proyecto, se ha necesitado acudir a diversas fuentes en busca de información acerca de las diferentes áreas que engloba este proyecto.

A continuación, se enumerarán las distintas fuentes consultadas:

Páginas Web.

• http://msdn.microsoft.com/en-‐us/library/ms950417.aspx • http://www.elguille.info/vb/Libros. • http://www.digilentinc.com/ • http://www.arduino.cc/ • http://es.farnell.com/ • http://www.analog.com/en/index.html • http://www.fairchildsemi.com • http://www.ti.com/ww/en/analog/overview/index.shtml • http://www.national.com • http://www.onsemi.com • http://www.avagotech.com/pages/home/ • http://www.comchiptech.com • http://www.can-‐cia.org/

Apuntes.

• Apuntes de la asignatura “Automatización Industrial Avanzada”. • Apuntes de “Electrónica analógica”.

Libros.

• Microcontroladores PIC: sistema integrado para el autoaprendizaje.


Memoria. 7

5.3 Programas.

• Visual basic studio 6.0 • Compilador de chipKIT. • Microsoft Office. • kiCAD • Top Solid • Photoshop • Autocad • Fritzing • VMware Fusion • Wings3D 1.4.1 • MWSnap • Proteus 7.2 Portable


Memoria. 8

6. Definiciones y abreviaturas.

Definiciones.

• Bus CAN: protocolo de comunicaciones desarrollado por la firma alemana Robert Bosch GmbH, basado en una topología bus para la transmisión de mensajes en entornos distribuidos.

• Código abierto: es el término con el que se conoce al software distribuido y desarrollado libremente. El código abierto tiene un punto de vista más orientado a los beneficios prácticos de poder acceder al código, que a las cuestiones éticas y morales las cuales se destacan en el software libre.

• Archivo .dll: Bibliotecas de vínculos dinámicos. • Microcontrolador: es un circuito integrado programable, capaz de

ejecutar órdenes grabadas en su memoria. Está formado por la unidad central de procesamiento, memoria y periféricos de entrada y salida.

• Framework: Es un conjunto estandarizado de conceptos, prácticas y criterios para enfocar un tipo de problemática particular, que sirve como referencia para enfrentar y resolver nuevos problemas de índole similar.

• Bit: Es la unidad mínima de información empleada en informática, capaz de representar dos estados, verdadero o falso, activado o desactivado.

• Byte: Unidad de información formada por 8 bits. • Core: Parte principal de los microcontroladores y microprocesadores

que se encarga de todo el procesamiento. Está formado por los registros, la unidad de control, la unidad aritmético lógica y los buses.

• Compilador: Programa informático que traduce el código fuente escrito en un lenguaje de programación a otro lenguaje de programación de menor nivel, generando un programa equivalente que la máquina sea capaz de interpretar. Normalmente al lenguaje al que se compila suele ser a lenguaje máquina.

• DIP: Empaquetado en el que se pueden fabricar los chips, consistente en dos filas paralelas de pines distribuidas a lo largo del empaquetado y con una separación de 0,1 pulgadas entre ellos.

• Shield: En el mundo relacionado con Arduino, se refiere a la placa que se conecta encima de éste para ampliar sus capacidades tanto de procesamiento, como de control o interfaz.

• Bootloader: Porción de código almacenado en una zona especial de la flashdel microcontrolador que le permite ejecutarse en cada inicio. Normalmente es utilizado para poder programar el microcontrolador a través del puerto serie en vez de con un programador especializado.


Memoria. 9

Abreviaturas.

• CAN : Controller área Network. • PIC: Peripheral interface Controller. • H: High • L: Low • ACK: Acknowledgement. • USB: Universal Serial Bus. • SCADA: Supervisory Control And Data Acquisition • PLC: Programmable Logic Controller


Memoria. 10

7. Análisis de soluciones. 7.1 Comparativa de soluciones para la placa interfaz.

La interacción con el mundo físico se realizará a través de un microcontrolador con una cantidad aceptable de pines disponibles para el uso del cliente, salidas PWM, entradas digitales y analógicas, temporizadores, etc. que ofrezcan un gran abanico de posibilidades.

Dichas placas electrónicas deberán reunir una serie de posibilidades, tales como:

• Alta disponibilidad por parte de los distribuidores a nivel mundial. • Así mismo, es interesante que dichos componentes electrónicos no se

encuentren en proceso de descatalogación o que sean susceptibles en un corto plazo de ser descatalogados.

• Precio reducido, incluso en bajas cantidades, con una relación funcionalidad/precio alta.

• Baja cantidad de electrónica adicional necesaria para el funcionamiento del microcontrolador.

7.1.1 Análisis de la plataforma Atmel AVR La arquitectura AVR, perteneciente a Atmel, es de 8 bits y fue diseñada

desde el comienzo para una eficiente ejecución de código C compilado.

ARDUINO.

Dicha arquitectura ha sufrido un incremento en popularidad como consecuencia del lanzamiento de la plataforma Arduino, lo que garantiza una gran cantidad de documentación, ejemplos de código y una comunidad de usuarios densamente poblada.

Arduino puede entenderse como un conjunto de librerías que facilitan en gran medida el desarrollo en la plataforma AVR, las cuales presentan una gran facilidad de uso.

Así mismo, Arduino también es una sencilla placa de desarrollo, que puede encontrarse en cualquier distribuidor de electrónica del mundo debido a su gran popularidad. Su precio alterna entre los 18 o 26 euros según modelo y distribuidor.

Una de las ventajas más destacadas y la razón por la que Arduino eligió la plataforma AVR, es la existencia del compilador libre basado en GCC denominado avr-‐gcc.


Memoria. 11

Ventajas • Compilador libre y gratuito. • Gran comunidad de usuarios y cantidad de información gratuita.

Desventajas • Precio.

7.1.2 Análisis de la plataforma Microchip PIC.

Microchip con su familia de microcontroladores PIC, ha estado liderando el mercado del desarrollo de proyectos personales a través del programa de muestras de Microchip. Sus compiladores junto con las librerías, son gratuitos o en algunos casos poseen un límite de compilación, sin embargo, poseen licencias con cláusulas que dificultan la distribución del código fuente en según qué casos.

PINGÜINO.

Pingüino nace como consecuencia de la idea de una serie de desarrolladores de portar las librerías Arduino a la arquitectura PIC. Aunque funcionales, estas librerías no presentan el mismo nivel de desarrollo ni de fiabilidad que las de Arduino. Sin embargo, continuando con el programa de muestras Microchip, consiguió formar una sólida base de usuarios.

chipKIT.

De una colaboración entre Digilent y la propia Microchip nace chipKIT, la alternativa real a Arduino, consiguiendo portar con fiabilidad las liberías de Arduino e intentando mantenerlas a la par con respecto a estas.

Una de los problemas que se planteaban, estaba en la línea del compilador, ya que aunque el entorno de desarrollo era el mismo que el de Arduino, su compilador poseía el inconveniente de no ser libre al seguir usando los propietarios ya existentes. Más tarde, como solución a este problema, se liberó parte del compilador para su uso con las placas chipKIT.

Sin embargo, como gran ventaja, chipKIT posee un microcontrolador de 32 bits, lo que posibilita realizar aquellos trabajos que requieren una gran cantidad de procesamiento con respecto al micro de 8 bits de Arduino.

Ventajas • Microcontrolador de 32 bits. • API exactamente igual que la de Arduino. • Provee de dos controladores CAN

Desventajas • Compilador no libre del todo. • Pequeña comunidad de usuarios.


Memoria. 12

7.2 Análisis de soluciones para la estructura del autómata alternativo.

La estructura interna de los autómatas programables puede ser descrita en cinco bloques:

El bloque de entradas, es el encargado de recibir las señales procedentes de los sensores. Además, estas señales deberán de ser adaptadas para su comprensión por parte de la CPU. También tiene como misión proteger los circuitos internos del PLC.

Por su parte, el bloque de salidas es un concepto inverso al anterior, de manera que su misión es interpretar las órdenes de la CPU, descodificarlas, amplificarlas y enviarlas a los actuadores.

La CPU, puede definirse como la unidad en la que reside la inteligencia del sistema, de forma que en base a las instrucciones programadas y el valor de las entradas, activa las salidas.

Así mismo, cualquier PLC requiere de una fuente de alimentación que sea capaz de adaptar las tensiones a los valores necesarios para los dispositivos electrónicos internos.

Por último, nombrar a los interfaces, que son los canales de comunicación con el exterior.

Figura 1) Estructura de los autómatas convencionales.

Partiendo de la estructura interna que presentan los autómatas programables convencionales, se plantean tres soluciones posibles para el equipo de control alternativo del presente proyecto. En primer lugar se enumerarán cada una de ellas y posteriormente se pasará a realizar un análisis más profundo.

La primera propuesta y la más sencilla de implementar, estaría basada en una placa de desarrollo chipKIT MAX32, en la que se delimitarían el número de entradas y salidas tanto digitales como analógicas, emulando así a los autómatas compactos.


Memoria. 13

En segundo lugar, de nuevo se partiría de una única placa de desarrollo chipKIT MAX32, sin embargo, en este caso la placa de potencia se diseñaría bajo una idea de autómata modular (aunque no en el sentido amplio de la palabra), dando al usuario la posibilidad de decidir el número de entradas analógicas o digitales que desee, así como el tipo de cada una de ellas.

En la tercera solución, es cuando se plantea un diseño plenamente modular, en la que se utilizarían tantas placas de desarrollo chipKIT MAX32 como el usuario desee o necesite para llevar a buen puerto su instalación industrial.

Como se ha citado al principio, en esta primera parte del análisis únicamente se está realizando una enumeración y será en la parte posterior cuando el lector comprenda mejor cada una de las propuestas.

PRIMERA PROPUESTA.

Esta primera solución, es una idea muy primitiva pero eficaz, basada en una placa chipKIT 32MAX, la cual aporta una gran cantidad de pines, en concreto, 16 entradas analógicas, 5 salidas digitales y 57 entradas/salidas digitales.

De manera que el diseñador delimitaría el número de entradas y salidas que poseería el equipo de control, obteniendo como resultado un elemento estanco, cuyo inconveniente principal aparecería en el supuesto caso de que el usuario necesitaría simplemente una entrada digital más que las dispuestas, lo que haría desechar la opción de uso de este tipo de dispositivos de control.

Por lo tanto, en caso de tomar la decisión de diseñar bajo estas premisas, se estaría limitando el campo de aplicación de estos dispositivos de control, a aquellas instalaciones que no superarían el número de entradas y salidas ofertadas.

De hecho, este es el único inconveniente a esta solución, ya que si se analiza la capacidad del microprocesador, se observa que con esos tiempos de procesamiento se puede dar respuesta a cualquier tipo de proceso a controlar. Además, con el mero hecho de seleccionar los componentes electrónicos oportunos (de la placa de potencia) para igualar los tiempos de conmutación de los PLC convencionales, estaríamos ante una gran solución al problema del presente proyecto.

Además, con esta disposición se tienen los cinco bloques principales de los autómatas programables en una placa de un tamaño mucho más reducido que el de los autómatas programables estándar.

SEGUNDA PROPUESTA.

La segunda opción también requiere de una única placa de desarrollo chipKIT 32MAX, a la que como se dijo en la primera parte de este análisis se le pretende conferir el mayor grado (dentro de las posibilidades que ofrece esta disposición) de adaptabilidad para el usuario.


Memoria. 14

Para ello, la placa de potencia se debería diseñar de tal manera, que exista una placa principal, la cual posea una serie de zócalos en los que se insertarían los diferentes módulos de entradas y salidas.

Estos módulos de entradas y salidas, serían placas secundarias que poseerían una cantidad concreta de entradas o salidas, emulando a los módulos de entradas y salidas que se pueden adquirir a cualquier fabricante de autómatas.

De esta manera, se tendría la placa principal unida a la chipKIT 32MAX y posteriormente se le irían incluyendo placas secundarias en función de las necesidades del usuario.

Con esto se obtiene una solución mucho más modulable que la anterior, sin embargo, el problema principal que se presentaba en la primera propuesta sigue sin subsanarse.

TERCERA PROPUESTA.

Es con esta tercera propuesta con la que se elimina el problema que aparece a lo largo de este análisis. Esto se consigue dotando a esta tercera solución de la cualidad de modulable en el sentido amplio de la palabra.

Para ello se requiere de varias placas de desarrollo chipKIT 32MAX, en concreto como mínimo serán necesarias dos chipKIT. La primera de ellas realizará las labores de la CPU, y la otra emulará a los bloques de entradas y salidas de los autómatas convencionales.

Es decir, la primera placa (CPU), albergará el programa de control, así como las instrucciones necesarias para controlar las distintas comunicaciones y las posteriores placas, serán idénticas a las descritas en la segunda propuesta, pudiendo añadir tantas placas como se quiera (en función de las necesidades del cliente), por lo que obviamente con esta nueva disposición se evita el problema del límite de entradas/salidas.

Figura 2) Estructura del autómata alternativo.


Memoria. 15

Esta solución parece la más correcta y así lo es, sin embargo complica mucho más la labor del diseñador, ya que requiere de un enlace de comunicación entre las diferentes placas, que se pasará a analizar en el siguiente punto.

7.3 Análisis del protocolo de comunicaciones CAN.

El protocolo de comunicaron CAN (Controller Area Network) fue desarrollado en los años 80 para resolver problemas de comunicación entre los diferentes sistemas de control de los coches. Debido a su robustez, la idea no tardó en pasar al sector de la automatización y control.

El CAN bus es un protocolo serie asíncrono del tipo CSMA/CD. Al ser CSMA, cada nodo de la red debe monitorizar el bus y si detecta que no existe actividad, puede enviar un mensaje. Así mismo, al ser CD, si dos nodos de la red comienzan a transmitir a la vez un mensaje, ambos detectan la colisión, dicho problema se resuelve mediante el uso de las prioridades que más tarde se explicarán.

El medio físico que permite la circulación de la información entre los distintos nodos, es un par de cables trenzados. La impedancia característica de la línea es del orden de 120 ohmios, por lo que se emplean resistencias de este valor en ambos extremos del bus para evitar ondas reflejadas y que el bus se convierta en una antena. Este bus tiene una longitud máxima de 1000 metros a 40 Kbps, con una velocidad máxima de 1Mbps a 40 metros.

Entre los distintos nodos circulan paquetes de ceros y unos con una longitud limitada y con una estructura definida en campos que conforman el mensaje. Uno de estos campos identifica el tipo de dato que transporta, así como la unidad que lo transmite y la prioridad para transmitirlo con respecto a otros. En realidad, el mensaje no va direccionado a ninguna unidad de mando en concreto, sino que cada una de ellas deberá ser capaz de reconocer mediante el identificador si el mensaje le interesa o no.

Todas las unidades de la red pueden ser transmisoras y receptoras, y el número de módulos conectados es variable, en función de las necesidades de la instalación. Como ya se ha dicho anteriormente, si no se cumple la condición de que el bus este libre, el módulo no podrá introducir un mensaje en el bus. En el supuesto caso, de que dos módulos intenten transmitir, el conflicto se resolverá mediante las prioridades, que están marcadas por el identificador. De tal manera, que aquel nodo con el identificador más bajo, será el que mayor prioridad tenga para transmitir.

Obviamente, el sistema está dotado de una serie de mecanismos que aseguran que el mensaje es transmitido y recibido correctamente. En el momento que un mensaje presenta un error, es anulado y vuelto a transmitir de manera automática. Así mismo, en caso de que un nodo presente problemas, lo comunica al resto de integrantes de la red, si la situación no se soluciona, este nodo se verá excluido de la comunicación, pero esto no significa que la red no siga funcionando.


Memoria. 16

Este protocolo se encuentra estructurado de acuerdo con el modelo OSI en una arquitectura de dos capas, la capa física y la capa de enlace de datos. El resto de capas del modelo OSI (red, transporte, sesión, presentación y aplicación) no están especificadas pero hay que diseñarlas. Sobre todo es de vital importancia especificar un protocolo de alto nivel (HLP).

Entre las características principales del bus CAN, aparecen algunas como:

• Priorización del mensaje. • Comunicación basada en mensajes y no en comunicaciones. • Garantía de los tiempos de retardo. • Flexibilidad de la configuración. • Recepción múltiple con tiempos de sincronización. • Robustez en sistemas de amplios datos. • Sistema multimaestro. • El límite de nodos, lo marca el hardware.

7.3.1 Elementos que componen el sistema CAN Bus.

Cables.

La información circula a través de dos cables trenzados que unen los diferentes nodos que conforman el sistema. Esta información es transmitida por diferencia de tensión entre ambos cables, de tal manera que un valor alto de tensión representa un uno y un valor bajo de tensión representa un cero. La combinación de unos ceros, forman las tramas que circulan a lo largo de la red.

En un cable los valores de tensión oscilan entre 0 y 2,25 voltios, por ello es denominado como cable L (Low). En el otro cable, los valores de tensión son superiores (entre 2,75 y 5 voltios), por lo que se denomina H, del acrónimo de High. En el supuesto caso de que se interrumpa la línea H o se derive a masa, el sistema trabajara con la señal L con respecto a masa, en el caso de interrumpirse la línea L, sucedería lo contrario.

Figura 3) Par trenzado.

Elementos de cierre o terminador.

Físicamente estos elementos son unas resistencias, que se colocan en los extremos de los cables H y L. Sus valores son habitualmente de 120 ohmios y se colocan con el objetivo de adecuar el funcionamiento del sistema a diferentes longitudes de cables y número de módulos conectados, ya que impiden posibles efectos parásitos que pueden corromper el mensaje.


Memoria. 17

Figura 4) Cierre o terminador.

Controlador.

Es el elemento encargado de la transmisión entre el microprocesador del módulo y el transmisor-‐receptor. Trabaja acondicionando la información que entra y sale entre ambos componentes.

Existirá un controlador por nodo, y entre sus labores principales se encuentra la determinación de la velocidad de los mensajes, así como la sincronización entre los diferentes módulos para la correcta emisión y recepción de los mensajes.

Figura 5) Controlador.

Transmisor/Receptor.

El transmisor-‐receptor es el elemento que tiene como misión recibir y transmitir los datos, además de acondicionar y preparar la información para que pueda ser utilizada por los controladores. Esta preparación consiste en situar los niveles de tensión de forma adecuada, amplificando la señal cuando la información se vuelca en la línea y reduciéndola cuando es recogida de la misma y suministrada al controlador.

7.3.2 Proceso de transmisión de datos.

Como ya se ha descrito más arriba, el CAN bus está orientado hacia el mensaje y no al destinatario. La información que circula por el par trenzado es transmitida en forma de mensajes estructurados, de tal manera que una parte del mismo es un identificador que establece la clase de dato que contiene. Por su parte, cada uno de los módulos reciben el mensaje, lo filtran y únicamente lo emplean aquellos que necesitan dicho dato.

Obviamente, cada uno de estos módulos es capaz de introducir como de recoger mensajes. Así mismo y sin ánimo de ser repetitivo, destacar que en el caso de que el bus este libre, cualquier módulo puede comenzar a transmitir. Este proceso de transmisión de datos requiere del desarrollo de varios pasos que serán explicados a continuación.


Memoria. 18

Suministro de datos.

Un módulo recibe información de los sensores que tiene asociados y posteriormente su microprocesador pasa la información al controlador donde es gestionada y preparada para ser pasada al transmisor-‐receptor donde se traducirá en señales eléctricas.

Transmisión de datos.

El controlador de los módulos transfiere los datos, el identificador y la petición de inicio de transmisión, con el objetivo de transmitir de manera correcta el mensaje a lo largo de la red.

Para conseguir el citado objetivo, el bus debe de encontrarse libre y en el hipotético caso, de encontrarse en conflicto con otro módulo, ha de tener mayor prioridad.

Una vez logrado el objetivo, el resto de nodos se convierten en receptores a la espera del mensaje, siempre y cuando este les sea de interés.

Recepción del mensaje.

Cuando todos los módulos se posicionan en estado de escucha, reciben el mensaje y a continuación verifican el identificador con el objetivo de determinar si el mensaje va a ser utilizado por ellos. De esta manera, aquellos que necesitan el mensaje lo procesan y aquellos que no lo necesitan simplemente lo ignoran.

El protocolo CAN dispone de mecanismos para detectar errores en la transmisión de mensajes, de forma que todos los receptores realizan un chequeo del mensaje analizando una parte del mismo, llamado campo CRC.

7.3.3 Mensajes y tipos de tramas.

Al igual que todas las comunicaciones de este tipo, el mensaje es una sucesión de ceros y unos, que se representan por distintos niveles de tensión en los cables del CAN. CAN utiliza mensajes con una estructura predefinida, que en una jerga más coloquial se conocen como tramas.

Se distinguen dos variantes de tramas CAN, las definidas en CAN estándar y las definidas en el CAN extendido. La diferencia sustancial entre ambas tramas viene impuesta por el número de bits que emplea para el identificador, requiriendo la primera 11 bits y la segunda 29 bits.

Las tramas CAN son de longitud reducida, la más larga es de 130 bits en CAN estándar y 154 bits en CAN extendida. En un bus Can existe la posibilidad de enviar las tramas de una manera automática, ya sea ante la aparición de un suceso o por un proceso realizado durante una cierta frecuencia.


Memoria. 19

La trama de interrogación remota es empleada únicamente para detectar la presencia de módulos o para configuración de información en un módulo recién incorporado a la red.

Las tramas principales que son manejadas en el CAN bus son:

Trama de datos

La que un módulo utiliza normalmente para poner información en el bus. Puede incluir entre 0 y 8 bytes de información útil.

Trama de interrogación remota.

Puede ser utilizada por un módulo para solicitar la transmisión de una trama de datos con la información implicada a un identificador dado. El módulo que disponga de la información definida por el identificador la transmitirá en una trama de datos.

Trama de error.

Se usan para señalar al resto de módulos la detección de cualquier error, impidiendo normalmente el mensaje erróneo

7.3.4 Formato de tramas.

El mensaje se descompone en varios campos de diferentes tamaños, gracias a los cuales es posible llevar a cabo el intercambio de información entre los distintos nodos.

Trama de datos.

Figura 6) Trama de Bus CAN.

Campo de inicio del mensaje. El mensaje se inicia con bit dominante, cuyo flanco descendente es utilizado por los módulos para sincronizarse entre si.

Campo de árbitro. Los 11 bits de este campo se usan como identificador que permite reconocer a los módulos su prioridad. De esta manera, cuanto más bajo sea el valor del identificador más alta es la prioridad, y por lo tanto, determina el orden en que van a ser introducidos los mensajes en la línea. El bit RTR indica si el mensaje contiene datos (RTR = 0) o si se trata de una trama remota sin datos (RTR = 1).

Campo de control. Este campo informa sobre las características del campo de datos. El bit IDE indica cuando es un “0” que se trata de una trama estándar (BasicCAN, 11bits) y cuando es un “1” que es una trama extendida. El segundo bit (RB0) es siempre recesivo. Los cuatro bits que componen el campo DLC indican el número de bytes contenido en el campo de datos (0 a 8).


Memoria. 20

Figura 7) Campo de control.

Campo de datos. En este campo aparece la información del mensaje con los datos que el módulo correspondiente introduce en la línea CAN. Puede contener entre 0 y 8 bytes.

Figura 8) Campo de datos.

Campo de aseguramiento. Este campo tiene una longitud de 16 bits y se utiliza para detectar errores por los 15 primeros, mientras que el último siempre será un bit recesivo para delimitar el campo CRC.

Figura 9) Campo de aseguramiento.

Campo de confirmación (ACK). El campo ACK se compone de dos bits que son siempre transmitidos como recesivos. Todos los módulos que reciben el mismo CRC modifican el primer bit del campo ACK por uno dominante, de forma que le módulo que esta todavía transmitiendo reconoce que al menos un módulo ha recibido un mensaje que se ha escrito correctamente. De no ser así, el módulo transmisor interpreta que su mensaje tiene un error.

Figura 10) Campo de confirmación ACK.

Campo de final del mensaje. Este campo indica el final del mensaje con una cadena de 7 bits recesivos.

Figura 11) Campo de final del mansaje.

Espaciado entre tramas (IFS). Consta mínimo de tres bits.


Memoria. 21

Trama remota.

El formato es idéntico al de la trama de datos, salvo por la diferencia de que el bit RTR es recesivo. Así mismo volver a destacar que una trama remota no incluye datos y que el identificador es el del mensaje que se solicita.

Figura 12) Trama remota.

Trama de error.

Las tramas de error son generadas por cualquier módulo que detecta un error. Consiste en dos campos: Indicador de error ("Error Flag") y Delimitador de error. El delimitador de error consta de 8 bits recesivos consecutivos y permite a los módulos reiniciar la comunicación de nuevo tras el error. El indicador de error varía según el estado de error:

• Si un módulo en estado de error "Activo" detecta un error en el bus interrumpe la comunicación del mensaje en proceso generando un "Indicador de error activo" que consiste en una secuencia de 6 bits dominantes sucesivos. Esta secuencia rompe la regla de relleno de bits y provocará la generación de tramas de error en otros módulos. Por tanto el Indicador de error puede extenderse entre 6 y 12 bits dominantes sucesivos. Finalmente se espera el campo que delimita el error formado por los 8 bits recesivos. Entonces la comunicación se reinicia y el módulo que había sido interrumpido reintenta la transmisión del mensaje.

• Si un módulo en estado de error "Pasivo" detecta un error, el módulo transmite un "Indicador de error pasivo" seguido, de nuevo, por el campo delimitador de error. El indicador de error de tipo pasivo consiste en 6 bits recesivos seguidos y, por lo tanto, la trama de error para un módulo pasivo es una secuencia de 14 bits recesivos. De aquí se deduce que la transmisión de la trama de error de tipo pasivo no afectará a ningún módulo en la red, excepto cuando el error es detectado por el propio módulo que está transmitiendo. En ese caso los demás módulos detectaran una violación de las reglas de relleno y transmitirán a su vez tramas de error.

Tras señalar un error por medio de la trama de error apropiada cada módulo transmite bits recesivos hasta que recibe un bit también recesivo, luego transmite 7 bits recesivos antes de finalizar el tratamiento de error.

Arbitraje.


Memoria. 22

Un módulo transmisor monitoriza constantemente el estado del bus. Durante la transmisión del campo Arbitraje la detección de un bit dominante, cuando el bit transmitido ha sido recesivo, hace que el módulo detenga la transmisión y pase a recepción de trama. Así, no se pierde información y no se destruye por colisión ninguna trama de datos o remota.

En un bus único un identificador de mensaje ha de ser asignado a un solo módulo concreto, es decir, se ha de evitar que dos módulos puedan iniciar la transmisión simultánea de mensajes con el mismo identificador y datos diferentes. La filosofía CAN se basa en que un mensaje es único en el sistema. Las tramas remotas con identificador concreto que puedan ser generadas por cualquier módulo han de coincidir en cuanto al campo longitud + longitud del campo de datos + contenido de estos datos, el mensaje ha de ser único en el sistema y estar asignado a un módulo concreto.

Figura 13) Acceso al bus CAN.

7.3.5 Errores en la comunicación.

Aunque como ya se ha citado anteriormente, los sistemas de seguridad que incorpora CAN bus lo convierten en uno de los protocolos de comunicación más robustos. Puede darse el caso, de que exista algún mal funcionamiento, que requiere un proceso de gestión.

No se utilizan mensajes de ACK, los errores se señalizan cuando ocurren. A nivel de trama hay tres mecanismos posibles: usar CRC, chequeo de formato de trama, y los receptores señalizando las tramas recibidas forzando el bit ACK a dominante, y en caso de que esto no ocurriese, significaría un error en ACK.

A nivel de bit se implementan dos mecanismos, la monitorización, donde el transmisor puede monitorizar el bus para observar si lo que envía es lo que aparece en el bus. Esto detecta errores globales y locales al transmisor, y el bit stuffing. Si se detecta algún error, al menos la estación aborta la transmisión mediante el envío de una trama de error. Tras esta trama, el transmisor reintenta el envío.

Una estación defectuosa podría abortar mensajes correctos, lo que podría bloquear el bus. El protocolo CAN aporta un mecanismo para diferenciar errores esporádicos y permanentes: un análisis estadístico de las situaciones de error. Si una estación detecta un estado permanente de error, entra en un estado de


Memoria. 23

operación que el resto de la red CAN puede seguir funcionando, debiendo poder auto desconectarse para que este mecanismo funcione.


Memoria. 24

8. Resultados finales. 8.1 Descripción del hardware.

En el apartado 7.2 del presente proyecto se planteaban tres posibles soluciones con las que implementar el equipo de control alternativo. Como se deduce de dicho análisis, la tercera solución es la más modulable y por lo tanto la solución a adoptar. Dicha solución esta compuesta por varios elementos que se enumerarán y describirán a continuación:

• Placa principal (CPU), chipKIT MAX32. • Placas secudarias (módulos de entrada/salida) chipKIT 32MAX junto a

sus respectivas placas de potencia.

Figura 14) Estructura hardware del autómata.

8.1.1 Placa principal (CPU).

Dicha placa principal, tendrá como misión coordinadar las comunicaciones y ejecutar ciclicamente el programa de control, de manera que en función de los valores de las entradas y de las variables internas, ordenara activarse las salidas que correspondan. Debido a que no debe leer ni escribir nada por sus pines no requerirá de una placa que adapte sus niveles.

La placa de desarrollo elegida para esta misión es el chipKIT MAX32 que presenta en su interior un PIC de 32 bits altamente capacitado para esta labor. Además, su integración en ambas redes de comunicaciones no requiere de hardware adicional (a excepción del transceiver MCP2551, cuyo coste es despreciable) ya que posee dos controladores de CAN y un puerto USB 2.0.


Memoria. 25

Figura 15) Descripción de todas las patillas del chip (PIC32MX795F512L).

Figura 16) Descripción de las patillas del chipKIT MAX32

1. Conector USB, para convertir de USB serie. 2. Conector de herramientas de depuración de microchip. 3. Conector de alimentación externa. 4. Fuente de alimentación (regulador de 3,3 V). 5. Puente de selección de alimentación. 6. Fuente de alimentación (regulador de 5 V). 7. J2 Conector shield. 8. Microcontrolador principal de la placa PIC32. 9. J5, J7 conectores de señal analógica. 10. J6, J8, J9 y J15 señal digital y alimentación. 11. LED de usuario. 12. JP3/JP4 Selección de puente maestro/esclavo SPI. 13. J13 conector de señal SPI. 14. J3, J4, J14 conector de señal digital.


Memoria. 26

15. Estado comunicaciones LED. 16. Botón RESET.

Algunas de las características más destacables son:

Reloj: Ofrece varias opciones de configuración de la frecuencia de oscilación, permitiendo al usuario escoger según se adapte a sus necesidades:

• Utilizando un cristal o un resonador cerámico y conectándolos a los pines

• OSC1 y OSC2 del PIC. • El sistema de oscilador tiene las siguientes características: • Como fuente oscilador de reloj tiene cuatro opciones internas y

externas. • En el chip tiene un interruptor que manipula el usuario de divisor y

multiplicador de entrada y también un divisor de salida para aumentar la frecuencia de operación al seleccionar las fuentes internas y externas.

• Fuente de reloj se puede controlar por software. • A prueba de fallos, detecta los fallos de reloj y permite la recuperación

de aplicaciones de seguridad. • El modulo del oscilador se compone de unos registros de funciones

especiales:

-‐ OSCCON: registro de control del oscilador.

-‐ OSCTUN: registro de ajuste de FRC

-‐ REFOCON: registro de control de la referencia del oscilador.

-‐ REFOTRIM: registro de trim de la frecuencia del oscilador.

• También tenemos los registros de configuración del dispositivo

-‐ DEVCFG1: Palabra de configuración de dispositivo 1.

-‐ DEVGFG2: Palabra de configuración de dispositivo 2.

Memoria de datos: Tiene 128 Kbytes de memoria RAM.

Memoria de programa: Tiene 512 kbytes de memoria Flash.

Periféricos: El Max32 ofrece 83 pines I/O que soportan un número de funciones periféricas, como UART, SPI y puertos I2C y salidas de ancho de pulso modulado. Dieciséis de los pines I/O se pueden utilizar como entradas analógicas o como entradas y salidas digitales.

El microcontrolador PIC32 en el Max32 también proporciona un 10/100 Ethernet MAC, USB 2.0 completo, un regulador de velocidad OTG, y dos controladores CAN. El uso de estos periféricos avanzados requiere una tarjeta


Memoria. 27

adicional (por ejemplo, el Digilent Red Shield) para proporcionar el hardware adicional que se requiere.

El Max32 puede ser alimentado a través de USB y externamente con un adaptador de corriente AC-‐DC o baterías.

8.1.2 Módulos de entrada/salida.

Las placas secundarias son los módulos que aparecen en cada uno de los nodos de la red CAN. Estas placas serán las encargadas de dar órdenes a los actuadores y de obtener a través de sus pines la información que les transmita los sensores. Como consecuencia de su labor, requieren de una placa de potencia que adapte los niveles al ámbito industrial.

La citada placa de potencia presenta dos partes, por un lado una placa principal, la cual posee una serie de zócalos en los que se insertarán los diferentes módulos de entradas y salidas. Estos módulos serán placas secundarias que poseerán una cantidad concreta de pines, emulando a los módulos de entradas y salidas que se puede adquirir a cualquier fabricante de autómatas.

De esta manera, se tendrá la placa principal unida a la chipKIT 32MAX y posteriormente se le irán incluyendo placas secundarias en función de las necesidades del cliente.

Placa principal.

El aspecto de la placa principal es el de la imagen inferior, en ella se pueden observar los distintos zócalos que albergarán los módulos de entradas/salidas, así como los diferentes componentes electrónicos que forman:

• La fuente de alimentación de los módulos. • El hardware de las cinco salidas analógicas. • Los switch para indicar el número de módulo en la red CAN


Memoria. 28

Figura 17) Simulación en 3D de la placa principal que albergará los módulos de entrada/salida junto al chipKIT.

El chipKIT será acoplado a la placa principal a través de los pin head, que se encuentran dispuestos de tal manera que la placa de desarrollo encaje perfectamente.

El esquema electrónico de la fuente de alimentación es el siguiente:

Figura 18) Circuito electrónico de la fuente de alimentación.

Dicho circuito electrónico esta compuesto principalmente por dos reguladores, un LM7815 y un MC7915, que convierten los +/-‐ 24 voltios a +/-‐ 15 voltios. El coste de dicha fuente de alimentación ronda un euro.

El hardware de las salidas analógicas amplifica a 24 voltios las señales de 3.3 voltios que saca el chipKIT. Para ello se empleará el driver FOD8321 dispuesto de la siguiente manera. El coste de las cinco salidas analógicas ronda los cinco euros.


Memoria. 29

Figura 19) Circuito electrónico de una salida analógica.

Placas secundarias.

Existe varios modelos de este tipo de placas, entre las que se encuentran:

• Módulos de cuatro entradas analógicas. • Módulos de siete entradas digitales tipo PNP • Módulos de seis salidas digitales de alta velocidad. • Módulos de salidas de alterna.

Los módulos de cuatro entradas analógicas constan de varios bloques que permiten adaptar los niveles procedentes de los sensores analógicos a los valores con los que trabaja chipKIT. Su precio es el más caro de todos los módulos, rondando los 50 euros. Sin embargo, los componentes con los que ha sido diseñado le permite competir de manera directa en el mercado actual.

A continuación se muestra una visión general del módulo junto con su modelo en 3D.

Figura 20) Simulación en 3D de los módulos de entradas analógicas.


Memoria. 30

Figura 21) Bloques que componen los módulos de entradas analógicas.

Los micro-‐switches que se observan en el modelo en 3D, permiten al usuario seleccionar si el sensor analógico con el que se esta trabajando, aporta una señal de 4-‐20 mA (intensidad) o por el contrario aporta voltajes. Estos pulsadores conmutan el analog-‐switch (ADG 5413), de tal manera que direccionan la señal del sensor hacia el bloque de adaptación de intensidad-‐voltaje o hacia el bloque de reducción de voltajes.

El primero de los bloques convierte los mA en voltios, de tal manera que si aparece en los borneros 4mA el micro recibirá cero voltios y si aparece 20 mA el micro recibirá 3.3 voltios. Este circuito electrónico esta basado en el RCV420KP y presenta la siguiente estructura:

Figura 22) Circuito electrónico que convierte intensidad a tensión.

Por su parte, el segundo de los bloques, convierte los 48 voltios en 3.3 a través de un amplificador inversor. Como en realidad lo que hace este amplificador es pasar de 48 voltios a -‐3.3 voltios, es necesario invertir de nuevo la señal y esto se realiza mediante un transistor.


Memoria. 31

Figura 23) Circuito electrónico que disminuye la tensión hasta 3.3 voltios.

El siguiente analog-‐switch (AD7512 DIKN) comandado por los microswitch a los que se ha hecho referencia más arriba, recogerá la señal o bien del primer bloque o bien del segundo en función de los indicado por el usuario a través de estos elementos. Esta señal adaptada ya a sus niveles de trabajo será la que recibirá el chipKIT.

ENTRADAS ANALÓGICAS Número de Entradas 4 Rango de voltajes de entrada(V) 9÷40 v Retraso de señal a ON 202 ns Retraso de señal a OFF 140 ns Voltaje a salida máximo de estado OFF 0.8 v Voltaje a salida mínimo de estado ON 3.3 v Intensidad máxima de entrada 30 mA Rango de temperaturas -‐25÷85 ºC Precio 50 euros

Figura 24) Especificaciones técnicas de los módulos de entradas analógicas.

La electrónica bajo la que se ha diseñado los módulos de entradas digitales, reduce el voltaje que llega de los sensores (aportando un 0 si aparece menos 5.1 voltios y 3.3 voltios cuando es superior a la cifra anterior) y además, aisla al chipKIT de picos de tensión que podrían destruir la placa de desarrollo. Su precio ronda los siete euros. El circuito electrónico queda de la siguiente manera.

Figura 25) Circuito electrónico que aisla y adapta niveles.


Memoria. 32

Como se observa, el optoacoplador 4N25 es el encargado de aislar la placa chipKIT del medio exterior. El circuito que se encuentra a su izquierda esta formado por dos resistencias, un diodo led y un zener. La misión del zener es regular la tensión entre sus extremos, de tal manera que entre esos dos puntos siempre aparezca 5.1 voltios. Como el optoacoplador únicamente requiere 1.5 voltios para conducir, reparto los 3.8 voltios entre el diodo led y la resistencia.

5.1 = 2.2 + 1.5 + R2 * 10mA à R2 = 140 ohmios

48 = 60mA * R1 + 2.2+ 140 * 10mA + 1.5 à R1 = 715 ohmios

Vout = 5 * R3 / (R5 + R3) à R5 = 5,1 K

A la derecha del optoacoplador la estructura más destacable es una red RC para el filtrado de la señal.

El circuito en su conjunto fue probado en una protoboard y funciona de manera correcta. Se presentan a continuación una serie de imágenes en las que aparece el montaje y las medidas que se realizarón con el osciloscopio.

Figura 26) Comprobando el diseño.


Memoria. 33

Figura 27) Vin=24v Vout =4.8 [etiqueta2(azul)=Vin etiqueta 1(verde)=Vout]

Figura 28) Vin=5.6v Vout =2.67v [etiqueta6(amarilla)=Vout etiqueta 7(azul)=Vin]


Memoria. 34

Figura 29) Vin=4.4v Vout =1.18v [etiqueta8(amarilla)=Vout etiqueta 9(azul)=Vin]

Figura 30) Vin=28v (máximo de la fuente del laboratorio) Vout =4.8 [etiqueta10(amarilla)=Vout etiqueta

11(azul)=Vin]

El aspecto en 3D de los módulos de entradas digitales es el siguiente.


Memoria. 35

Figura 31) Simulación en 3D de los módulos de entradas digitales


Memoria. 36

ENTRADAS DIGITALES Número de Entradas 7 Rango de voltajes de entrada(V) 5.1÷48 v Retraso de señal a ON 2us Retraso de señal a OFF 2us Voltaje a salida máximo de estado OFF 1.2 v Voltaje a salida mínimo de estado ON 5v Intensidad máxima de entrada 60 mA Rango de temperaturas -‐65÷125 ºC Precio 9 euros

Figura 32) Especificaciones técnicas de los módulos de entradas digitales.

Por su parte, la electrónica de los módulos de salidas digitales rápidas es muy sencilla, basándose únicamente en un convertidor de intensidad a voltaje, en concreto el FOD 8321. El funcionamiento de este componente es muy simple, de tal manera que si le llega por la patilla uno entre 10 y 16 mA, sacará por la patilla cinco la tensión que se le coloque en la patilla seis.

Figura 33) Circuito electrónico de las salidas digitales rápidas.

El precio de estos módulos ronda los siete euros y su aspecto simulado es el que se expone a continuación.

SALIDAS DIGITALES RAPIDAS Número de Entradas 6 Rango de voltajes de salida(V) 0÷35 v Retraso de señal a ON 500 ns Retraso de señal a OFF 500 ns Voltaje de entrada máximo 5 v Intensidad máxima de entrada 25 mA Rango de temperaturas -‐40÷100 ºC Precio 7 euros

Figura 34) Especificaciones técnicas de los módulos de salidas digitales rápidas.


Memoria. 37

Figura 35) Simulación en 3D de los módulos de salidas digitales rápidas.

Las interfaces de salidas digital con triac, están basadas en un diodo luminiscente y un triac sensible a la luz (optotriac) que controla a un triac de mayor potencia.

Figura 36) Circuito electrónico de las salidas digitales a triac.

Figura 37) Simulación en 3D de los módulos de salidas digitales a TRIAC.


Memoria. 38

SALIDAS DIGITALES a triac Número de Entradas 6 Rango de voltajes de salida(V) 115÷230

Vac Rango de 1 lógico hasta 1A Intensidad media a la entrada 25mA Voltaje de salida máximo para 1 lógico 3Vp Voltaje de salida máximo para 1 lógico 1.8Vp Rango de temperaturas -‐40÷150 ºC Precio 19 euros

Figura 38) Especificaciones técnicas de las salidas digitales a triac.


Memoria. 39

8.2 Descripción del software.

En las siguientes líneas se procederá a explicar la programación que hace posible la ejecución del panel SCADA, creado para controlar y monitorizar las diferentes variables que se extienden a lo largo de cada uno de los módulos de la red CAN. Así mismo, se aportara a la descripción un manual de usuario de la aplicación.

En primer lugar destacar que la aplicación esta llevada a cabo mediante el

software Visual Basic 6, sin embargo, al usuario/cliente únicamente se le entregará un archivo ejecutable que no requiere instalación alguna, hecho que permite reducir aún más los costes de este autómata alternativo, ya que de esta manera el cliente no tiene que adquirir ningún tipo de licencia para ejecutarla.

La aplicación como se verá más adelante consta de cuatro pantallas o

formularios, una pantalla inicial a modo de presentación, que apenas requiere de programación y que por ello será obviada en esta primera parte de la descripción.

Una segunda pantalla (en VB6 denominada “Zonas”), que será utilizada para cargar la imagen de fondo que el usuario desee y que servirá de plantilla a la hora de crear los controles.

8.2.1 Programación formulario Zonas.

El objetivo que se perseguía en este formulario, era conseguir emular un cuadro de selección con el que designar la zona en la que se quiere colocar la imagen de fondo y posteriormente posicionar a esta.

Para ello se hace uso de una API de Windows que devuelve el valor en pixels

de la posición en la que se encuentra el puntero. A partir de estos datos, cuando se producen los eventos de MouseDown y

MouseUP sobre el formulario, se guarda la posición de la esquina superior e inferior del cuadro de selección. Con estos datos y unas sencillas operaciones de cálculo, se determina el tamaño y posición de la imagen de fondo.

Posteriormente se dimensiona el elemento Image (en base a las medidas

anteriores), que será el contenedor de la imagen de fondo. Para designar dicha imagen de fondo aparecerá una ventana emergente solicitando la ruta (esta operación se realiza a través del elemento CommonDialog). Una vez marcado el directorio, se cargara la imagen sobre el control Image.

Private Sub Form_MouseDown(Button As Integer, Shift As Integer, x As Single, Y As Single) Dim cursorpos As POINTAPI GetCursorPos cursorpos listo = True Xsuperior = cursorpos.x


Memoria. 40

Ysuperior = cursorpos.Y - 26 End Sub Private Sub Form_MouseUp(Button As Integer, Shift As Integer, x As Single, Y As Single) listo = False Dim cursorpos As POINTAPI GetCursorPos cursorpos Xinferior = cursorpos.x Yinferior = cursorpos.Y - 26 Ancho = Xinferior - Xsuperior Alto = Yinferior - Ysuperior 'Paso1.Show 1 Image1.Move Xsuperior, Ysuperior, Ancho, Alto Fondo(0) = Ancho Fondo(1) = Alto Fondo(2) = Xsuperior Fondo(3) = Ysuperior Call menudesp1.activar("Cargue la imagen de fondo.", 3, 2, True, "Cargar") End Sub

A través del evento MouseMove y con el apoyo de la Api de Windows se

podrá ir dibujando un cuadrado, que irá actualizando su tamaño a medida que se desplaza el ratón consiguiendo el efecto de un cuadro de selección típico de Windows.

Private Sub Form_MouseMove(Button As Integer, Shift As Integer, x As Single, Y As Single) Dim cursorpos As POINTAPI GetCursorPos cursorpos If listo = True Then Zonas.Cls Line (Xsuperior, Ysuperior)-(cursorpos.x, cursorpos.Y - 26), vbWhite, BF End If End Sub


Memoria. 41

8.2.2 Programación del formulario Paso1.

La tercera pantalla, denominada en visual basic como “Paso1”, es un formulario que permite crear los diferentes elementos a través de los cuales el usuario podrá interactuar con el proceso.

Figura 39) Formulario de la aplicación SCADA.

Como se puede observar en la imagen superior, el formulario (al que más adelante se verá cómo se accede) presenta dos botones, un botón de agregar y otro de aceptar. El primero incluye el elemento de control en su tabla correspondiente (existe una tabla para los indicadores digitales, otra diferente para los controles digitales, etc). El segundo botón cuando es pulsado dibuja el elemento de control sobre el cuarto formulario, para ello se ayuda de la función LoadPicture, cuya labor es crear un objeto indexado al ya existente.

A continuación se analizará la creación de cada uno de los elementos desde

el punto de vista del botón de Agregar. Creación de controles digitales (Button). Para crear un control digital se tiene que rellenar el formulario como dicta

el manual de usuario, una vez rellenado de forma correcta, la aplicación ya sabe el elemento a generar.

La tabla de los controles digitales presenta los siguientes campos, que posteriormente serán utilizados (tras pulsar el botón Aceptar) para crear el control digital sobre el formulario cuatro.

Indice Valor Ruta Ruta Color Color PIN Estado Color(1) Modulo


Memoria. 42

por defecto

Imagen ON

Imagen OFF

ON OFF Actual Imagen(0)

El campo “Valor defecto” es usado por el botón Aceptar, para poner el

aspecto inicial, así mismo, los cuatro campos siguientes son utilizados en el evento click para cambiar el aspecto en función de lo solicitado por el usuario. Las celdas siete y ocho, son los datos que requiere el chipKIT para poder actualizar las salidas, por lo tanto son datos a enviar junto con la celda diez, que indica el modulo al que pertenece el PIN. Por último, la celda nueve es una celda de apoyo, para saber si se ha pulsado la opción de botón con color o botón animado.

Botón Agregar (correspondiente a la parte de controles booleanos).

If (Option2(1) And Option1(2)) = True Then 'Esto para controles booleanos cantidadBotones = cantidadBotones + 1 Tabla_Control_Dig(cantidadBotones, 1) = cantidadBotones If Option3(0) = True Then Tabla_Control_Dig(cantidadBotones, 2) = 0 Else Tabla_Control_Dig(cantidadBotones, 2) = 1 End If If Option5(0) = True Then Tabla_Control_Dig(cantidadBotones, 9) = 1 Tabla_Control_Dig(cantidadBotones,5) = DialogoColorOn.color Tabla_Control_Dig(cantidadBotones,6)= DialogoColorOFF.color Else Tabla_Control_Dig(cantidadBotones, 9) = 0 Tabla_Control_Dig(cantidadBotones, 3) = BotON.FileName Tabla_Control_Dig(cantidadBotones, 4) = BotonOFF.FileName End If Tabla_Control_Dig(cantidadBotones, 7) = Text5.Text Tabla_Control_Dig(cantidadBotones, 10) = Text10.Text Tabla_Control_Dig(cantidadBotones,8)=

Tabla_Control_Dig(cantidadBotones, 3) datos(Controles.cantidad, 6) = 0 End If ' Label19.Caption = Tabla_Indicador_Dig(cantidadindica, 1) If ((Option1(0) Or Option1(1)) And Option2(0)) = True Then 'Indicadores analógicos cantidadindicanalog = cantidadindicanalog + 1 Tabla_Indicador_Analog(cantidadindicanalog, 1) = cantidadindicanalog Tabla_Indicador_Analog(cantidadindicanalog, 2) = Text6.Text Tabla_Indicador_Analog(cantidadindicanalog, 3) = Text7.Text Tabla_Indicador_Analog(cantidadindicanalog, 4) = 0 Tabla_Indicador_Analog(cantidadindicanalog, 5) = Text5.Text Tabla_Indicador_Analog(cantidadindicanalog, 6) = colorfondo.color Tabla_Indicador_Analog(cantidadindicanalog, 7) = colorprogreso.color


Memoria. 43

Tabla_Indicador_Analog(cantidadindicanalog, 9) = Text8.Text Tabla_Indicador_Analog(cantidadindicanalog, 10) = Text10.Text datos(Controles.cantidad, 6) = 1 End If

Boton Aceptar (Correspondiente a la parte de controles booleanos).

If (Option2(1) And Option1(2)) = True Then 'Esto para controles booleanos If Tabla_Control_Dig(cantidadBotones, 2) = 1 Then 'Has señalado por defecto = ON If Tabla_Control_Dig(cantidadBotones, 9) = 1 Then 'Has señalado Color Controles.mi_imagen(Controles.cantidad).Visible = False Load Controles.Command4(cantidadBotones) Controles.Command4(cantidadBotones).BackColor = Tabla_Control_Dig(cantidadBotones, 5) Controles.Command4(cantidadBotones).Top = Controles.Ys - 26 Controles.Command4(cantidadBotones).Left = Controles.Xs Controles.Command4(cantidadBotones).Width = Controles.Dimx Controles.Command4(cantidadBotones).Height = Controles.Dimy Controles.Command4(cantidadBotones).Visible = True Picture7.Picture = Nothing Picture6.Picture = Nothing Paso1.Hide Controles.Show End If If Tabla_Control_Dig(cantidadBotones, 9) = 0 Then 'Has señalado Imagen Controles.mi_imagen(Controles.cantidad).Visible = False 'cantidadBotones = cantidadBotones + 1 Load Controles.Command4(cantidadBotones) Controles.Command4(cantidadBotones).Picture = LoadPicture(Tabla_Control_Dig(cantidadBotones, 3)) 'Controles.Command4(cantidadBotones).BackColor = Tabla_Control_Dig(cantidadBotones, 5) Controles.Command4(cantidadBotones).Top = Controles.Ys - 26 Controles.Command4(cantidadBotones).Left = Controles.Xs Controles.Command4(cantidadBotones).Width = Controles.Dimx Controles.Command4(cantidadBotones).Height = Controles.Dimy Controles.Command4(cantidadBotones).Visible = True Picture7.Picture = Nothing Picture6.Picture = Nothing Paso1.Hide Controles.Show End If End If If Tabla_Control_Dig(cantidadBotones, 2) = 0 Then 'Has señalado por defecto = OFF If Tabla_Control_Dig(cantidadBotones, 9) = 1 Then 'Has señalado Color Controles.mi_imagen(Controles.cantidad).Visible = False Load Controles.Command4(cantidadBotones) Controles.Command4(cantidadBotones).BackColor= Tabla_Control_Dig(cantidadBotones, 6) Controles.Command4(cantidadBotones).Top = Controles.Ys - 26


Memoria. 44

Controles.Command4(cantidadBotones).Left = Controles.Xs Controles.Command4(cantidadBotones).Width = Controles.Dimx Controles.Command4(cantidadBotones).Height = Controles.Dimy Controles.Command4(cantidadBotones).Visible = True Picture7.Picture = Nothing Picture6.Picture = Nothing Paso1.Hide Controles.Show End If If Tabla_Control_Dig(cantidadBotones, 9) = 0 Then 'Has señalado Imagen Controles.mi_imagen(Controles.cantidad).Visible = False 'cantidadBotones = cantidadBotones + 1 Load Controles.Command4(cantidadBotones) Controles.Command4(cantidadBotones).Picture = LoadPicture(Tabla_Control_Dig(cantidadBotones, 4)) 'Controles.Command4(cantidadBotones).BackColor = Tabla_Control_Dig(cantidadBotones, 5) Controles.Command4(cantidadBotones).Top = Controles.Ys - 26 Controles.Command4(cantidadBotones).Left = Controles.Xs Controles.Command4(cantidadBotones).Width = Controles.Dimx Controles.Command4(cantidadBotones).Height = Controles.Dimy Controles.Command4(cantidadBotones).Visible = True Picture7.Picture = Nothing Picture6.Picture = Nothing Paso1.Hide Controles.Show End If End If End If

Creación de indicadores digitales (Shape). Las directrices para crear un indicador digital son idénticas a las

mencionadas para el elemento de control anterior. En cuanto a la tabla de los indicadores digitales sí que varía y se pasará a analizar a continuación.

Cantidad Ruta

Imagen ON

Ruta Imagen OFF

PIN Estado Actual

Valor por defecto

Modulo ¿Alarma? SIà1 NOà0

Texto alarma

Las tres primeras celdas son usadas en un timer (en el formulario cuatro)

para cambiar la imagen en función del estado del campo cinco. Es decir, si en el campo cinco aparece un uno, la imagen a mostrar será la que se encuentre en la ruta de la celda dos.

La actualización de este “estado actual” será estudiada en el análisis del

formulario cuatro cuando se estudie la comunicación PC-‐chipKIT, ya que este valor proviene de lo que mande codificado el chipKIT a través del puerto USB.

La celda siete, es el módulo al que pertenece el PIN que se encuentra

recogido en el campo cuatro.


Memoria. 45

Por último los campos ocho y nueve permiten la gestión de alarmas en los indicadores digitales. Indicando a través del campo ocho si el usuario requiere alarma y en el campo nueve aparece el texto que el usuario quiere que aparezca.

Botón Agregar. If (Option2(0) And Option1(2)) = True Then 'Esto para

indicadores booleanos cantidadindica = cantidadindica + 1 Tabla_Indicador_Dig(cantidadindica, 1) = Controles.cantidad Tabla_Indicador_Dig(cantidadindica, 2) = DialogON.FileName Tabla_Indicador_Dig(cantidadindica, 3) = DialogOFF.FileName Tabla_Indicador_Dig(cantidadindica, 4) = Text5.Text Tabla_Indicador_Dig(cantidadindica, 6) = Text10.Text If Option3(1) Then Tabla_Indicador_Dig(cantidadindica, 5) = 1 Else Tabla_Indicador_Dig(cantidadindica, 5) = 0 End If datos(Controles.cantidad, 6) = 3 End If

Botón Aceptar. If (Option2(0) And Option1(2)) = True Then 'Esto para

indicadores booleanos If Option3(1) = True Then Controles.mi_imagen(Controles.cantidad).Picture =

LoadPicture(DialogON.FileName) SetLayeredWindowAttributes

Controles.mi_imagen(Controles.cantidad).hwnd, RGB(0, 0, 255), 0, LWA_COLORKEY

Controles.mi_imagen(Controles.cantidad).ScaleMode = 3 Controles.mi_imagen(Controles.cantidad).AutoRedraw = True Controles.mi_imagen(Controles.cantidad).PaintPicture

Controles.mi_imagen(Controles.cantidad).Picture, _ 0, 0, Controles.mi_imagen(Controles.cantidad).ScaleWidth,

Controles.mi_imagen(Controles.cantidad).ScaleHeight Picture1.Picture = Nothing Picture4.Picture = Nothing Paso1.Hide Controles.Show Else Controles.mi_imagen(Controles.cantidad).Picture =

LoadPicture(DialogOFF.FileName) SetLayeredWindowAttributes

Controles.mi_imagen(Controles.cantidad).hwnd, RGB(0, 0, 255), 0, LWA_COLORKEY

Controles.mi_imagen(Controles.cantidad).ScaleMode = 3 Controles.mi_imagen(Controles.cantidad).AutoRedraw = True 'Controles.mi_imagen(Controles.cantidad).PaintPicture

Controles.mi_imagen(Controles.cantidad).Picture, _ '0, 0, Controles.mi_imagen(Controles.cantidad).ScaleWidth,

Controles.mi_imagen(Controles.cantidad).ScaleHeight Controles.mi_imagen(Controles.cantidad).PaintPicture

Controles.mi_imagen(Controles.cantidad).Picture, _ 0, 0, Controles.mi_imagen(Controles.cantidad).ScaleWidth,

Controles.mi_imagen(Controles.cantidad).ScaleHeight


Memoria. 46

Picture1.Picture = Nothing Picture4.Picture = Nothing Paso1.Hide Controles.Show End If End If

Creación de controles analógicos (Slider). La tabla correspondiente a los controles analógicos, contienen un gran

número de datos.

Máximo Mínimo DimX DimY PIN Valor por defecto

Indice Unidad de medida

Slider(0) Text(1)

Modulo

Tanto los controles analógicos como los indicadores son más complejos que

los digitales, ya que requieren un número de datos mayor. Los dos primeros datos, son utilizados para realizar el escalado.

Ejemplo de escalado. Si en la primera celda aparece un 20 y en la segunda un

0, la información que se debe de mandar al chipKIT es un 255 (20 -‐> 255) y un 0 para el mínimo (0 -‐> 0).

Las dos siguientes celdas son empleadas para el aspecto visual del slider

junto con la octava. Los demás campos tienen el mismo cometido que en los controles digitales.

Botón Agregar. If ((Option1(0) Or Option1(1)) And Option2(1)) = True Then

'Controles analógicos cantidadcontrolanalog = cantidadcontrolanalog + 1 Tabla_Control_Analog(cantidadcontrolanalog, 1) = Text6.Text Tabla_Control_Analog(cantidadcontrolanalog, 2) = Text7.Text Tabla_Control_Analog(cantidadcontrolanalog, 3) =

Controles.Dimx Tabla_Control_Analog(cantidadcontrolanalog, 4) =

Controles.Dimy Tabla_Control_Analog(cantidadcontrolanalog, 5) = Text5.Text Tabla_Control_Analog(cantidadcontrolanalog, 6) = 0 Tabla_Control_Analog(cantidadcontrolanalog, 7) =

cantidadcontrolanalog Tabla_Control_Analog(cantidadcontrolanalog, 8) = Text9.Text If Option30 = True Then Tabla_Control_Analog(cantidadcontrolanalog, 9) = 1 Else Tabla_Control_Analog(cantidadcontrolanalog, 9) = 0 End If Tabla_Control_Analog(cantidadcontrolanalog, 10) =

Text10.Text datos(Controles.cantidad, 6) = 2 End If


Memoria. 47

Botón Aceptar. If ((Option1(0) Or Option1(1)) And Option2(1)) = True Then

'Controles analógicos If Option30 = False Then Controles.mi_imagen(Controles.cantidad).Visible = False Load Controles.Pic_slider(Paso1.cantidadcontrolanalog) Controles.Pic_slider(cantidadcontrolanalog).Top =

Controles.Ys - 26 Controles.Pic_slider(cantidadcontrolanalog).Left =

Controles.Xs Controles.Pic_slider(cantidadcontrolanalog).Width = 15 Controles.Pic_slider(cantidadcontrolanalog).Height =

Controles.Dimy Controles.Pic_slider(cantidadcontrolanalog).Visible = True Load Controles.Pic_Barra(Paso1.cantidadcontrolanalog) Controles.Pic_Barra(cantidadcontrolanalog).Top =

Controles.Ys - 26 Controles.Pic_Barra(cantidadcontrolanalog).Left =

Controles.Xs Controles.Pic_Barra(cantidadcontrolanalog).Width =

Controles.Dimx Controles.Pic_Barra(cantidadcontrolanalog).Height =

Controles.Dimy Controles.Pic_Barra(cantidadcontrolanalog).ZOrder

vbBringToFront Controles.Pic_Barra(cantidadcontrolanalog).Visible = True Controles.Pic_slider(cantidadcontrolanalog).ZOrder

vbBringToFront Load Controles.Label2(cantidadcontrolanalog) Controles.Label2(cantidadcontrolanalog).Top = Controles.Ys -

26 + Controles.Dimy + 10 Controles.Label2(cantidadcontrolanalog).Left = Controles.Xs

+ (Controles.Dimx / 2) - 5 Controles.Label2(cantidadcontrolanalog).Width =

Controles.Dimx + 20 Controles.Label2(cantidadcontrolanalog).Height = 25 Controles.Label2(cantidadcontrolanalog).Visible = True Controles.Label2(cantidadcontrolanalog).ZOrder

vbBringToFront Else Controles.mi_imagen(Controles.cantidad).Visible = False Load Controles.Text1(cantidadcontrolanalog) Controles.Text1(cantidadcontrolanalog).Top = Controles.Ys -

26 Controles.Text1(cantidadcontrolanalog).Left = Controles.Xs Controles.Text1(cantidadcontrolanalog).Width =

Controles.Dimx Controles.Text1(cantidadcontrolanalog).Height =

Controles.Dimy Controles.Text1(cantidadcontrolanalog).ZOrder vbBringToFront Controles.Text1(cantidadcontrolanalog).Visible = True Controles.Text1(cantidadcontrolanalog).ZOrder vbBringToFront End If Paso1.Hide


Memoria. 48

Controles.Show End If

Creación de indicadores analógicos (ProgressBar). La tabla de los indicadores analógico requiere el mismo número de campos

que la de los controles.

Índice Máximo Mínimo Valor actual

PIN Color fondo

Color progr

Vertical(0) Horiz (1)

Unidad de medida

Modulo

Alarma SI à1 NOà 0

Texto de alarma

Valor limite

De nuevo los valores “máximo” y “mínimo” son utilizados para realizar el

escalado, que junto al campo cuatro también son utilizados para variar su estado visual en función de lo que mande chipKIT. El resto de campos, son necesarios para poder manejar este tipo de controles en visual basic.

Es en la cuarta pantalla (en VB6 denominada Controles) donde se lleva a cabo todas las operaciones necesarias para la creación de la aplicación SCADA y por lo tanto es el formulario que más programación requiere.

Los tres últimos campos son utilizados por visual basic para generar las

alarmas cuando así se lo indique el usuario. Botón Agregar. If ((Option1(0) Or Option1(1)) And Option2(0)) = True Then

'Indicadores analógicos cantidadindicanalog = cantidadindicanalog + 1 Tabla_Indicador_Analog(cantidadindicanalog, 1) =

cantidadindicanalog Tabla_Indicador_Analog(cantidadindicanalog, 2) = Text6.Text Tabla_Indicador_Analog(cantidadindicanalog, 3) = Text7.Text Tabla_Indicador_Analog(cantidadindicanalog, 4) = 0 Tabla_Indicador_Analog(cantidadindicanalog, 5) = Text5.Text Tabla_Indicador_Analog(cantidadindicanalog, 6) =

colorfondo.color Tabla_Indicador_Analog(cantidadindicanalog, 7) =

colorprogreso.color Tabla_Indicador_Analog(cantidadindicanalog, 9) = Text8.Text Tabla_Indicador_Analog(cantidadindicanalog, 10) =

Text10.Text datos(Controles.cantidad, 6) = 1 End If

Botón Aceptar. If ((Option1(0) Or Option1(1)) And Option2(0)) = True Then

'Indicadores analógicos Controles.mi_imagen(Controles.cantidad).Visible = False Load Controles.ProgressBar1(cantidadindicanalog) If Option4(0) = True Then


Memoria. 49

Controles.ProgressBar1(cantidadindicanalog).Orientation = ccOrientationHorizontal

Tabla_Indicador_Analog(cantidadindicanalog, 8) = 1 Else Controles.ProgressBar1(cantidadindicanalog).Orientation

= ccOrientationVertical Tabla_Indicador_Analog(cantidadindicanalog, 8) = 0 End If Color_Fondo

Controles.ProgressBar1(cantidadindicanalog).hwnd, colorfondo.color Color_Progreso

Controles.ProgressBar1(cantidadindicanalog).hwnd, colorprogreso.color

Controles.ProgressBar1(cantidadindicanalog).Top = Controles.Ys - 26

Controles.ProgressBar1(cantidadindicanalog).Left = Controles.Xs

Controles.ProgressBar1(cantidadindicanalog).Width = Controles.Dimx

Controles.ProgressBar1(cantidadindicanalog).Height = Controles.Dimy

Controles.ProgressBar1(cantidadindicanalog).Visible = True Picture2.Picture = Nothing Picture8.Picture = Nothing Load Controles.Label1(cantidadindicanalog) Controles.Label1(cantidadindicanalog).Top = Controles.Ys -

26 + Controles.Dimy + 10 Controles.Label1(cantidadindicanalog).Left = Controles.Xs -

10 Controles.Label1(cantidadindicanalog).Width = Controles.Dimx

+ 20 Controles.Label1(cantidadindicanalog).Height = 25 Controles.Label1(cantidadindicanalog).Visible = True Controles.Label1(cantidadindicanalog).ZOrder vbBringToFront Paso1.Hide Controles.Show End If

8.2.3 Programación del formulario Controles.

Este formulario es el eje central de la aplicación, sobre el se vertebran diferentes operaciones como, guardar el panel SCADA o cargar uno ya existente. Además, de manera invisible para el usuario, también se lleva a cabo la gestión de la comunicación serie con el chipKIT. Así mismo, se realiza de manera automatica la programación de la CPU o placa principal chipKIT.

Botón de Guardar y Botón de Cargar. El botón Guardar a través de su pulsación permite salvar todo el trabajo ya

realizado sobre el SCADA. El archivo que genera, es del tipo .xlsx es decir un archivo tipo Excel. En el cual se irá guardando celda a celda cada una de las tablas mencionadas anteriormente, de tal manera que cuando se quiera rescatar el trabajo realizado (botón de Cargar), únicamente sea necesario volver a leer este


Memoria. 50

archivo e ir conformando esas tablas. Una vez que VB disponga de esas tablas, trabajará de forma normal y en base a esos datos cargados.

A continuación se muestra la programación que requiere cada uno de los

botones, que como se observa es bastante extensa y nada simple. Por ello, es más didáctico quedarse con la idea general que entrar en detalle en cada una de las líneas de programación.

Programación del botón guardar. Dim oExcel As Object Dim oBook As Object Dim oSheet As Object 'Abre un nuevo libro en excel Set oExcel = CreateObject("Excel.Application") Set oBook = oExcel.Workbooks.Add 'Añade la cabeceras Set oSheet = oBook.Worksheets(1) 'Comienza a pasar los Arrays oSheet.range("A1").Resize(1).Value = Controles.cantidad oSheet.range("A2").Resize(1).Value = Paso1.cantidadBotones oSheet.range("A3").Resize(1).Value = Paso1.cantidadindica oSheet.range("A4").Resize(1).Value =

Paso1.cantidadindicanalog oSheet.range("A5").Resize(1).Value =

Paso1.cantidadcontrolanalog oSheet.range("A6").Resize(40, 6).Value = datos oSheet.range("A" & (CStr(Controles.cantidad) + 6)).Resize(40,

10).Value = Tabla_Control_Dig oSheet.range("A" & (CStr(Controles.cantidad) + 6 +

CStr(Paso1.cantidadBotones))).Resize(40, 6).Value = Tabla_Indicador_Dig

oSheet.range("A" & (CStr(Controles.cantidad) + 6 + CStr(Paso1.cantidadBotones) + CStr(Paso1.cantidadindica))).Resize(40, 10).Value = Tabla_Indicador_Analog

oSheet.range("A" & (CStr(Controles.cantidad) + 6 + CStr(Paso1.cantidadBotones) + CStr(Paso1.cantidadindica) + CStr(Paso1.cantidadindicanalog))).Resize(40, 10).Value = Tabla_Control_Analog

oSheet.range("A" & (CStr(Controles.cantidad) + 6 +

CStr(Paso1.cantidadBotones) + CStr(Paso1.cantidadindica) + CStr(Paso1.cantidadindicanalog) + CStr(Paso1.cantidadcontrolanalog))).Resize(1, 5).Value = Fondo

'Save the Workbook and Quit Excel Guardar.ShowSave oSheet.SaveAs Guardar.FileName oExcel.Quit

Programación del botón Cargar.


Memoria. 51

Dim obj As Object, libro As Object, Hoja As Object Dim Arch As String, Cant As Integer, x As Integer 'Creo un vector de Enteros generico Dim MiVector() As Integer Dim i As Integer Dim j As Integer 'creo nueva instancia de Excel Set obj = CreateObject("Excel.Application") 'Abro el archivo. Uso un ComomDialog Cargar.ShowOpen Arch = Cargar.FileName 'Abro el libro Set libro = obj.Workbooks.Open(Arch) 'referencia la Hoja, por defecto la hoja activa Set Hoja = obj.ActiveSheet 'Escribo en los Arrays Controles.cantidad = Hoja.cells(1, 1) Paso1.cantidadBotones = Hoja.cells(2, 1) Paso1.cantidadindica = Hoja.cells(3, 1) Paso1.cantidadindicanalog = Hoja.cells(4, 1) Paso1.cantidadcontrolanalog = Hoja.cells(5, 1) Fondo(0) = Hoja.cells(6 + Controles.cantidad +

Paso1.cantidadBotones + Paso1.cantidadindica + Paso1.cantidadindicanalog + Paso1.cantidadcontrolanalog, 1).Value

Fondo(1) = Hoja.cells(6 + Controles.cantidad + Paso1.cantidadBotones + Paso1.cantidadindica + Paso1.cantidadindicanalog + Paso1.cantidadcontrolanalog, 2).Value




Image2.Move Fondo(2), Fondo(3), Fondo(0), Fondo(1) Image2.Picture = LoadPicture(Fondo(4)) For i = 1 To Controles.cantidad For j = 1 To 6 datos(i, j) = Hoja.cells(i + 5, j).Value Next Next For i = 1 To Paso1.cantidadBotones For j = 1 To 10 Tabla_Control_Dig(i, j) = Hoja.cells(i + 5 +

Controles.cantidad, j).Value Next Next For i = 1 To Paso1.cantidadindica For j = 1 To 6 Tabla_Indicador_Dig(i, j) = Hoja.cells(i + 5 +

Controles.cantidad + Paso1.cantidadBotones, j).Value


Memoria. 52

Next Next For i = 1 To Paso1.cantidadindicanalog For j = 1 To 10 Tabla_Indicador_Analog(i, j) = Hoja.cells(i + 5 +

Controles.cantidad + Paso1.cantidadBotones + Paso1.cantidadindica, j).Value

Next Next For i = 1 To Paso1.cantidadcontrolanalog For j = 1 To 10 Tabla_Control_Analog(i, j) = Hoja.cells(i + 5 +

Controles.cantidad + Paso1.cantidadBotones + Paso1.cantidadindica + Paso1.cantidadindicanalog, j).Value

Next Next ' Cierro Excel obj.Quit Set obj = Nothing Set libro = Nothing Set Hoja = Nothing 'Cargar las imagenes en el form excel = 1 excelID = 1 excelIA = 1 excelCD = 1 excelCA = 1 While (excel <= Controles.cantidad) Load mi_imagen(excel) mi_imagen(excel).Visible = False mi_imagen(excel).Move datos(excel, 4), datos(excel, 5),

datos(excel, 2), datos(excel, 3) mi_imagen(excel).ScaleMode = vbPixels mi_imagen(excel).Visible = True SetParent mi_imagen(excel).hwnd, 0 SetWindowLong mi_imagen(excel).hwnd, GWL_EXSTYLE,

GetWindowLong(mi_imagen(excel).hwnd, GWL_EXSTYLE) Or WS_EX_LAYERED Or WS_CHILD

SetLayeredWindowAttributes mi_imagen(excel).hwnd, 0, 100, LWA_ALPHA

SetParent mi_imagen(excel).hwnd, Me.hwnd tipo = datos(excel, 6) Select Case tipo Case 0 'Controles Digitales If Tabla_Control_Dig(excelCD, 9) = 1 Then 'Has

señalado Color mi_imagen(excel).Visible = False Load Command4(excelCD) If Tabla_Control_Dig(excelCD, 5) = 1 Then Command4(excelCD).BackColor =

Tabla_Control_Dig(excelCD, 5) Else Command4(excelCD).BackColor =

Tabla_Control_Dig(excelCD, 6)


Memoria. 53

End If Command4(excelCD).Top = datos(excel, 5) - 26 Command4(excelCD).Left = datos(excel, 4) Command4(excelCD).Width = datos(excel, 2) Command4(excelCD).Height = datos(excel, 3) Command4(excelCD).Visible = True End If If Tabla_Control_Dig(excelCD, 9) = 0 Then 'Has

señalado Imagen Controles.mi_imagen(excel).Visible = False Load Command4(excelCD) If Tabla_Control_Dig(excelCD, 5) = 1 Then Command4(excelCD).Picture =

LoadPicture(Tabla_Control_Dig(excelCD, 3)) Else Command4(excelCD).Picture =

LoadPicture(Tabla_Control_Dig(excelCD, 3)) End If Command4(excelCD).Top = datos(excel, 5) - 26 Command4(excelCD).Left = datos(excel, 4) Command4(excelCD).Width = datos(excel, 2) Command4(excelCD).Height = datos(excel, 3) Command4(excelCD).Visible = True End If excelCD = excelCD + 1 Case 1 'Indicadores analógicos mi_imagen(excel).Visible = False Load ProgressBar1(excelIA) If Tabla_Indicador_Analog(excelIA, 8) = 1 Then ProgressBar1(excelIA).Orientation =

ccOrientationHorizontal Else ProgressBar1(excelIA).Orientation =

ccOrientationVertical End If Color_Fondo ProgressBar1(excelIA).hwnd,

Tabla_Indicador_Analog(excelIA, 6) Color_Progreso ProgressBar1(excelIA).hwnd,

Tabla_Indicador_Analog(excelIA, 7) ProgressBar1(excelIA).Top = datos(excel, 5) - 26 ProgressBar1(excelIA).Left = datos(excel, 4) ProgressBar1(excelIA).Width = datos(excel, 2) ProgressBar1(excelIA).Height = datos(excel, 3) ProgressBar1(excelIA).Visible = True Load Controles.Label1(excelIA) Controles.Label1(excelIA).Top = datos(excel, 5) - 26

+ datos(excel, 3) + 10 Controles.Label1(excelIA).Left = datos(excel, 4) -

10 Controles.Label1(excelIA).Width = datos(excel, 2) +

20 Controles.Label1(excelIA).Height = 25 Controles.Label1(excelIA).Visible = True Controles.Label1(excelIA).ZOrder vbBringToFront excelIA = excelIA + 1 Case 2 'Controles analógicos. If Tabla_Control_Analog(excelCA, 9) = 0 Then


Memoria. 54

mi_imagen(excel).Visible = False Load Pic_slider(excelCA) Pic_slider(excelCA).Top = datos(excel, 5) - 26 Pic_slider(excelCA).Left = datos(excel, 4) Pic_slider(excelCA).Width = 15 Pic_slider(excelCA).Height = datos(excel, 3) Pic_slider(excelCA).Visible = True Load Pic_Barra(excelCA) Pic_Barra(excelCA).Top = datos(excel, 5) - 26 Pic_Barra(excelCA).Left = datos(excel, 4) Pic_Barra(excelCA).Width = datos(excel, 2) Pic_Barra(excelCA).Height = datos(excel, 3) Pic_Barra(excelCA).ZOrder vbBringToFront Pic_Barra(excelCA).Visible = True Pic_slider(excelCA).ZOrder vbBringToFront Load Controles.Label2(excelCA) Controles.Label2(excelCA).Top = datos(excel, 5)

- 26 + datos(excel, 3) + 10 Controles.Label2(excelCA).Left = datos(excel, 4)

+ (datos(excel, 2) / 2) - 5 Controles.Label2(excelCA).Width = datos(excel,

2) + 20 Controles.Label2(excelCA).Height = 25 Controles.Label2(excelCA).Visible = True Controles.Label2(excelCA).ZOrder vbBringToFront Else mi_imagen(excel).Visible = False Load Text1(excelCA) Text1(excelCA).Top = datos(excel, 5) - 26 Text1(excelCA).Left = datos(excel, 4) Text1(excelCA).Width = datos(excel, 2) Text1(excelCA).Height = datos(excel, 3) Text1(excelCA).ZOrder vbBringToFront Text1(excelCA).Visible = True End If excelCA = excelCA + 1 Case 3 'indicadores digitales If Tabla_Indicador_Dig(excelID, 5) = 0 Then mi_imagen(excel).Picture =

LoadPicture(Tabla_Indicador_Dig(excelID, 3)) SetLayeredWindowAttributes

mi_imagen(excel).hwnd, RGB(0, 0, 255), 0, LWA_COLORKEY mi_imagen(excel).ScaleMode = 3 mi_imagen(excel).AutoRedraw = True mi_imagen(excel).PaintPicture

mi_imagen(excel).Picture, _ 0, 0, mi_imagen(excel).ScaleWidth,

mi_imagen(excel).ScaleHeight Else mi_imagen(excel).Picture =

LoadPicture(Tabla_Indicador_Dig(excelID, 2)) SetLayeredWindowAttributes

mi_imagen(excel).hwnd, RGB(0, 0, 255), 0, LWA_COLORKEY mi_imagen(excel).ScaleMode = 3 mi_imagen(excel).AutoRedraw = True mi_imagen(excel).PaintPicture

mi_imagen(excel).Picture, _


Memoria. 55

0, 0, mi_imagen(excel).ScaleWidth, mi_imagen(excel).ScaleHeight

End If excelID = excelID + 1 End Select excel = excel + 1 Wend

Botón de Programación de chipKIT. El botón de “programar chipKIT” tiene como objetivo liberar al usuario de

toda programación que no tenga nada que ver con su algoritmo de control, ya que esto último es algo variable en función de la situación en que vaya a emplearse este equipo de control.

De tal manera que las labores que se realizan de manera automática son las

siguientes: • Programación de las comunicaciones vía puerto USB que le permite al

chipKIT estar en contacto con el PC. • Programación de las comunicaciones CAN, así como la gestión de la

configuración de los diferentes módulos que forman la red CAN. • Programación del estado de los pines de los pines del módulo 0, es decir,

de la placa chipKIT principal (CPU). Los dos primeros puntos por su complejidad e importancia serán tratados

en puntos posteriores de forma más extensa. Sin embargo si que se entrará a explicar el tercer punto.

Toda placa chipKIT requiere de una zona de programación en la que se le

diga como va a trabajar cada uno de sus pines (entrada o salida). Esta podría ser labor del usuario, sin embargo, para facilitar el uso de este tipo de placas, es el propio Visual Basic el que genera ese código en función de los datos que tiene en las tablas antes mencionadas. Quedando la programación de esa parte del Sketch de chipKIT de la siguiente manera. Un ejemplo:

// ZONA DE ENTRADAS Y SALIDAS pinMode(10,OUTPUT); //Control analogico analogWrite(10,0); pinMode(1,OUTPUT); //Control analogico analogWrite(1,0); pinMode(0,INPUT); //Indicador analogico pinMode(1,INPUT); //Indicador analogico pinMode(1,INPUT); //Indicador analogico pinMode(1,INPUT); //Indicador analogico pinMode(1,INPUT); //Indicador analogico pinMode(33,INPUT); //Indicador digital pinMode(35,INPUT); //Indicador digital pinMode(39,INPUT); //Indicador digital pinMode(40,INPUT); //Indicador digital pinMode(25,OUTPUT); //Control digital digitalWrite(25,0);


Memoria. 56

Se puede observar en las líneas superiores como los pines 10,1 y 25 quedan

configurados como salidas y los demás como entradas. Cada uno de estos pines corresponderá a un módulo determinado, para saber a que módulo corresponde cada uno de estos pines en líneas posteriores se programará una serie de arrays que contendrán estos datos. Ejemplo.

unsigned int MODULO1_ID[] = {39,0}; // Array de indicadores

digitales del modulo 1 unsigned int PINES_MODULO1_ID[] = {39}; // Array de indicadores

digitales del modulo 1 unsigned int MODULO2_ID[] = {40,0}; // Array de indicadores

digitales del modulo 2 unsigned int PINES_MODULO2_ID[] = {40}; // Array de indicadores

digitales del modulo 2 unsigned int MODULO3_ID[] = {}; // Array de indicadores

digitales del modulo 3 unsigned int PINES_MODULO3_ID[] = {}; // Array de indicadores

digitales del modulo 3 unsigned int MODULO1_IA[] = {1,0}; // Array de indicadores

analogicos del modulo 1 unsigned int PINES_MODULO1_IA[] = {1}; // Array de indicadores

analogicos del modulo 1 unsigned int MODULO2_IA[] = {1,0}; // Array de indicadores


analogicos del modulo 2 unsigned int MODULO3_IA[] = {1,0}; // Array de indicadores


analogicos del modulo 3 unsigned int cantidad =4; // Cantidad de indicadores digitales unsigned int cantidadanalog =5; // Cantidad de indicadores

analogicos unsigned int pines_digi_entrada[] = {33,0,35,0,39,1,40,2}; //

Array de indicadores digitales unsigned int pines_analog_entrada[] = {0,0,1,0,1,1,1,2,1,3}; //

Array de indicadores analogicos

Para liberar al usuario de todo este trabajo, es necesario programarlo de

manera automática mediante visual basic. Las líneas de código que llevan a cabo esta labor son las siguientes.

Private Sub Command3_Click() 'Escribir programación en

chipKIT ' Esta variable contendrá la dirección del archivo al que

queremos acceder Dim Archivo As String Dim Linea As String Dim texto As String Archivo = "C:\Documents and Settings\Administrador\Mis

documentos\Proyecto SCADAv6.2\Archivos de programa\ARDUINOv1_8\ARDUINOv1_8.pde"

' Abrimos el archivo con la variable Archivo, y como el acceso será de lectura _

utilizamos el modo Input seguido del número de archivo "#1"


Memoria. 57

Open Archivo For Input As #1 ' Creamos un bucle para controlar que después de llegar al final

del archivo _ la sentencia Input, no continue leyendo y se produzca un error

en tiempo de eje _ cucíon. Para ello utilizamos la condición Not EoF(1), que

traducido quiere decir _ mientras no llegue al final del archivo, que continúe leyendo

línea por línea. _ While Not EOF(1) Line Input #1, Linea Dim F As Integer F = FreeFile Open "C:\Documents and Settings\Administrador\Mis

documentos\Mis imágenes\sketch_aug16a\sketch_aug16a.pde" For Output As F

Print #F, Linea Close F Wend ' Cerramos el archivo Close #1 Dim punteroprogramar As Byte punteroprogramar = 1 'Colocar pines de controles analogicos While (punteroprogramar <= Paso1.cantidadcontrolanalog) F = FreeFile Open "C:\Documents and Settings\Administrador\Mis

documentos\Mis imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F

Print #F, "pinMode(" & Tabla_Control_Analog(punteroprogramar, 5) & ",OUTPUT); //Control analogico"

Print #F, "analogWrite(" & Tabla_Control_Analog(punteroprogramar, 5) & ",0);"

Close F punteroprogramar = punteroprogramar + 1 Wend 'Colocar pines de indicadores analogicos punteroprogramar = 1 While (punteroprogramar <= Paso1.cantidadindicanalog) F = FreeFile Open "C:\Documents and Settings\Administrador\Mis


Print #F, "pinMode(" & Tabla_Indicador_Analog(punteroprogramar, 5) & ",INPUT); //Indicador analogico"

Close F punteroprogramar = punteroprogramar + 1 Wend 'Colocar pines de indicadores digitales punteroprogramar = 1 While (punteroprogramar <= Paso1.cantidadindica) F = FreeFile Open "C:\Documents and Settings\Administrador\Mis



Memoria. 58

Print #F, "pinMode(" & Tabla_Indicador_Dig(punteroprogramar, 4) & ",INPUT); //Indicador digital"

Close F punteroprogramar = punteroprogramar + 1 Wend 'Colocar pines de controles digitales punteroprogramar = 1 While (punteroprogramar <= Paso1.cantidadBotones) F = FreeFile Open "C:\Documents and Settings\Administrador\Mis


Print #F, "pinMode(" & Tabla_Control_Dig(punteroprogramar, 7) & ",OUTPUT); //Control digital"

Print #F, "digitalWrite(" & Tabla_Control_Dig(punteroprogramar, 7) & "," & Tabla_Control_Dig(punteroprogramar, 2) & ");"

Close F punteroprogramar = punteroprogramar + 1 Wend 'Colocar Void loop F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "}" Close F F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "void loop(){" Close F 'Crear tablas necesarias para el BUS CAN 'Modulo1_ID y PINES_MODULO1_ID Dim punteromodulos As Byte punteromodulos = 1 While (punteromodulos < Paso1.cantidadindica) If (Tabla_Indicador_Dig(punteromodulos, 6) = 1) Then texto = texto & Tabla_Indicador_Dig(punteromodulos,

4) & "," & Tabla_Indicador_Dig(punteromodulos, 5) & "," punteromodulos = punteromodulos + 1 Else punteromodulos = punteromodulos + 1 End If Wend If (Tabla_Indicador_Dig(punteromodulos, 6) = 1) Then texto = texto & Tabla_Indicador_Dig(punteromodulos, 4) & "," &

Tabla_Indicador_Dig(punteromodulos, 5) End If F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "unsigned int MODULO1_ID[] = {" & texto & "}; //

Array de indicadores digitales del modulo 1" Close F texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindica)


Memoria. 59

If (Tabla_Indicador_Dig(punteromodulos, 6) = 1) Then texto = texto & Tabla_Indicador_Dig(punteromodulos,

4) punteromodulos = punteromodulos + 1 Else punteromodulos = punteromodulos + 1 End If Wend If (Tabla_Indicador_Dig(punteromodulos, 6) = 1) Then texto = texto & Tabla_Indicador_Dig(punteromodulos, 4) End If F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "unsigned int PINES_MODULO1_ID[] = {" & texto & "};

// Array de indicadores digitales del modulo 1" Close F 'Modulo2_ID y PINES_MODULO2_ID texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindica) If (Tabla_Indicador_Dig(punteromodulos, 6) = 2) Then texto = texto & Tabla_Indicador_Dig(punteromodulos,


Tabla_Indicador_Dig(punteromodulos, 5) F = FreeFile End If Open "C:\Documents and Settings\Administrador\Mis documentos\Mis


Array de indicadores digitales del modulo 2" Close F texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindica) If (Tabla_Indicador_Dig(punteromodulos, 6) = 2) Then texto = texto & Tabla_Indicador_Dig(punteromodulos,

4) & "," punteromodulos = punteromodulos + 1 Else punteromodulos = punteromodulos + 1 End If Wend If (Tabla_Indicador_Dig(punteromodulos, 6) = 2) Then texto = texto & Tabla_Indicador_Dig(punteromodulos, 4) End If F = FreeFile


Memoria. 60

Open "C:\Documents and Settings\Administrador\Mis documentos\Mis imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F

Print #F, "unsigned int PINES_MODULO2_ID[] = {" & texto & "}; // Array de indicadores digitales del modulo 2"

Close F 'Modulo3_ID y PINES_MODULO3_ID texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindica) If (Tabla_Indicador_Dig(punteromodulos, 6) = 3) Then texto = texto & Tabla_Indicador_Dig(punteromodulos,


Tabla_Indicador_Dig(punteromodulos, 5) F = FreeFile End If Open "C:\Documents and Settings\Administrador\Mis documentos\Mis


Array de indicadores digitales del modulo 3" Close F texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindica) If (Tabla_Indicador_Dig(punteromodulos, 6) = 3) Then texto = texto & Tabla_Indicador_Dig(punteromodulos,

4) & "," punteromodulos = punteromodulos + 1 Else punteromodulos = punteromodulos + 1 End If Wend If (Tabla_Indicador_Dig(punteromodulos, 6) = 3) Then texto = texto & Tabla_Indicador_Dig(punteromodulos, 4) End If F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "unsigned int PINES_MODULO3_ID[] = {" & texto & "};

// Array de indicadores digitales del modulo 3" Close F 'Modulo1_IA y PINES_MODULO1_IA punteromodulos = 1 While (punteromodulos < Paso1.cantidadindicanalog) If (Tabla_Indicador_Analog(punteromodulos, 10) = 1) Then


Memoria. 61

texto = texto & Tabla_Indicador_Analog(punteromodulos, 5) & "," & Tabla_Indicador_Analog(punteromodulos, 4) & ","

punteromodulos = punteromodulos + 1 Else punteromodulos = punteromodulos + 1 End If Wend If (Tabla_Indicador_Analog(punteromodulos, 10) = 1) Then texto = texto & Tabla_Indicador_Analog(punteromodulos, 5) & ","

& Tabla_Indicador_Analog(punteromodulos, 4) End If F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "unsigned int MODULO1_IA[] = {" & texto & "}; //

Array de indicadores analogicos del modulo 1" Close F texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindicanalog) If (Tabla_Indicador_Analog(punteromodulos, 10) = 1) Then texto = texto &

Tabla_Indicador_Analog(punteromodulos, 5) punteromodulos = punteromodulos + 1 Else punteromodulos = punteromodulos + 1 End If Wend If (Tabla_Indicador_Analog(punteromodulos, 10) = 1) Then texto = texto & Tabla_Indicador_Analog(punteromodulos, 5) End If F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "unsigned int PINES_MODULO1_IA[] = {" & texto & "};

// Array de indicadores analogicos del modulo 1" Close F 'Modulo2_IA y PINES_MODULO2_IA texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindicanalog) If (Tabla_Indicador_Analog(punteromodulos, 10) = 2) Then texto = texto &

Tabla_Indicador_Analog(punteromodulos, 5) & "," & Tabla_Indicador_Analog(punteromodulos, 4) & ","


& Tabla_Indicador_Analog(punteromodulos, 4) End If F = FreeFile


Memoria. 62

Open "C:\Documents and Settings\Administrador\Mis documentos\Mis imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F

Print #F, "unsigned int MODULO2_IA[] = {" & texto & "}; // Array de indicadores analogicos del modulo 2"

Close F texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindicanalog) If (Tabla_Indicador_Analog(punteromodulos, 10) = 2) Then texto = texto &

Tabla_Indicador_Analog(punteromodulos, 5) punteromodulos = punteromodulos + 1 Else punteromodulos = punteromodulos + 1 End If Wend If (Tabla_Indicador_Analog(punteromodulos, 10) = 2) Then texto = texto & Tabla_Indicador_Analog(punteromodulos, 5) End If F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis


// Array de indicadores analogicos del modulo 2" Close F 'Modulo3_IA y PINES_MODULO3_IA texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindicanalog) If (Tabla_Indicador_Analog(punteromodulos, 10) = 3) Then texto = texto &

Tabla_Indicador_Analog(punteromodulos, 5) & "," & Tabla_Indicador_Analog(punteromodulos, 4) & ","


& Tabla_Indicador_Analog(punteromodulos, 4) End If F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "unsigned int MODULO3_IA[] = {" & texto & "}; //

Array de indicadores analogicos del modulo 3" Close F texto = Empty punteromodulos = 1 While (punteromodulos < Paso1.cantidadindicanalog) If (Tabla_Indicador_Analog(punteromodulos, 10) = 3) Then texto = texto &

Tabla_Indicador_Analog(punteromodulos, 5)


Memoria. 63

punteromodulos = punteromodulos + 1 Else punteromodulos = punteromodulos + 1 End If Wend If (Tabla_Indicador_Analog(punteromodulos, 10) = 3) Then texto = texto & Tabla_Indicador_Analog(punteromodulos, 5) End If F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis


// Array de indicadores analogicos del modulo 3" Close F 'Fin de la parte del BUS CAN 'Colocar arrays que necesita arduino para la comunicación F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "unsigned int cantidad =" & Paso1.cantidadindica & ";

// Cantidad de indicadores digitales" Close F F = FreeFile Open "C:\Documents and Settings\Administrador\Mis documentos\Mis

imágenes\sketch_aug16a\sketch_aug16a.pde" For Append As F Print #F, "unsigned int cantidadanalog =" &

Paso1.cantidadindicanalog & "; // Cantidad de indicadores analogicos"

Close F 'Colocar array de indicadores digitales punteroprogramar = 1 texto = Empty If Paso1.cantidadindica = 1 Then F = FreeFile Open "C:\Documents and Settings\Administrador\Mis


Print #F, "unsigned int pines_digi_entrada[] = {" & Tabla_Indicador_Dig(punteroprogramar, 4), Tabla_Indicador_Dig(punteroprogramar, 6) & "}; // Array de indicadores digitales"

Close F Else While (punteroprogramar < Paso1.cantidadindica) texto = texto & Tabla_Indicador_Dig(punteroprogramar, 4)

& "," & Tabla_Indicador_Dig(punteroprogramar, 6) & "," punteroprogramar = punteroprogramar + 1 Wend texto = texto & Tabla_Indicador_Dig(punteroprogramar, 4) &

"," & Tabla_Indicador_Dig(punteroprogramar, 6) F = FreeFile Open "C:\Documents and Settings\Administrador\Mis


Print #F, "unsigned int pines_digi_entrada[] = {" & texto & "}; // Array de indicadores digitales"

Close F


Memoria. 64

End If 'Colocar array de indicadores analogicos punteroprogramar = 1 texto = Empty If Paso1.cantidadindicanalog = 1 Then F = FreeFile Open "C:\Documents and Settings\Administrador\Mis


Print #F, "unsigned int pines_analog_entrada[] = {" & Tabla_Indicador_Analog(punteroprogramar, 5), Tabla_Indicador_Analog(punteroprogramar, 10); "}; // Array de indicadores analogicos"

Close F Else While (punteroprogramar < Paso1.cantidadindicanalog) texto = texto & Tabla_Indicador_Analog(punteroprogramar,

5) & "," & Tabla_Indicador_Analog(punteroprogramar, 10) & "," punteroprogramar = punteroprogramar + 1 Wend texto = texto & Tabla_Indicador_Analog(punteroprogramar, 5)

& "," & Tabla_Indicador_Analog(punteroprogramar, 10) F = FreeFile Open "C:\Documents and Settings\Administrador\Mis


Print #F, "unsigned int pines_analog_entrada[] = {" & texto & "}; // Array de indicadores analogicos"

Close F End If 'Colocar la tercera parte Archivo = "C:\Documents and Settings\Administrador\Mis

documentos\Proyecto SCADAv6.2\Archivos de programa\Arduinov1_8B\ARDUINOv1_8\ARDUINOv1_8.pde"

Open Archivo For Input As #1 While Not EOF(1) Line Input #1, Linea F = FreeFile Open "C:\Documents and Settings\Administrador\Mis


Print #F, Linea Close F Wend Close #1 'Abrir el archivo Dim res As Long res = ShellExecute(Me.hwnd, "Open", "C:\Documents and

Settings\Administrador\Mis documentos\Mis imágenes\sketch_aug16a\sketch_aug16a.pde", "", "", 1)

End Sub

En líneas generales lo que hace todo este código de programación es unir

dos archivos, en los que se encuentra programado aquello que es fijo (comunicaciones) y además le añade ciertos datos (ya mencionados líneas más


Memoria. 65

arriba) que son variables en función de la aplicación SCADA que haya diseñado el usuario.

De manera que a lo largo de todas estas líneas de código se esta siguiendo

una serie de pasos que pueden resumirse en unas pocas líneas. El primer paso es abrir un archivo (ubicado en “Archivos de programa”) que

contiene cierta información fija, leer su contenido y pegarlo en el sketch a generar. Posteriormente se vuelve a abrir el sketch a generar y se le incluye los datos

variables que configuran la placa principal y los diferentes módulos de la red CAN. Una vez en este punto, la siguiente tarea es abrir otro archivo almacenado

en la carpeta “Archivos de programa”, leer su contenido y pegarlo al final del sketch que se esta generando.

Una vez finalizada esta última acción se abre el sketch y se presenta al

usuario, para que este pueda programar su algoritmo de control. Cuando finalice su algoritmo de control, deberá cargar el programa a través del USB que es el medio de comunicación entre la placa principal y el SCADA.

Figura 40) Diagrama de flujo. Generar programa para chipKIT.

Comunicaciones vía USB, PC-‐chipKIT. La comunicación chipKIT-‐PC se lleva a cabo mediante el puerto USB, que en

un principio y por las funciones tan simples que hacen posible el envio y recepción de datos, puede parecer una comunicación sencilla, pero nada más lejos de la


Memoria. 66

realidad. Ya que a diferencia de CAN, este tipo de comunicaciones no presenta una trama predefinida, sino que debe ser el propio diseñador el que genere la trama de entendimiento entre ambas partes.

La trama de comunicación chipKIT à PC esta formada por varios campos y

presenta la estructura siguiente. Inicio de trama (:)

Lectura pines digitales

Checksum pines digitales

Bytes de dato analógico

Separador de dato analógico (/)

Bytes del Checksum de pines analógicos

Finalizador (.)

Esta es la trama que permite al chipKIT reportar la información al SCADA

sobre el estado de sus pines de entrada, con el objetivo de que este pueda actualizar las diferentes tablas y de esta manera presentar al usuario la información actualizada (tanto en los indicadores digitales como analógicos).

El primero de los campos que manda chipKIT es un byte de inicio de la

comunicación, VB hasta que no encuentra este dato desecha toda la información. Una vez que constata que le ha llegado el carácter “:”, lee el siguiente dato o datos en función del número de indicadores que existan. VB tiene en una variable almacenado la cantidad de indicadores que existen y el sabe que si tiene entre 1 y 8 indicadores, únicamente le llegará un dato de lectura de pines digitales, si tiene más de 8 pero menos de 16, le llegarán dos y así sucesivamente como se puede observar en la programación.

Una vez que ha leído el dato que contiene información sobre el estado de las entradas digitales, comprueba que esa información ha llegado de manera correcta. Para ello realiza un checksum, es decir, suma todos los datos de lectura de pines que le han llegado y a ese resultado le suma un valor constante. Si ese dato que se obtiene coincide con el siguiente valor que llega por el puerto serie (“checksum pines digitales”), la información ha llegado correctamente, si no es así desecha toda la trama y vuelve a leer.

El siguiente paso es leer el estado de las entradas analógicas, por la forma

de enviar estos datos de chipKIT, los valores que llegan a VB están separados en cifras, es decir, chipKIT cuando manda un 1023, en realidad manda cuatro bytes en el que el primer byte llega un 1, en el segundo un 0 y así sucesivamente hasta formar la cifra. Este número deberá ser reconstruido en VB para su posterior uso.

Una vez leídos todos los datos de los pines analógicos, se lee en campo de

“Checksum analógico”, que deberá ser utilizado para comprobar de nuevo que los datos recibidos son correctos.

Por último se leerá el campo “Finalizador” que marcará a VB el final de

trama.


Memoria. 67

Figura 41) Diagrama de flujo. Comunicación chipKIT-‐PC

La programación que hace posible este entendimiento entre chipKIT y el panel SCADA es la siguiente.

Programación en Visual Basic. Private Sub recoge_arduino_Timer() 'COMUNICACIONES Select Case numindicadoresarduino Case 1 To 8 numindicadoresarduino = 2 Case 9 To 16 numindicadoresarduino = 3 Case 17 To 24 numindicadoresarduino = 4 Case 25 To 32 numindicadoresarduino = 5 Case 33 To 40 numindicadoresarduino = 6


Memoria. 68

Case 41 To 48 numindicadoresarduino = 7 Case 49 To 56 numindicadoresarduino = 8 Case 57 To 64 numindicadoresarduino = 9 Case 65 To 72 numindicadoresarduino = 10 Case 73 To 81 numindicadoresarduino = 11 End Select If (SerieC.InBufferCount > 113) Then SerieC.InputLen = 0 Label5.Caption = SerieC.Input SerieC.InputLen = 1 End If lee: If (SerieC.InBufferCount <> 0) Then numindicadoresarduino = Paso1.cantidadindica BYTES(0) = SerieC.Input If (BYTES(0) = "+") Then 'MODULOS BYTES(0) = SerieC.Input If (BYTES(0) = "+") Then BYTES(0) = SerieC.Input If (BYTES(0) = "+") Then ' !!!AQUI COMPRUEBO EL DATO DEL QUE SE TRATA Dim msgvalue As Boolean msgvalue = MsgBox("Modulo 0: Conectado" & vbCr & "Modulo 1: Desconectado" & vbCr & "Modulo 2: Desconectado" & vbCr & "Modulo 3: Desconectado", vbOKCancel) BYTES(0) = SerieC.Input End If End If End If If (BYTES(0) = "") Then 'INDICADORES GoTo lee Else If (Asc(BYTES(0)) = 58) Then Select Case numindicadoresarduino Case 1 To 8 numindicadoresarduino = 2 Case 9 To 16 numindicadoresarduino = 3 Case 17 To 24 numindicadoresarduino = 4 Case 25 To 32 numindicadoresarduino = 5 Case 33 To 40 numindicadoresarduino = 6 Case 41 To 48 numindicadoresarduino = 7 Case 49 To 56


Memoria. 69

numindicadoresarduino = 8 Case 57 To 64 numindicadoresarduino = 9 Case 65 To 72 numindicadoresarduino = 10 Case 73 To 81 numindicadoresarduino = 11 End Select While (numindicadoresarduino <> 0) BYTES(numindicadoresarduino) = SerieC.Input If (BYTES(numindicadoresarduino) = "") Then BYTES(numindicadoresarduino) = 0 GoTo lee End If numindicadoresarduino = numindicadoresarduino - 1 Wend punteroA = 0 auxiliar = 0 While (auxiliar <> ".") BYTESANALOG(punteroA) = SerieC.Input auxiliar = BYTESANALOG(punteroA) If (BYTESANALOG(punteroA) = "") Then BYTESANALOG(numindicadoresarduinoanalog) = 0 GoTo lee End If punteroA = punteroA + 1 Wend Else GoTo lee End If End If numindicadoresarduino = Paso1.cantidadindica Select Case numindicadoresarduino Case 1 To 8 numindicadoresarduino = 2 Case 9 To 16 numindicadoresarduino = 3 Case 17 To 24 numindicadoresarduino = 4 Case 25 To 32 numindicadoresarduino = 5 Case 33 To 40 numindicadoresarduino = 6 Case 41 To 48 numindicadoresarduino = 7 Case 49 To 56 numindicadoresarduino = 8 Case 57 To 64 numindicadoresarduino = 9 Case 65 To 72 numindicadoresarduino = 10 Case 73 To 81 numindicadoresarduino = 11


Memoria. 70

End Select While (numindicadoresarduino <> 0) entero = BYTES(numindicadoresarduino) Checksum = Checksum Xor Asc(entero) numindicadoresarduino = numindicadoresarduino - 2 Wend Checksum = Checksum Xor 17 punteroAA = 0 punteroestadoanalogica = 1 While (punteroAA < punteroA) If (BYTESANALOG(punteroAA) <> "/") And (BYTESANALOG(punteroAA) <> ".") Then cnt = cnt + 1 punteroAA = punteroAA + 1 Else punteroanalog = punteroAA - cnt Select Case cnt Case 1 estadoanalogica(punteroestadoanalogica) = BYTESANALOG(punteroanalog) punteroestadoanalogica = punteroestadoanalogica + 1 Case 2 estadoanalogica(punteroestadoanalogica) = BYTESANALOG(punteroanalog) * 10 punteroanalog = punteroanalog + 1 estadoanalogica(punteroestadoanalogica) = estadoanalogica(punteroestadoanalogica) + BYTESANALOG(punteroanalog) punteroestadoanalogica = punteroestadoanalogica + 1 Case 3 estadoanalogica(punteroestadoanalogica) = BYTESANALOG(punteroanalog) * 100 punteroanalog = punteroanalog + 1 estadoanalogica(punteroestadoanalogica) = estadoanalogica(punteroestadoanalogica) + BYTESANALOG(punteroanalog) * 10 punteroanalog = punteroanalog + 1 estadoanalogica(punteroestadoanalogica) = estadoanalogica(punteroestadoanalogica) + BYTESANALOG(punteroanalog) punteroestadoanalogica = punteroestadoanalogica + 1 Case 4 estadoanalogica(punteroestadoanalogica) = BYTESANALOG(punteroanalog) * 1000 punteroanalog = punteroanalog + 1 estadoanalogica(punteroestadoanalogica) = estadoanalogica(punteroestadoanalogica) + BYTESANALOG(punteroanalog) * 100 punteroanalog = punteroanalog + 1 estadoanalogica(punteroestadoanalogica) = estadoanalogica(punteroestadoanalogica) + BYTESANALOG(punteroanalog) * 10 punteroanalog = punteroanalog + 1


Memoria. 71

estadoanalogica(punteroestadoanalogica) = estadoanalogica(punteroestadoanalogica) + BYTESANALOG(punteroanalog) punteroestadoanalogica = punteroestadoanalogica + 1 End Select punteroanalog = 0 punteroAA = punteroAA + 1 cnt = 0 End If Wend punteroAA = 1 Checktramanalog = 0 Checksumanalog = estadoanalogica(punteroestadoanalogica - 1) While (punteroAA < (punteroestadoanalogica - 1)) Checktramanalog = Checktramanalog Xor estadoanalogica(punteroAA) punteroAA = punteroAA + 1 Wend Checktramanalog = Checktramanalog Xor 17 If ((Asc(BYTES(1)) = Checksum) And (Checksumanalog = Checktramanalog)) Then 'habilitar_timer = True numindicadoresarduino = Paso1.cantidadindica puntero = 1 Select Case numindicadoresarduino Case 1 To 8 numindicadoresarduino = 2 Case 9 To 16 numindicadoresarduino = 3 Case 17 To 24 numindicadoresarduino = 4 Case 25 To 32 numindicadoresarduino = 5 Case 33 To 40 numindicadoresarduino = 6 Case 41 To 48 numindicadoresarduino = 7 Case 49 To 56 numindicadoresarduino = 8 Case 57 To 64 numindicadoresarduino = 9 Case 65 To 72 numindicadoresarduino = 10 Case 73 To 81 numindicadoresarduino = 11 End Select While (numindicadoresarduino <> 1) Tabla_Indicador_Dig(puntero, 5) = (Asc(BYTES(numindicadoresarduino)) And 128) / 128 puntero = puntero + 1 Tabla_Indicador_Dig(puntero, 5) = (Asc(BYTES(numindicadoresarduino)) And 64) / 64 puntero = puntero + 1


Memoria. 72

Tabla_Indicador_Dig(puntero, 5) = (Asc(BYTES(numindicadoresarduino)) And 32) / 32 puntero = puntero + 1 Tabla_Indicador_Dig(puntero, 5) = (Asc(BYTES(numindicadoresarduino)) And 16) / 16 puntero = puntero + 1 Tabla_Indicador_Dig(puntero, 5) = (Asc(BYTES(numindicadoresarduino)) And 8) / 8 puntero = puntero + 1 Tabla_Indicador_Dig(puntero, 5) = (Asc(BYTES(numindicadoresarduino)) And 4) / 4 puntero = puntero + 1 Tabla_Indicador_Dig(puntero, 5) = (Asc(BYTES(numindicadoresarduino)) And 2) / 2 puntero = puntero + 1 Tabla_Indicador_Dig(puntero, 5) = (Asc(BYTES(numindicadoresarduino)) And 1) numindicadoresarduino = numindicadoresarduino - 1 Wend punteroAA = 1 puntero = 1 While (punteroAA < (punteroestadoanalogica - 1)) Tabla_Indicador_Analog(puntero, 4) = estadoanalogica(punteroAA) punteroAA = punteroAA + 1 puntero = puntero + 1 Wend Else Checksum = 0 Checksumanalog = 0 GoTo lee End If numindicadores = Paso1.cantidadindica While numindicadores <> 0 If Tabla_Indicador_Dig(numindicadores, 5) = 1 Then mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).Picture = LoadPicture(Tabla_Indicador_Dig(numindicadores, 2)) SetLayeredWindowAttributes mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).hwnd, RGB(0, 0, 255), 0, LWA_COLORKEY mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).ScaleMode = 3 mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).AutoRedraw = True mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).PaintPicture mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).Picture, _ 0, 0, mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).ScaleWidth, mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).ScaleHeight Else mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).Picture = LoadPicture(Tabla_Indicador_Dig(numindicadores, 3)) SetLayeredWindowAttributes mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).hwnd, RGB(0, 0, 255), 0, LWA_COLORKEY


Memoria. 73

mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).ScaleMode = 3 mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).AutoRedraw = True mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).PaintPicture mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).Picture, _ 0, 0, mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).ScaleWidth, mi_imagen(Tabla_Indicador_Dig(numindicadores, 1)).ScaleHeight End If numindicadores = numindicadores - 1 Wend numindicadoresanalog = Paso1.cantidadindicanalog While numindicadoresanalog <> 0 ProgressBar1(numindicadoresanalog).Max = Tabla_Indicador_Analog(numindicadoresanalog, 2) ProgressBar1(numindicadoresanalog).Min = Tabla_Indicador_Analog(numindicadoresanalog, 1) ProgressBar1(numindicadoresanalog).Value = (Tabla_Indicador_Analog(numindicadoresanalog, 4) * (Tabla_Indicador_Analog(numindicadoresanalog, 2) - Tabla_Indicador_Analog(numindicadoresanalog, 1)) / 1023) + (Tabla_Indicador_Analog(numindicadoresanalog, 1)) Label1(numindicadoresanalog).Caption = Round((Tabla_Indicador_Analog(numindicadoresanalog, 4) * (Tabla_Indicador_Analog(numindicadoresanalog, 2) - Tabla_Indicador_Analog(numindicadoresanalog, 1)) / 1023) + (Tabla_Indicador_Analog(numindicadoresanalog, 1))) & (Tabla_Indicador_Analog(numindicadoresanalog, 9)) numindicadoresanalog = numindicadoresanalog - 1 Wend End If End Sub

Programación en chipKIT. //----------------------------------------------------------------- //ZONA DE COMUNICACIONES. NO REALIZE NINGÚN CAMBIO POR FAVOR. //----------------------------------------------------------------- //Declaro variables para controles. unsigned int dato; // variable con la que voy desapilando el buffer. int num_led; //Me indica el LED a encender en los controles int brillo; //Me indica el brillo que le quiero dar al LED en los controles analogicos int estado; // Me indica el estado de los controles digitales //Declaro variables para indicadores int punteroindicadoresdig; int datoindic; // Dato que le mando a VB para informarle de 7 en 7 del estado de los indicadores int datoindic2; // Dato que le mando a VB para informarle de 7 en 7 del estado de los indicadores int datoindic3; int datoindic4;


Memoria. 74

int datoindic5; int datoindic6; int datoindic7; int datoindic8; int datoindic9; int datoindic10; int checksum; //Dato con el que comparo a ver si puedo comenzar a enviar el estado de los indicadores datoindic =0; checksum = 0; datoindic2 = 0; datoindic3 = 0; datoindic4 = 0; datoindic5 = 0; datoindic6 = 0; datoindic7 = 0; datoindic8 = 0; datoindic9 = 0; datoindic10 = 0; int punteroindicadoresanalog; int checksumanalog; checksumanalog = 0; //MAPA DE MEMORIA int zonas_controles_digitales[80]; //ZONA EN LA QUE ESTA EL ESTADO DE LOS CONTROLES DIGITALES, ORDENADOS POR PINES. EJ 46 VALOR, ESTADO DEL PIN 46 int zonas_controles_analogicos[11]; //ZONA EN LA QUE ESTA EL ESTADO DE LOS CONTROLES ANALOGICOS, SE ORDENAN DE LA MISMA MANERA QUE EN EL ANTERIOR int zonas_indicadores_digitales[80]; //ZONA EN LA QUE SE ENCUENTRA EL ESTADO DE LOS INDICADORES DIGITALES, ORDENADOS POR LOS PINES INDICADOS EN LA VARIABLE ARRAY. EL PRIMER VALOR int i=0; // SERA EL ESTADO DEL PIN 33. for(i=0; i<80; i++){ zonas_indicadores_digitales[i]=0; } int zonas_indicadores_analogicos[16]; //ZONA EN LA QUE SE ENCUENTRA EL ESTADO DE LOS INDICADORES ANALOGICOS //Zona en la que se va a enviar la configuración de los pines a cada módulo //Zona en la que se va a leer el buffer de entrada, para poder actualizar los controles. if(Serial.available()) { while (Serial.available()>0){ dato = Serial.read(); //read Serial if (dato == 0){ dato = Serial.read(); //read Serial if ((dato & 0x01)== 1){ num_led = (dato & 0x7E)>>1; //delay(1000); dato = Serial.read(); //read Serial brillo = dato;


Memoria. 75

analogWrite(num_led,brillo); zonas_controles_analogicos[num_led] = brillo; } else{ num_led = (dato & 0x7E) >>1; //delay(1000); estado = (dato & 0x80) >> 7; digitalWrite(num_led,estado); zonas_controles_digitales[num_led] = estado; } } if (dato == 1){ lcd.setCursor(0, 1); lcd.print("MODULO 1"); } } } //Zona en la que se va a enviar la tabla de indicadores, para que los lea VB. int punteroauxiliar; // Con este recorro la tabla de pines indicadores digitales int punteroM1ID; punteroindicadoresdig = 0; //Indicadores DIGITALES punteroauxiliar =0; punteroM1ID = 0; while (punteroindicadoresdig != cantidad * 2){ PIN = pines_digi_entrada[punteroauxiliar]; punteroauxiliar = punteroauxiliar +1 ; MODULO = pines_digi_entrada[punteroauxiliar]; punteroauxiliar = punteroauxiliar +1 ; switch (MODULO){ case 0: //MODULO 0 zonas_indicadores_digitales[punteroindicadoresdig] = digitalRead (PIN); punteroindicadoresdig = punteroindicadoresdig +1 ; break; case 1: //MODULO 1 while (PIN != MODULO1_ID[punteroM1ID]){ punteroM1ID = punteroM1ID + 2; } punteroM1ID = punteroM1ID + 1; zonas_indicadores_digitales[punteroindicadoresdig] = MODULO1_ID[punteroM1ID]; punteroM1ID = 0; punteroindicadoresdig = punteroindicadoresdig +1 ; break; case 2: //MODULO 2 while (PIN != MODULO2_ID[punteroM1ID]){ punteroM1ID = punteroM1ID + 2; } punteroM1ID = punteroM1ID + 1; zonas_indicadores_digitales[punteroindicadoresdig] = MODULO2_ID[punteroM1ID]; punteroM1ID = 0; punteroindicadoresdig = punteroindicadoresdig +1 ; break;


Memoria. 76

case 3: //MODULO 3 while (PIN != MODULO3_ID[punteroM1ID]){ punteroM1ID = punteroM1ID + 2; } punteroM1ID = punteroM1ID + 1; zonas_indicadores_digitales[punteroindicadoresdig] = MODULO3_ID[punteroM1ID]; punteroM1ID = 0; punteroindicadoresdig = punteroindicadoresdig +1 ; break; } } punteroindicadoresdig = 0; switch (cantidad) { case 1 ... 8: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = datoindic ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(checksum,BYTE); break; case 9 ... 16: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = (datoindic ^ datoindic2) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(checksum,BYTE); break; case 17 ... 24: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; }


Memoria. 77

while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 24){ datoindic3 = datoindic3 <<1; datoindic3 = datoindic3 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = (datoindic ^ datoindic2 ^ datoindic3) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(datoindic3,BYTE); Serial.print(checksum,BYTE); break; case 25 ... 32: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 24){ datoindic3 = datoindic3 <<1; datoindic3 = datoindic3 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 32){ datoindic4 = datoindic4 <<1; datoindic4 = datoindic4 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = (datoindic ^ datoindic2 ^ datoindic3 ^datoindic4) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(datoindic3,BYTE); Serial.print(datoindic4,BYTE); Serial.print(checksum,BYTE); break;


Memoria. 78

case 33 ... 40: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 24){ datoindic3 = datoindic3 <<1; datoindic3 = datoindic3 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 32){ datoindic4 = datoindic4 <<1; datoindic4 = datoindic4 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 40){ datoindic5 = datoindic5 <<1; datoindic5 = datoindic5 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = (datoindic ^ datoindic2 ^ datoindic3 ^datoindic4 ^datoindic5) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(datoindic3,BYTE); Serial.print(datoindic4,BYTE); Serial.print(datoindic5,BYTE); Serial.print(checksum,BYTE); break; case 41 ... 48: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1;


Memoria. 79

} while (punteroindicadoresdig != 24){ datoindic3 = datoindic3 <<1; datoindic3 = datoindic3 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 32){ datoindic4 = datoindic4 <<1; datoindic4 = datoindic4 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 40){ datoindic5 = datoindic5 <<1; datoindic5 = datoindic5 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 48){ datoindic6 = datoindic6 <<1; datoindic6 = datoindic6 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = (datoindic ^ datoindic2 ^ datoindic3 ^datoindic4 ^datoindic5^datoindic6) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(datoindic3,BYTE); Serial.print(datoindic4,BYTE); Serial.print(datoindic5,BYTE); Serial.print(datoindic6,BYTE); Serial.print(checksum,BYTE); break; case 49 ... 56: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 24){ datoindic3 = datoindic3 <<1; datoindic3 = datoindic3 + zonas_indicadores_digitales[punteroindicadoresdig];


Memoria. 80

punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 32){ datoindic4 = datoindic4 <<1; datoindic4 = datoindic4 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 40){ datoindic5 = datoindic5 <<1; datoindic5 = datoindic5 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 48){ datoindic6 = datoindic6 <<1; datoindic6 = datoindic6 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 56){ datoindic6 = datoindic7 <<1; datoindic6 = datoindic7 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = (datoindic ^ datoindic2 ^ datoindic3 ^ datoindic4 ^ datoindic5 ^ datoindic6 ^ datoindic7) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(datoindic3,BYTE); Serial.print(datoindic4,BYTE); Serial.print(datoindic5,BYTE); Serial.print(datoindic6,BYTE); Serial.print(datoindic7,BYTE); Serial.print(checksum,BYTE); break; case 57 ... 64: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 24){ datoindic3 = datoindic3 <<1;


Memoria. 81

datoindic3 = datoindic3 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 32){ datoindic4 = datoindic4 <<1; datoindic4 = datoindic4 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 40){ datoindic5 = datoindic5 <<1; datoindic5 = datoindic5 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 48){ datoindic6 = datoindic6 <<1; datoindic6 = datoindic6 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 56){ datoindic6 = datoindic7 <<1; datoindic6 = datoindic7 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 64){ datoindic6 = datoindic8 <<1; datoindic6 = datoindic8 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = (datoindic ^ datoindic2 ^ datoindic3 ^ datoindic4 ^ datoindic5 ^ datoindic6 ^ datoindic7 ^ datoindic8) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(datoindic3,BYTE); Serial.print(datoindic4,BYTE); Serial.print(datoindic5,BYTE); Serial.print(datoindic6,BYTE); Serial.print(datoindic7,BYTE); Serial.print(datoindic8,BYTE); Serial.print(checksum,BYTE); break; case 65 ... 72: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig];


Memoria. 82

punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 24){ datoindic3 = datoindic3 <<1; datoindic3 = datoindic3 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 32){ datoindic4 = datoindic4 <<1; datoindic4 = datoindic4 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 40){ datoindic5 = datoindic5 <<1; datoindic5 = datoindic5 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 48){ datoindic6 = datoindic6 <<1; datoindic6 = datoindic6 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 56){ datoindic6 = datoindic7 <<1; datoindic6 = datoindic7 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 64){ datoindic6 = datoindic8 <<1; datoindic6 = datoindic8 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 64){ datoindic6 = datoindic9 <<1; datoindic6 = datoindic9 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; }


Memoria. 83

checksum = (datoindic ^ datoindic2 ^ datoindic3 ^ datoindic4 ^ datoindic5 ^ datoindic6 ^ datoindic7 ^ datoindic8 ^ datoindic9) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(datoindic3,BYTE); Serial.print(datoindic4,BYTE); Serial.print(datoindic5,BYTE); Serial.print(datoindic6,BYTE); Serial.print(datoindic7,BYTE); Serial.print(datoindic8,BYTE); Serial.print(datoindic9,BYTE); Serial.print(checksum,BYTE); break; case 73 ... 80: while (punteroindicadoresdig != 8){ datoindic = datoindic <<1; datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 16){ datoindic2 = datoindic2 <<1; datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 24){ datoindic3 = datoindic3 <<1; datoindic3 = datoindic3 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 32){ datoindic4 = datoindic4 <<1; datoindic4 = datoindic4 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 40){ datoindic5 = datoindic5 <<1; datoindic5 = datoindic5 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 48){ datoindic6 = datoindic6 <<1; datoindic6 = datoindic6 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 56){


Memoria. 84

datoindic6 = datoindic7 <<1; datoindic6 = datoindic7 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 64){ datoindic6 = datoindic8 <<1; datoindic6 = datoindic8 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 64){ datoindic6 = datoindic9 <<1; datoindic6 = datoindic9 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } while (punteroindicadoresdig != 64){ datoindic6 = datoindic10 <<1; datoindic6 = datoindic10 + zonas_indicadores_digitales[punteroindicadoresdig]; punteroindicadoresdig = punteroindicadoresdig +1; } checksum = (datoindic ^ datoindic2 ^ datoindic3 ^ datoindic4 ^ datoindic5 ^ datoindic6 ^ datoindic7 ^ datoindic8 ^ datoindic9 ^ datoindic10) ^17; Serial.print(58,BYTE); Serial.print(datoindic,BYTE); Serial.print(datoindic2,BYTE); Serial.print(datoindic3,BYTE); Serial.print(datoindic4,BYTE); Serial.print(datoindic5,BYTE); Serial.print(datoindic6,BYTE); Serial.print(datoindic7,BYTE); Serial.print(datoindic8,BYTE); Serial.print(datoindic9,BYTE); Serial.print(datoindic10,BYTE); Serial.print(checksum,BYTE); break; } int punteroM1IA; //Indicadores ANALOGICOS punteroindicadoresanalog = 0; punteroauxiliar =0; punteroM1IA = 0; PIN = 0; MODULO = 0; while (punteroindicadoresanalog != cantidadanalog * 2){ PIN = pines_analog_entrada[punteroauxiliar]; punteroauxiliar = punteroauxiliar +1 ; MODULO = pines_analog_entrada[punteroauxiliar]; punteroauxiliar = punteroauxiliar +1 ; switch (MODULO){ case 0: //MODULO 0


Memoria. 85

zonas_indicadores_analogicos[punteroindicadoresanalog] = analogRead (PIN); punteroindicadoresanalog = punteroindicadoresanalog +1 ; break; case 1: //MODULO 1 while (PIN != MODULO1_IA[punteroM1IA]){ punteroM1IA = punteroM1IA + 2; } punteroM1IA = punteroM1IA + 1; zonas_indicadores_analogicos[punteroindicadoresanalog] = MODULO1_IA[punteroM1IA]; punteroM1IA = 0; punteroindicadoresanalog = punteroindicadoresanalog +1 ; break; case 2: //MODULO 2 while (PIN != MODULO2_IA[punteroM1IA]){ punteroM1IA = punteroM1IA + 2; } punteroM1IA = punteroM1IA + 1; zonas_indicadores_analogicos[punteroindicadoresanalog] = MODULO2_IA[punteroM1IA]; punteroM1IA = 0; punteroindicadoresanalog = punteroindicadoresanalog +1 ; break; case 3: //MODULO 3 while (PIN != MODULO3_IA[punteroM1IA]){ punteroM1IA = punteroM1IA + 2; } punteroM1IA = punteroM1IA + 1; zonas_indicadores_analogicos[punteroindicadoresanalog] = MODULO3_IA[punteroM1IA]; punteroM1IA = 0; punteroindicadoresanalog = punteroindicadoresanalog +1 ; break; } } punteroindicadoresanalog = 0; checksumanalog = 0; while (punteroindicadoresanalog != cantidadanalog){ Serial.print(zonas_indicadores_analogicos[punteroindicadoresanalog]); checksumanalog = checksumanalog ^ zonas_indicadores_analogicos[punteroindicadoresanalog] ; punteroindicadoresanalog = punteroindicadoresanalog +1 ; Serial.print (47,BYTE); } checksumanalog = checksumanalog ^17; Serial.print (checksumanalog); Serial.print (46,BYTE);


Memoria. 86

8.2.4 Manual de usuario del panel SCADA.

Como ya se ha hecho mención anteriormente, el panel SCADA esta formado por cuatro pantallas, cuya programación ya ha sido analizada extensamente. A continuación se va a presentar los resultados visuales de dicha programación.

La primera pantalla que aparece es una pantalla de presentación, en la que aparecen dos botones, los cuales rezan de la siguiente manera, “PROYECTO NUEVO” y “PROYECTO EXISTENTE”. El primero de los botones permite crear un SCADA desde cero, por su parte el segúndo botón concede al usuario la posibilidad de partir de un panel SCADA ya realizado o en proceso de realización.

Figura 42) Pantalla de presentación de la aplicación.

Se va a partir del supuesto caso en que el usuario decide crear el proyecto desde cero, ya que la única diferencia que existe con respecto a la otra opción es la no necesidad de pasar por una pantalla intermedia, que se va a analizar a continuación. Si por el contrario, se pulsaría la opción de “PROYECTO EXISTENTE”, la aplicación direccionaria al usuario a la última de las pantallas, una vez ahí, este debería pulsar el botón cargar y seleccionar el archivo (.xlsx) que desea cargar.

La siguiente pantalla a la que nos conducirá la aplicación será un formulario limpio, que recibirá al usuario con una ventana emergente, en la que se le pedirá que “delimite la zona en la que se desea colocar la imagen de fondo”.

Figura 43) Asistente de creación del panel SCADA


Memoria. 87

El primer paso a realizar en esta pantalla, será delimitar el área en la que se quiere colocar la imagen. Esto se consigue de la misma manera que cuando se quiere realizar una selección sobre cualquier aplicación Windows. Una vez que ya se le ha indicado a la aplicación el área en la que se quiere imprimir la imagen aparecerá de nuevo otra ventana emergente, que indicará al usuario cual es el paso siguiente, “Cargue la imagen de fondo”.


Pulsando sobre el botón cargar, se desplegará una pantalla emergente en la que se solicitará la ruta de la imagen de fondo.

Figura 45) Solicita la ruta de la imagen de fondo.

Una vez seleccionado el archivo .jpeg que se desea cargar, inmediatamente se colocará la imagen sobre el fondo.


Memoria. 88

Figura 46) Estado de la aplicación una vez cargada la imagen de fondo.

Se pulsa el botón siguiente para pasar a la siguiente página en la que se podrá llevar a cabo la creación de los diferentes elementos que permitirán al usuario interacturar con el proceso.

Una vez situado el la tercera página, de nuevo aparecerá una ventana emergente en la que pedirá al usuario que “marque las zonas a controlar y edítelas”.

Figura 47) El asistente indica al usuario que puede comenzar a crear las zonas de control.


Memoria. 89

Figura 48) Asistente de cración del panel SCADA.

De manera, que siguiendo las instrucciones del asistente la siguiente tarea será crear las diferentes zonas de control. Para ello, de nuevo se marca la zona sobre la que se desea situar el elemento de control, en caso de que el usuario no esté convencido con el resultado obtenido, posee un botón de “MODIFICAR” que le permite borrar esta zona y volver a crear otra.

Una vez que el usuario decida que esa es la zona final sobre la que desea colocar el elemento de control, pulsará en la zona remarcada y le aparecerá una ventana emergente a modo de formulario, que deberá rellenar para seleccionar si desea crear un botón, un shape, un slider, una etiqueta o una progressbar.

Figura 49) Formulario para crear los diferentes elementos de control.


Memoria. 90

En caso de querer crear un botón el formulario deberá ser rellenado de la siguiente manera.

Figura 50) Formulario rellenado para crear un botón.

De manera que estamos creando un control booleano, cuyo estado por defecto es apagado y que configura al pin 25 del módulo cero como salida. Así mismo, en la parte de la derecha del formulario, permite elegir si se quiere un botón de color (que se ponga en verde cuando el actuador este encendido o en rojo en caso contrario) o un botón animado en el que se alterne la imagen elegida en función de la posición en que se encuentre.

Una vez cumplimentado el formulario, se pulsa el botón Agregar, con el fin de guardar este componente y posteriormente se pulsa Aceptar para posicionar el control seobre la imagen de fondo.

Figura 51) Aplicación SCADA con el botón ya creado.


Memoria. 91

Si el usuario necesita crear un slider o text, deberá cumplimentar el formulario de la siguiente manera.

Figura 52) Formulario rellenado para crear un slider.

De nuevo creamos un control, pero en este caso los datos con los que trabaja son de tipo real. Se le indicará por tanto cual será el valor máximo y mínimo con los que se quiere trabajar y la aplicación de manera interna (como ya se ha explicado anteriormente) llevará a cabo el escalado. Se configura como salida analógica el pin 10 de módulo 0 y se le indica a la aplicación que cuando ofrezca el valor en el que este posicionado el slider lo acompañe de la unidad de medida que se le indique.

Una vez realizado el formulario se seguirán la operativa será la misma que la expuesta en el punto anterior.

Figura 53) Aplicación SCADA con el slider ya creado.


Memoria. 92

En caso de querer crear un text, el formulario se rellena de la misma manera que en el anterior punto a excepción de que hay que marcar el check “text Analógico”.

Figura 54) Formulario rellenado para crear un text.

Figura 55) Panel SCADA con el text ya creado.


Memoria. 93

Para crear una progressbar el proceso es el mismo que con el resto de controles, únicamente cambia la manera de rellenar el formulario.

Figura 56) Formulario rellenado para crear una progressbar.

En este caso se ha seleccionado un indicador (pin 0 del módulo 0), que trabajará con datos reales (analógicos), cuyos valores oscilarán entre 0 y 30.

En la parte derecha se puede seleccionar la forma de relleno, o bien vertical o bien horizontal, así como el color de fondo y el color de la barra de progreso. De nuevo se le da la posibilidad al usuario de definir las unidades con las que esta trabajando y que acompañarán al dato que indica cual es el valor de la entrada analógico (esta valor ya esta escalado, en este caso entre 0 y 30).

Así mismo el usuario podrá utilizar el servicio de gestión de alarmas marcando el check “Generar alarma”. Los campos que debe de rellenar es el valor límite a partir del cual quiere que se genere la alarma y el texto que quiere que aparezca.

Figura 57) Generación de alarma tras superar el valor límite.


Memoria. 94

Figura 58) Aplicación SCADA con la progressbar ya creada.

El último elemento a crear, es un shape, que requiere rellenar el formulario como se expone a continuación.

Figura 59) Formulario rellenado para crear un shape.

Con este formulario se indica que el pin 35 del módulo 0 debe trabajar como entrada digital (Booleano, Indicador) y que parte de un estado por defecto de cero (en este caso de apertura total de la válvula). En la parte de la derecha existen dos zonas que pinchando sobre ellas dan la posibilidad al usuario de seleccionar la ruta de las imágenes que deben aparecer en función del estado de las entrada.

Además se ha seleccionado que se genere una alarma cuando el sensor transmita cero voltios.


Memoria. 95

Figura 60) Generación de alarma.

De nuevo se pulsa Agregar y Aceptar y se cierra la ventana emergente apareciendo el shape en la página principal.

Figura 61) Aplicación SCADA con el shape ya creado.

Una vez que se tienen creados todos los elementos de control necesarios, es una práctica recomendable guardar la aplicación, para ello se pulsa el botón “GUARDAR” y se presentara una ventana emergente que solicitara al usuario el nombre que quiere dar al archivo y donde lo quiere guardar, tras cumplimentar ambas acciones la aplicación SCADA ya estará salvada y esperando a que en algún otro momento pueda ser cargada.

Figura 62) Ventana emergente que solicita la ruta en la que se quiere guardar la aplicación.

El siguiente paso es generar el código que necesita el chipKIT principal para poder gestionar tanto las comunicaciones con el PC como con los distintos módulos integrados en el bus CAN, así como la configuración de los pines de cada uno de los módulos que existen en la red CAN.

Para ello, se pulsa el botón “PROGRAMAR chpKIT”, la ventana emergente que aparece es la siguiente.


Memoria. 96

Figura 63) Ventana de programación y compilación chipKIT.

*Antes de realizar esta acción el usuario debe asegurarse que esta conectado el PC con la placa de desarrollo mediante el cable USB.

Una vez que aparezca el entorno de programación de chipKIT, el usuario deberá buscar la zona en la que ponga “Escriba el código programa a partir de esta zona” y ahí programar su algoritmo de control. Cuando ya lo tenga programado deberá cargar el programa a la placa, mediante la pulsación del botón:

Figura 64) Botón transferir.

En ese momento se comenzará a transferir el programa, mientras se este realizando esta acción no se debe modificar ninguna línea de la programación.


Memoria. 97

Figura 65) Programa transfiriéndose al chipKIT.

Una vez se ha transferido el programa de manera correcta, se pulsa el botón “CONECTAR” que permitirá establecer las comunicaciones entre los diferentes módulos y el panel SCADA. Inmediatamente después de realizar esta acción, saltará un aviso en el que se comunicará el estado de todos los módulos de la red CAN y el usuario deberá decidir si desea continuar o por el contrario reiniciar la conexión.

Figura 66) Estado de los módulos del bus CAN.

Figura 67) La aplicación funcionando.


Memoria. 98

8.3 Descripción de las comunicaciones.

A continuación se pasará a describir el enlace de comunicación CAN, el cual permitirá el intercambio de información entre los diferentes módulos y el panel SCADA. Dicha labor requiere de dos actores principales, la unidad master (módulo cero) y los slaves que se necesiten (módulos uno, dos y tres).

La unidad master tiene como misión: gestionar la configuración de los slaves, y transmitir al SCADA la información proveniente de los mismos.

Por su parte, las unidades slaves únicamente deberán estar reportando información de sus pines configurados como entradas y además, estar atentas a si el master les indica que deben cambiar el estado de sus pines de salida. Si el usuario decidierá que se le quiere integrar algún tipo de algoritmo de control, únicamente debería de programarlo en la zona destinada para ello.

Descripción de la programación que configura los slaves desde el módulo master.

Antes de proceder a la configuración de los slaves, es necesario realizar unos pasos previos:

1.-‐ Declaración de variables.

2.-‐ Definición de filtros.

3.-‐ Inicialización de los nodos.

4.-‐ Programación de funciones de utilidad CAN y comprobación de su estado.


Memoria. 99

Figura 68) Pasos previos a la configuración de los nodos.

Líneas de programación // Incluir librerías:

#include <WProgram.h>

#include "chipKITCAN.h"

#include <LiquidCrystal.h>

// inicializar la libreria con el numero de pins del interfaz

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// -------------------------------------------------------------

// Definición de constantes y variables locales

// -------------------------------------------------------------

// Direcciones de red de los nodos

//FILTROS

#define FILTROCONFIGURA_M1D 0x0100L //Filtro para configurar slave1

#define FILTROCONFIGURA_M1A 0x0101L //Filtro para configurar slave1


Memoria. 100





#define FILTROINFORMATIVO_FC_M1 0x0111L //Filtro indicar al módulo 1 que ya no le va a enviar más datos de configuración

#define FILTROINFORMATIVO_ACK_M1 0x1011L //Filtro que manda modulo 1 indicando al modulo 0 que ya esta configurado





#define FILTROINFORMATIVO_ESTADO_M1D 0x101100L //El modulo 1 me manda el estado de un pin digital



#define FILTROINFORMATIVO_ESTADO_M1A 0x101101L //El modulo 1 me manda el estado de un pin analogico


#define FILTROINFORMATIVO_ESTADO_M3A 0x301101L //El modulo 3 me manda el estado de un pin analógico

#define FILTROINFORMATIVO_CONTROL_M1A 0x011101L //El modulo 0 manda como quiere que ponga un pin analogico en el modulo 1



#define FILTROINFORMATIVO_CONTROL_M1D 0x011100L //El modulo 0 manda como quiere que ponga un pin digital en el modulo 1




Memoria. 101

#define modulo1can1 0x110L




// Definición de la frecuencia y de la velocidad

#define SYS_FREQ (80000000L)

#define CAN_BUS_SPEED 250000 // velocidad CAN

// ------------------------------------------------------------

// Variables globales

// ------------------------------------------------------------

// Interfaz de instancias del nodo controlador CAN

CAN canMod1(CAN::CAN1); // este objeto lo usa el modulo CAN1


byte DatosMsg[7];

// ------------------------------------------------------------

// Variables locales

// ------------------------------------------------------------

uint8_t REMOTA = 0x0C; // Indico si esta correcto el modulo

// Buffer de mensajes CAN

uint8_t CAN1MessageFifoArea [2 * 8 * 16];


// Flags indicadores de eventos de las rutinas de interrupción.

static volatile bool isCAN1MsgReceived = false;


// ------------------------------------------------------------

// Declaraciones directas

// ------------------------------------------------------------

void initCan1 (uint32_t myaddr);

void doCan1Interrupt();

void txCAN1remota(uint32_t rxnode, uint8_t dato); // función para envió de tramas remotas

void txCAN1(uint32_t rxnode, uint8_t dato0, uint8_t dato1, uint8_t dato2, uint8_t dato );


Memoria. 102

void rxCAN1remota(void); // función para recibir las tramas remotas

void rxCAN1(void);

// ------------------------------------------------------------

// Definición de procedimientos

// ------------------------------------------------------------

void setup(){

lcd.begin(16, 2); // inicializar LCD

lcd.print("PROYECTO"); // Escribir un mensaje en LCD

Serial.begin(9600); //Puerto serie, configuración

// Inicializar cada controlador CAN que va a ser usado. (En este caso solo se utiliza el CAN1)

// Instalar las rutinas de servicio de interrupción.

canMod1.attachInterrupt (doCan1Interrupt);


initCan1 (modulo0can1); //Inicialización de los diferentes nodos

initCan1 (modulo1can1);



//Comprobación de que los nodos conectados al bus can están correctos

txCAN1remota (modulo0can1, REMOTA); // función para envió de tramas remotas

delay(100); // Espera a que el carácter sea entregado

rxCAN1remota (); // función para recibir tramas remotas (dentro de esta función

// escribe el mensaje si esta activo o no lo esta)


Memoria. 103

txCAN1remota (modulo1can1, REMOTA);// función para envió de tramas remotas










rxCAN1remota ();// función para recibir tramas remotas (dentro de esta función


Serial.print(43,BYTE); // Dice cual es el estado de los modulos al panel SCADA

Serial.print(43,BYTE);


// FIN BUS CAN

Una vez cumplimentados los pasos previos anteriormente descritos, ya se puede comenzar a configurar uno a uno todos los módulos tal y como se expone a continuación.


Memoria. 104

Figura 69) Configuración de los nodos de la red CAN.

En el diagrama de flujo superior se observa que este proceso únicamente se ejecutará una vez, ya que cuando todo este correcto, la variable configurado pasará a estado TRUE, impidiendo de esta manera que se pueda volver a ejecutar el ciclo de configuración.

A continuación, se expondrá de manera detallada el bloque “Envio trama configuración de módulo 1”, que conceptualmente es exactamente igual que los dos bloques siguientes (“Envio trama configuración de módulo 2” y “Envio trama configuración de módulo 3”).


Memoria. 105

Figura 70) Subproceso para configuración de módulos.

Para que se pueda ejecutar este proceso, previamente el panel SCADA ha debido de programar los arrays que contienen los pines de entradas (tanto digitales como analógicas) con los que debe de trabajar cada módulo.

Estos arrays serán consultados dato a dato y se irán mandando a su módulo correspondiente a través de la siguiente trama.

FILTRO PIN

Figura 71) Trama de configuración de los slaves

En el campo filtro se enviará 01XX, el cero codifica el origen del envio, el uno codifica el destino y los dos siguientes informan de que es una trama de configuración en la que se manda el pin que deberá actuar como entrada analógica (01) o como entrada digital (00).

En el segundo campo se le manda el dato extraido del array, que es el pin a configurar como entrada analógica o digital.

En los dos siguientes pasos básicamente se hace lo mismo que lo expuesto anteriormente, salvo con la diferencia que en este caso se recorre el array que contiene los pines que actuarán como entradas analógicas.

Una vez recorridos ambos arrays, se informa al módulo correspondiente de que ya no se va a mandar más datos de configuración. Para ello se envía una trama como esta:


Memoria. 106

FILTRO 0xFF

Figura 72) Trama de fin de datos para configurar.

En el campo filtro se enviará 0111, los dos primeros bits indican lo mismo que en el anterior caso y los dos segundos indican que se trata de una trama informativa.

El segundo campo es algo fijo y que el chipKIT slave identificará como final de la configuración

Una vez enviada esta trama, el módulo cero se mantendrá a la espera de que el módulo 1 le informe de que ya ha sido configurado. El identificador que debe esperar el módulo cero para captar ese dato será 1011, es decir, origen módulo uno, destino módulo cero y dato informativo.

El segundo dato que le acompañara será un FF, que significa que todo esta correcto.

Si recibe la confirmación continua el ciclo de manera normal, si por el contrario no obtiene respuesta, volverá a intentar configurar el slave cero.

Líneas de programación. //CONFIGURACION DE LOS MODULOS INTEGRADOS EN EL BUS CAN.

byte tamano;

byte punteroCAN;

byte intentos;

if (CONFIGURADO == false){

otra: punteroCAN = 0; //MODULO 1

tamano = sizeof(PINES_MODULO1_ID)/4;

while (punteroCAN <= tamano){ //Le indico cuales son sus pines de entrada digitales

txCAN1(FILTROCONFIGURA_M1D,PINES_MODULO1_ID[punteroCAN],0,0);

punteroCAN = punteroCAN +1;

}

tamano = 0;

punteroCAN=0;

tamano = sizeof(PINES_MODULO1_IA)/4;

while (punteroCAN <= tamano){ //Le indico cuales son sus pines de entrada analógicos

txCAN1(FILTROCONFIGURA_M1A,PINES_MODULO1_IA[punteroCAN],0,0);


}


Memoria. 107

txCAN1(FILTROINFORMATIVO_FC_M1,0xFF,0x00,0x00); //Le indico que ya le he mandado todos los valores para que se configure

rxCAN1(DatosMsg); // Espero a que me confirme que esta configurado

if (DatosMsg[0] == FILTROINFORMATIVO_ACK_M1 && DatosMsg[1] == 0xFF ){

CONFIGURADOM1 = true;

goto M2;

}

else {

intentos = intentos +1;

if (intentos == 3){

goto M2;

}

else{

goto otra;

}

}

intentos = 0;

M2: punteroCAN = 0; //MODULO 2





}

tamano = 0;

punteroCAN=0;





}

txCAN1(FILTROINFORMATIVO_FC_M1,0xFF,0xFF,0xFF); //Le indico que ya le he mandado todos los valores para que se configure


Memoria. 108


if (DatosMsg[0] == FILTROINFORMATIVO_ACK_M2 && DatosMsg[1] == 0xFF){


goto M3;

}

else{


if (intentos == 10){

goto M3;

}

else{

lcd.setCursor(0, 1);

lcd.print(intentos);

goto M2;

}

}

intentos = 0;






}

tamano = 0;

punteroCAN=0;





}


Memoria. 109





goto M4;

}

else{



goto M4;

}

else{



goto M3;

}

}

M4: CONFIGURADO == true; //En realidad no se pondría configurado a true hasta que todos los modulos estarían OK!

}


Memoria. 110

Breve descripción funcional de la programación que transmite la información desde los módulos slaves hasta el panel SCADA.

Dicho de manera sencilla, el módulo cero (en el ámbito del CAN bus), denominado master, es el intermediario entre los slaves y el panel SCADA, ya que su labor (aparte de la ya vista) es transmitir al software de el estado de la planta y enviar a su vez a la planta, las órdenes de control, por medio del bus CAN. En las siguientes líneas, con el apoyo habitual de los diagramas de flujo, se mostrarán cuáles son los pasos para conseguir desarrollar estas funciones.

Figura 73) Proceso para recibir datos de módulos

Inicialmente, el panel SCADA ha debido programar previamente las tablas: ModuloX_IA y ModuloX_ID (la X puede tomar valores de 1, 2, 3). Más tarde se verá cual es el uso de estas tablas o arrays, cuyo contenido es: el pin y el estado que este presenta, es decir:

Modulo1_ID [ ] = {15, 1, 17, 0}; esto significa que el pin numero 15 esta a uno y el pin 17 a 0.

Partiendo de que estos arrays han sido creados, el primer paso es comprobar si existe dato para leer, en caso de ser así se lee y se comprueba a partir de su identificador si este dato interesa o no. Interesará todo dato que presente un identificador del tipo (1011XX o 2011XX o 3011XX) es decir, toda trama de tipo informativa. Esta trama presenta las siguientes estructuras.

FILTRO PIN ESTADO

Figura 74) Trama informativa del estado de un pin digital


Memoria. 111

FILTRO PIN MILES CENTENAS DECENAS UNIDADES

Figura 75) Trama informativa del estado de un pin analógico

Si los dos primeros bits del filtro son 00, es un dato digital, si por el contrario es 01, se trata de un dato analógico.

Una vez que se sabe el tipo de dato que es, se actualizan los arrays nombrados al principio. El objetivo de estos arrays es el siguiente: el master recibe la información de los distintos módulos, esa información la desgrana y con ella se actualiza el estado (Modulo1_ID [ ] = {15, 1, 17, 0} ) del array, este array será utilizado para enviar el estado de estos pines a través del puerto USB al panel SCADA.

Líneas de programación. // ZONA DESTINADA UNICAMENTE AL BUS CAN

// ------------------------------------------------------------

// Labores de intercambio con el CAN

// ------------------------------------------------------------

byte dato0;

byte dato1;

byte dato2;

byte dato3;

byte dato4;

byte dato5;

byte dato6;

int analogico;

int tipo;

if (isCAN1MsgReceived == false){

goto PROGRAMA;

}

rxCAN1(DatosMsg);

DatosMsg[0] = dato0; //leo el dato que me ha llegado

DatosMsg[1] = dato1;






Memoria. 112

tipo = dato0 & 100000L;

tipo = tipo >> 5;

if (dato0 == FILTROINFORMATIVO_ESTADO_M3A || dato0 == FILTROINFORMATIVO_ESTADO_M2A || dato0 == FILTROINFORMATIVO_ESTADO_M1A ){ //Filtro el mensaje para saber si es un dato que tengo que recoger

//Nos ha llegado un dato analógico

analogico = dato2 * 1000 + dato3 * 100 + dato4 * 10 + dato5;

switch (tipo){

case 1:

tamano = 0;

tamano = sizeof(MODULO1_IA)/4;

punteroCAN = 0;

while (punteroCAN <= tamano){

if (MODULO1_IA[punteroCAN] == dato1){


MODULO1_IA[punteroCAN] = analogico;

}


}

break;

case 2:

tamano = 0;


punteroCAN = 0;





}


}

break;

case 3:


Memoria. 113

tamano = 0;


punteroCAN = 0;





}


}

break;

break;

}

}

if (dato0 == FILTROINFORMATIVO_ESTADO_M3D || dato0 == FILTROINFORMATIVO_ESTADO_M2D || dato0 == FILTROINFORMATIVO_ESTADO_M1D ){ //Nos ha llegado un dato digital

switch (tipo){

case 1:

tamano = 0;

tamano = sizeof(MODULO1_ID)/4;

punteroCAN = 0;


if (MODULO1_ID[punteroCAN] == dato1){


MODULO1_ID[punteroCAN] = dato2;

}


}

break;

case 2:

tamano = 0;


punteroCAN = 0;


Memoria. 114





}


}

break;

case 3:

tamano = 0;


punteroCAN = 0;





}


}

break;

}

}

analogico = 0;

Descripción de la programación que transmite la información desde el SCADA hacia los módulos slaves.

Como ya se ha dicho desde el punto de vista del CANbus el módulo cero es un intermediario entre los slaves y el panel SCADA. Por lo tanto, la forma de transmitir la información entre el SCADA y los slaves es la siguiente: el SCADA transmite a través del puerto USB la información al módulo cero y este inmediatamente se la transmite al slave correspondiente a través de una trama informativa en la que manda el pin y el valor analógico (comprendido entre 0 y 255, por lo tanto únicamente se requiere de un byte para enviar esta información).

FILTRO PIN ESTADO

Figura 76) Trama de envio de controles a los módulos slaves.


Memoria. 115

Líneas de programación.

//Declaro variables para controles.

unsigned int dato; // variable con la que voy desapilando el buffer.

int num_led; //Me indica el LED a encender en los controles

int brillo; //Me indica el brillo que le quiero dar al LED en los controles analogicos

int estado; // Me indica el estado de los controles digitales

//Declaro variables para indicadores

int punteroindicadoresdig;

int datoindic; // Dato que le mando a VB para informarle de 7 en 7 del estado de los indicadores

int datoindic2; // Dato que le mando a VB para informarle de 7 en 7 del estado de los indicadores

int datoindic3;

int datoindic4;

int datoindic5;

int datoindic6;

int datoindic7;

int datoindic8;

int datoindic9;

int datoindic10;

int checksum; //Dato con el que comparo a ver si puedo comenzar a enviar el estado de los indicadores

datoindic =0;

checksum = 0;

datoindic2 = 0;

datoindic3 = 0;

datoindic4 = 0;

datoindic5 = 0;

datoindic6 = 0;

datoindic7 = 0;

datoindic8 = 0;

datoindic9 = 0;

datoindic10 = 0;


Memoria. 116

int punteroindicadoresanalog;

int checksumanalog;

checksumanalog = 0;

//MAPA DE MEMORIA

int zonas_controles_digitales[80]; //ZONA EN LA QUE ESTA EL ESTADO DE LOS CONTROLES DIGITALES, ORDENADOS POR PINES. EJ 46 VALOR, ESTADO DEL PIN 46

int zonas_controles_analogicos[11]; //ZONA EN LA QUE ESTA EL ESTADO DE LOS CONTROLES ANALOGICOS, SE ORDENAN DE LA MISMA MANERA QUE EN EL ANTERIOR

int zonas_indicadores_digitales[80]; //ZONA EN LA QUE SE ENCUENTRA EL ESTADO DE LOS INDICADORES DIGITALES, ORDENADOS POR LOS PINES INDICADOS EN LA VARIABLE ARRAY. EL PRIMER VALOR

int i=0; // SERA EL ESTADO DEL PIN 33.

for(i=0; i<80; i++){

zonas_indicadores_digitales[i]=0;

}

int zonas_indicadores_analogicos[16]; //ZONA EN LA QUE SE ENCUENTRA EL ESTADO DE LOS INDICADORES ANALOGICOS

//Zona en la que se va a leer el buffer de entrada, para poder actualizar los controles.

if(Serial.available()) {

while (Serial.available()>0){ //Modulo 0

dato = Serial.read(); //read Serial

if (dato == 0){


if ((dato & 0x01)== 1){

num_led = (dato & 0x7E)>>1;

//delay(1000);


brillo = dato;

analogWrite(num_led,brillo);

zonas_controles_analogicos[num_led] = brillo;

}


Memoria. 117

else{

num_led = (dato & 0x7E) >>1;

//delay(1000);

estado = (dato & 0x80) >> 7;

digitalWrite(num_led,estado);

zonas_controles_digitales[num_led] = estado;

}

}

if (dato == 1){ //Envia por bus can los datos al modulo 1


lcd.print("MODULO 1");


if ((dato & 0x01)== 1){



brillo = dato;

txCAN1(FILTROINFORMATIVO_CONTROL_M1A, num_led,brillo,0);

}

else{


estado = (dato & 0x80) >> 7;

txCAN1(FILTROINFORMATIVO_CONTROL_M1D, num_led,estado,0);

}

}






Memoria. 118

if ((dato & 0x01)== 1){



brillo = dato;


}

else{


estado = (dato & 0x80) >> 7;


}

}





if ((dato & 0x01)== 1){



brillo = dato;


}

else{


estado = (dato & 0x80) >> 7;


}

}

}

}


Memoria. 119

Descripción de la programación con la que los slaves se configuran.

Ya se ha estudiado la forma en la que se envían las tramas de configuración desde el master hasta los slaves. Ahora se expondrá los pasos que permiten al slave recibir esa información y procesarla para configurarse.

De nuevo se puede ver que el proceso de recepción de datos es muy idéntico al ya visto para la transmisión slave-‐master, con la excepción en este caso que una vez descodifica si se trta de una dato de tipo analógico o digital, lo siguiente que hace es configurar ese pin como entrada y además actualizar la tabla Modulo_IA que le servirá al slave para saber que pines debe leer continuamente con el objetivo de reportar esa información al master.

Destacar que el slave tomará su valor de módulo (y esto afecta directamente a los datos que le interesan), en función del estado que presenten los switches de su placa principal. Es decir, si sus switches están dispuestos de tal manera que el microprocesador lee un tres, deberá captar aquellos datos cuyo identificador presenta un 03XX.

Así mismo es importante tener presente que las líneas de código que aparecen a continuación ya no son generadas por la aplicación SCADA, sino que están generadas previamente por el desarrollador y precargadas en los distintos módulos de la red CAN. Es decir, existen dos tipos de programas, los primeros, generados por el panel SCADA y cargados a través del puerto USB al


Memoria. 120

módulo cero y los segundos, que ya viene precargado en cada uno de los módulos slaves.

Además, en este segundo programa, se destina un espacio para dar la posibilidad al usuario de programar su propio algoritmo de control, que correra únicamente en el módulo que lo haya programado. De darse esta situación, se estaría configurando una red descentralizada de módulos de entrada/salida inteligentes.

Programación que permite al slave saber cual es su módulo.

int valor_analogico;

byte dato;

byte datomodulo1;

pinMode(11,INPUT); // A estos pines estan conectados los switches

pinMode(12,INPUT);

pinMode(83,INPUT);

pinMode(84,INPUT);

pinMode(85,INPUT);

dato = digitalRead(11);

datomodulo1 = dato << 4;


datomodulo1 = (dato << 3)+ datomodulo1;

dato = 0;


datomodulo1 = (dato << 2) + datomodulo1;

dato = 0;



dato = 0;


datomodulo1 = dato + datomodulo1;

dato = 0;

switch (dato){

case 1:


Memoria. 121

//FILTROS

#define FILTROCONFIGURA_M1D 0x0100L; //Filtro para configurarme

#define FILTROCONFIGURA_M1A 0x0101L; //Filtro para configurarme

#define FILTROINFORMATIVO_FC_M1 0x0111L; //Filtro con el que me indica el modulo 0 que ya no me va a enviar más datos de configuración

#define FILTROINFORMATIVO_ACK_M1 0x1011L; //Filtro que mando al modulo 0 para decirle que ya estoy configurado configurado

#define FILTROINFORMATIVOESTADOM1D 0x1011L; //Mando el estado de un pin digital al modulo 0

#define FILTROINFORMATIVOESTADOM1A 0x1011L; //Mando el estado de un pin analogico al modulo 0

#define FILTROINFORMATIVO_CONTROL_M1A 0x011101L; //El modulo 0 me manda como quiere que ponga un pin analogico

#define FILTROINFORMATIVO_CONTROL_M1D 0x011100L; //El modulo 0 me manda como quiere que ponga un pin digital

break;

case 2:

//FILTROS





#define FILTROINFORMATIVO_ESTADO_M1D 0x201100L; //Mando el estado de un pin digital al modulo 0

#define FILTROINFORMATIVO_ESTADO_M1A 0x201101L; //Mando el estado de un pin analogico al modulo 0



break;


Memoria. 122

case 3:

//FILTROS









break;

}

Programación que le permite al slave configurarse. // Instalar las rutinas de servicio de interrupción.


ESPERA1: if (isCAN1MsgReceived == false){

// CAN1 no recibio ningún mensaje para salir de la función, nos mantenemos a la espera

goto ESPERA1;

}

rxCAN1(DatosMsg);

dato0 = DatosMsg[0]; // almaceno del dato

dato1 = DatosMsg[1];



if (dato0 == 0x01){ // El dato que acaba de llegar me interesa ¡¡¡¡¡ESTA ES LA VARIABLE A MODIFICAR PARA CADA MODULO!!!!


Memoria. 123

if (dato2 == 0xFF){ // Si le llega ese dato es que ya se ha configurado y se lo remite al modulo0

goto CONFIGURADO;

}

else{

pinMode(dato1,INPUT);

switch(dato2){

case 0:

MODULO_ID[punteroID] = dato1;

punteroID = punteroID +1;

break;

case 1:

MODULO_IA[punteroIA] = dato1;

punteroIA = punteroIA +1;

break;

}

goto ESPERA1; // No ha terminado de configurarse así que debe de leer otra vez

}

}

CONFIGURADO: txCAN1(modulo0, 0xFF,0xFF,modulo1,0x00,0x00,0x00);

// YA ESTA CONFIGURADO Y PUEDE COMENZAR A TRABAJAR EN EL LOOP

Ahora se expone como reporta la información al master para que se vea monitorizada en el panel SCADA.

// Leo entradas digitales y le remito su estado al modulo0 // En primer lugar obtengo el tamaño de MODULO_ID

byte valor_analogico;

tamano = sizeof(MODULO_ID)/4;

punteroID = 0;

dato0 = 0;

dato1 = 0;

dato2 = 0;

while (punteroID <= tamano){ // recorro MODULO_ID leyendo el dato de cada uno de los pines y remitiendoselo a modulo0

dato2=digitalRead (MODULO_ID[punteroID]);

modulo0 = FILTROINFORMATIVOESTADOM1A;

txCAN1(modulo0, MODULO_ID[punteroID],0x00,0x00,0x00,0x00,0x00);


Memoria. 124


}

tamano = sizeof(MODULO_IA)/4;

punteroIA = 0;

while (punteroIA <= tamano){ // recorro MODULO_IA leyendo el dato de cada uno de los pines y remitiendoselo a modulo0

valor_analogico = analogRead (MODULO_IA[punteroIA]);


txCAN1(modulo0, MODULO_IA[punteroIA], miles, centenas, decenas, unidades,0x00);


}


Memoria. 125

Descripción de las funciones de utilidad CAN, a través de las cuales se puede mandar datos y recibirlos.

// ------------------------------------------------------------

// Funciones de utilidad CAN

// ------------------------------------------------------------

// Descripción:

// Inicializa el controlador CAN.

void initCan1(uint32_t myaddr)

{

CAN::BIT_CONFIG canBitConfig;

// Paso 1: Activa los switch del modulo CAN y los switch de modo de configuración.

// Espera a que este completo.

canMod1.enableModule(true);

canMod1.setOperatingMode(CAN::CONFIGURATION);

while(canMod1.getOperatingMode() != CAN::CONFIGURATION);

/* Paso 2: Configura el reloj del modulo CAN. La función CAN::BIT_CONFIG la estructura de datos se utiliza

* para este propósito. La propagación, la fase del segmento 1 y segmento 2 están configuradas con 3TQ.

* La función CANSetSpeed(), establece la velocidad en baudios.*/

canBitConfig.phaseSeg2Tq = CAN::BIT_3TQ;


canBitConfig.propagationSegTq = CAN::BIT_3TQ;

canBitConfig.phaseSeg2TimeSelect = CAN::TRUE;

canBitConfig.sample3Time = CAN::TRUE;

canBitConfig.syncJumpWidth = CAN::BIT_2TQ;

canMod1.setSpeed(&canBitConfig,SYS_FREQ,CAN_BUS_SPEED);

/* Paso 3: Asignación del área del buffer al modulo CAN.*/

/* Nota tenga en cuenta el área de cada canal.

** Se trata de 2 (Canales) * 8 (Buffer de mensaje) * 16 (bytes/por buffer de mensaje) bytes. Cada modulo

** CAN debe tener un mensaje propio. */


Memoria. 126

canMod1.assignMemoryBuffer(CAN1MessageFifoArea,2 * 8 * 16);

/* Paso 4: Configuración del canal 0 para TX y tamaño de 8 buffer de mensajes con prioridad baja media.

* Configurar el canal 1 para RX y el tamaño de los 8 buffer de mensaje y recibir el mensaje completo. */

canMod1.configureChannelForTx(CAN::CHANNEL0,8,CAN::TX_RTR_DISABLED,CAN::LOW_MEDIUM_PRIORITY);

canMod1.configureChannelForRx(CAN::CHANNEL1,8,CAN::RX_FULL_RECEIVE);

// Paso 5 : Configurar filtros y mascaras. Configurar el filtro 0, mensajes a aceptar SID con ID= 0x100,

// ID=0x110, ID=0x120, …

// Configurar la mascara del filtro 0 y comparar todos los bits del ID y para filtrar el tipo de identificador se

// hace en la especificación de la configuración del filtro. Los mensajes aceptados por el filtro son

// almacenados en el canal 1. */

canMod1.configureFilter (CAN::FILTER0, myaddr, CAN::SID);

canMod1.configureFilterMask (CAN::FILTER_MASK0, 0xFFF, CAN::SID, CAN::FILTER_MASK_IDE_TYPE);

canMod1.linkFilterToChannel (CAN::FILTER0, CAN::FILTER_MASK0, CAN::CHANNEL1);

canMod1.enableFilter (CAN::FILTER0, true);

/* Paso 6: Habilitación interrupciones y eventos. Enable the receive channel not empty event (channel

* event ) and the receive channel event (module event).

* The interrrupt peripheral library is used to enable the CAN interrupt to the CPU. */

canMod1.enableChannelEvent(CAN::CHANNEL1, CAN::RX_CHANNEL_NOT_EMPTY, true);

canMod1.enableModuleEvent(CAN::RX_EVENT, true);

/* Paso 7: Cambiar el modo de CAN a modo normal. */

canMod1.setOperatingMode(CAN::NORMAL_OPERATION);

while(canMod1.getOperatingMode() != CAN::NORMAL_OPERATION);

}


Memoria. 127

/*** txCAN1remota

**

** Descripción:

** Inicializa un buffer de paquetes con la cabecera y carga el paquete. La carga útil no es ninguna por

** en la trama remota es para ver si el nodo esta activo o no (solamente ID, RTR=1, y sin datos)*/

void txCAN1remota(uint32_t rxnode, uint8_t dato) // en la variable piso va metido el bit que quiero que

// se ponga a 1 cuando pulsas el piso correspondiente

// cada vez..

{

CAN::TxMessageBuffer * message;

message = canMod1.getTxMessageBuffer(CAN::CHANNEL0); /*Se coge del CHANNEL0 por que es el que

/* IMPORTANTE lo que envía cuando se

* pulsa hay que meterlo en el CHANEL0 */

if (message != NULL)

{

// limpiar el buffer

message->messageWord[0] = 0;




message->msgSID.SID = rxnode; //recepción del nodo (rxnode es el nodo que lo recibe, es decir

// a quien se lo envió)

message->msgEID.IDE = 0; //BIT IDE = trama estándar = 0, trama extendida = 1

message->msgEID.RTR = 1; //RTR a recesivo por ser trama remota

message->msgEID.DLC = 0; // BIT DLC = longitud de los datos


Memoria. 128

//message->data[0] = 0x00; // datos, la trama remota no envía nada

//message->data[1] = 0x00;







/* Esta función permite que el modulo CAN pueda saber como va el proceso del mensaje y cuando el

* mensaje esta listo para ser procesado. */

canMod1.updateChannel(CAN::CHANNEL0);

/* Modulo CAN directo para limpiar el canal TX . Esto envía algún mensaje pendiente en el canal TX . */

canMod1.flushTxChannel(CAN::CHANNEL0);

}

}


Memoria. 129

/* ------------------------------------------------------------ */

/*** txCAN1

**

** Descripción:

** Inicializa un buffer de paquetes con la cabecera y carga el paquete. La carga útil en este caso es solo un ** carácter ASCII (0x31 = '1'). Transmite el paquete.*/

void txCAN1(uint32_t rxnode, uint8_t dato0, uint8_t dato1, uint8_t dato2) // en la variable piso va metido el bit que quiero que se ponga a

// 1 cuando pulsas el piso correspondiente cada vez.

{



* hemos configurado para transmitir




{






message->msgSID.SID = rxnode; // recepción del nodo (rxnode es el nodo que lo recibe, es decir



message->msgEID.RTR = 0; // RTR a dominante

message->msgEID.DLC = 3; // BIT DLC = numero de bytes a mandar por dato

message->data[0] = dato0; // dato un solo byte lo que quiero enviar en este caso seria :

message->data[1] = dato1;


Memoria. 130


//message->data[3] = dato3;










}

}


Memoria. 131

//------------------------------------------------------------------------------------------------------------------------------------

//** rxCAN1remota ** ** Descripción:

//Comprueba si el nodo esta activo o no. Si esta activo imprime un mensaje indicando que esta correcto ** y sino es así imprime mensaje indicando de que es incorrecto por el monitor serie.*/

void rxCAN1remota(void)

{

CAN::RxMessageBuffer * message;


return;

}

//compruebo que si que ha llegado mensaje // si no ha llegado mensaje pongo NODO INACTIVO

/* Mensaje ha sido recibido. Resetear los flags de isCAN1MsgReceived para recibir el siguiente mensaje. */

isCAN1MsgReceived = false;

message = canMod1.getRxMessage(CAN::CHANNEL1);

/* Llamar a la función CAN::updateChannel() para que el modulo CAN pueda saberlo que se hace en el * proceso del mensaje. Habilitar el evento para que cuando el modulo CAN genere una interrupción cuando * ocurre el evento.*/



}


Memoria. 132

/* ------------------------------------------------------------------------------------------------------------------------------------------------ *

/ /*** rxCAN1 ** ** Descripción:

** Comprueba si el paquete ha sido recibido. Si es así leer el paquete recibido e imprimir la carga del ** paquete por el monitor seria.*/

void rxCAN1(byte DatosMsg[ ]) {


if (isCAN1MsgReceived == false)

{ /* CAN1 no recibió ningún mensaje para salir de la función. Saltamos a ERRORCAN*/ //Seguridad_mal=1;

DatosMsg[0]= 0;

DatosMsg[1]= 0;

return ; }



message = canMod1.getRxMessage(CAN::CHANNEL1); /* Imprime el primer byte del área del paquete cargado como un carácter ASCII por el monitor serie. */ Serial.print( DatosMsg [0]);




DatosMsg[0]= (message->data[0]);








return ;

}


Memoria. 133

/* --------------------------------------------------------------------------- */

/* Manejador de las funciones de interrupción */

/* --------------------------------------------------------------------------- */

/*** doCan1Interrupt

**

** Descripción:

** Rutina de servicio de interrupción para manejar el nivel de los eventos de interrupción para el modulo ** CAN1.*/

void doCan1Interrupt()

{

/* Este es el controlador de las interrupciones CAN1. Esto no es la rutina actual de interrupción, sino que es

* el manejador de interrupciones de usuario instalado por CAN::attachInterrupt. Esto es llamado por el ISR.

* Ten en cuenta que hay muchos eventos en el modulo CAN1 que pueden causar esta interrupción. Estos

* eventos son activados por la función CAN::enableModuleEvent() .

* En este ejemplo solo CAN::RX_EVENT esta habilitado. */

/* Comprobar si el origen de la interrupción es la función CAN::RX_EVENT.

* Esto es redundante ya que solo este evento esta habilitado en este ejemplo, pero esto muestra un

* esquema para la manipulación de las interrupciones. */

if ((canMod1.getModuleEvent() & CAN::RX_EVENT) != 0)

{

/* En este marco, se pueden comprobar los hechos que ocasionaron la interrupción con la función

* CAN::getPendingEventCode() para obtener alta prioridad del evento activo.*/

if(canMod1.getPendingEventCode() == CAN::CHANNEL1_EVENT)

{

/* Esto significa que el canal 1 ha causado un evento.

* El CAN::RX_CHANNEL_NOT_EMPTY es un evento persistente. Tu puedes leer el canal en el ISR para


Memoria. 134

* borrar la condición del evento o deshabilitar el origen del evento y establecer una bandera para

* indicar que un mensaje se ha recibido. El evento puede ser habilitado por la aplicación cuando se ha

* procesado un mensaje.

* Ten en cuenta que la salida del evento habilitado podría causar que la CPU mantenga la ejecución de la

* ISR ya que CAN::RX_CHANNEL_NOT_EMPTY es un evento persistente. (a menos que la condición no

* este vacía, se borra.) */

canMod1.enableChannelEvent(CAN::CHANNEL1, CAN::RX_CHANNEL_NOT_EMPTY, false);

isCAN1MsgReceived = true;

}

}

/* La bandera de interrupción del CAN1 se limpia por la rutina de servicio de la interrupción después lo

* devuelve la función. Esto sucederá porque la causa del evento de la interrupción

* (CAN::RX_CHANNEL_NOT_EMPTY) esta deshabilitado .

* El intento del ISR's de borrar el flag de interrupción seria un error en el caso de que

* CAN::RX_CHANNEL_NOT_EMPTY este habilitado, porque el evento todavía esta presente. En este caso

* otra interrupción podría ocurrir inmediatamente */

}


Memoria. 135

9. Posibles vías de ampliación.

Como se ha dicho al principio del presente documento se pretende obtener una aplicación software de código abierto, para el desarrollo de aplicaciones de control y monitorización industrial, como alternativa abierta de bajo coste.

Por ello, se contempla como una línea de ampliación imprescindible adaptar este software a otros sistemas operativos. Sería interesante desarrollar esta aplicación para Linux, de esta manera se conseguería una solución full open.

Además, esta línea de desarrollo es totalmente viable, ya que existe un software, KBasic, de código abierto que trabaja en Linux y OS X Lion. Debido a que KBasic ha mantenido la similitud con visual basic en la mayoría de los aspectos, no sería muy costoso en tiempo, hacer el cambio.

Visto esto puede parecer que haya sido un error desarrollar la aplicación para Windows, sin embargo, el SO Windows es el que mayor número de usuarios presenta y esta es la razón principal de porque ha sido desarrollado en esta plataforma.


Memoria. 136

Logroño, a 3 de Septiembre de 2013.

Fdo: Alberto Martínez Inchusta.

Anexos

Índice de Anexos. 1. Anexo 1. Características técnicas de los componentes electrónicos usados en el hardware de las placas. .................................................................................................................... 1 1.1. ADG 5412. ................................................................................................................................. 1 1.2. Amplificador LM358. ........................................................................................................... 3 1.3. Amplificador MC7915. ........................................................................................................ 5 1.4. Amplificador LM7815. ........................................................................................................ 6 1.5. Convertidor RCV 420. .......................................................................................................... 7 1.6. Optoacoplador 4N25. .......................................................................................................... 8 1.7. Zener 1N4733A. ..................................................................................................................... 9 1.8. Driver FOD 8321. ............................................................................................................... 10 1.9. Optotriac MOC 3021. ........................................................................................................ 12

2. Anexo 2. Hardware y software del CAN bus. .................................................................. 14 2.1. chipKIT MAX32. .................................................................................................................. 16 2.2. Transceiver MCP2551. ..................................................................................................... 16 2.3. Código del módulo 0. ........................................................................................................ 17 2.4. Código del resto de módulos. ........................................................................................ 56

3. Anexo 3. Código de la aplicación SCADA. ......................................................................... 73 4. Anexo 4. Contenido del cd adjunto. .................................................................................... 74

Nota.

Los anexos que aparecerán a continuación contienen características técnicas de todos los componentes electrónicos.

Las características técnicas aquí expuestas, son aquellas que se han considerado más importantes. Si se desea aumentar esta información consúltese la carpeta “Datasheets del hardware” incluida en el CD adjunto.

Controlador modular programable basado en procesadores de 32 bits y CAN bus.

Anexos 1

1. Anexo 1. Características técnicas de los componentes electrónicos usados en el hardware de las placas.

1.1. ADG 5412.

El ADG5412/ADG5413 contiene cuatro interruptores independientes single-‐pole/single-‐throw (SPST). Los conmutadores ADG5412 se activan con lógica positiva, mientras que el ADG5413 presenta dos interruptores con lógica positiva y otros dos con lógica negativa, ideal para este proyecto.

Cada switch puede trabajar en ambas direcciones cuando está encendido, y cada interruptor tiene un rango de señal de entrada que se extiende a la salida. En el estado de apagado, no llega ninguna tensión a la otra parte..

Diagrama de bloques funcionales.

Figura 1) Figura explicativa de cómo trabaja el ADG 5412.


Anexos 2

Valores máximos.

Figura 2) Valores máximo


Anexos 3

Configuración de los pines.

1.2. Amplificador LM358.

Amplificador operacional doble, que permite trabajar desde rangos tan bajos como 3 voltios hasta 32 voltios. Este tipo de componentes pueden trabajar con los populares MC1558 entre otros o con el MC7915 como en el presente proyecto.

Distribución de los pines.

Figura 3) Distribución de pines


Anexos 4

Tipos de encapsulados que presenta.

Figura 4) Tipos de encapsulados

Valores máximos.

Figura 5) Máximos rangos en los que puede trabajar.


Anexos 5

1.3. Amplificador MC7915.

Regulador de tensión utilizado para adecuar voltajes. En el presente proyecto es usado junto al MC7915 para adaptar los 24 y -‐24 voltios que entran a la placa principal a +/-‐ 15 voltios, que alimentará a muchos de los módulos.

Aplicación de nota, usada en la fuente de alimentación de la placa principal.

Figura 6) Conversión de 24 voltios a 15 voltios tanto positivos como negativos.

Esquema de sus pines y encapsulados.

Figura 7) Encapsulados.


Anexos 6

Valores máximos.

1.4. Amplificador LM7815.

Como ya se ha dicho más arriba la funcionalidad de este elemento es idéntica al MC7915.

Pines y encapsulado.

Figura 8) Configuración de los pines y encapsulados.

Valores máximos.

Figura 9) Valores máximos.


Anexos 7

1.5. Convertidor RCV 420.

Este componente convierte intensidad en tensión, en concreto convierte valores de entrada comprendidos entre los 4 y 20 mA a 0 o 5 voltios a la salida.

Distribución de los pines.

Figura 10) Distribución de los pines del RCV 420

A continuación se exponen varios datos como son, valores máximos, encapsulados y la configuración de los pines.

Figura 11) Datos más destacables del presente componente.


Anexos 8

1.6. Optoacoplador 4N25.

El siguiente componente es utilizado en los módulos de entradas digitales con el objetivo de aislar a la placa chipKIT MAX 32, a continuación se van a analizar sus características, ya que junto con el zener es el componente que marca las limitaciones de los módulos ya citados.

Diagrama en el que se muestra las diferentes partes que componen el opto.

Figura 12) Diagrama en el que se muestran los pines y otro en el que se observa el funcionamiento.

Valores máximos.

Figura 13) Valores máximos a tener en cuenta.


Anexos 9

1.7. Zener 1N4733A.

Pieza clave en los módulos de las entradas digitales ya que trabaja como regulador, consiguiendo de esta manera que si no existe una tensión mayor que 5.1 voltios en los borneros de entradas, no permite que el optoacoplador antes mencionado conduzca y por lo tanto no llega tensión al pin del chipKIT MAX32.

Valores máximos a los que puede trabajar.

Figura 14) Valores máximos

Características eléctricas.

Figura 15) Datos importantes para hacer trabajar al zener.


Anexos 10

1.8. Driver FOD 8321.

El driver FOD 8321, eleva la tensión que recibe en sus pines de entrada, además aporta hasta 2.5 A y todo esto con grandes tiempos de conmutación. Es por ello, por lo que se denominan módulos de salidas digitales máximas.

A continuación se expondrán datos que corroborarán el gran potencial de este driver, que ha sido utilizado también en las salidas analógicas, que como se saben son PWM y por lo tanto si se trabaja con una frecuencia de onda cuadrada muy rápida no se tendría ningún problema.

Esquema funcional.

Figura 16) Esquema funcional.

Configuración de pines.

Figura 17) Configuración de pines.


Anexos 11

Valores máximos.

Figura 18) Rangos máximos.

Aplicación de nota empleada para diseñar las salidas digitales rápidas.

Figura 19) Application Note.


Anexos 12

1.9. Optotriac MOC 3021.

Este elemento tiene como misión principal permitir al usuario trabajar también con tensiones alternas. Así mismo requiere del apoyo de un triac, para poder elevar la tensión de trabajo que como se va a exponer a continuación son bastante elevadas.

Encapsulado y pines.

Figura 20) Tipo de encapsulado y el esquema del componente.


Anexos 13

Máximos valores.

Figura 21) Valores máximos..


Anexos 14

2. Anexo 2. Hardware y software del CAN bus.

CAN (“Controller Area Network), bus serie patentado por la compañía Robert Bosch (1982). Inicialmente se pensó en el como bus de campo, pero donde realmente encontró utilidad fue en el sector del automóvil y la industria, para interconectar el bus de confort, seguridad, etc.

El Mercedes Clase E fue el primer coche en incorporar el bus CAN, 10 años después(1992). Fue diseñado para permitir la comunicación fiable entre centralitas electrónicas basadas en microcontrolador, ECUs (“Electronic Control Unit”) y reducir cableado.

En Europa se ha convertido en un estándar “de facto”, con carácter internacional y documentado por normas ISO (ISO11898).

Ventajas: reducción de costes, mejora flexibilidad.

El bus CAN es un protocolo serie asíncrono del tipo CSMA/CD (“Carrier Sense Múltiple Access hit Collision Detection”).

El bus es un medio compartido (multiplexado).

Se trata de un protocolo “Multicast”, es decir, todo el mundo puede hablar (de uno en uno) y escuchar.

“CSMA”: cada nodo de la red debe monitorizar el bus y si detecta que no hay actividad, puede enviar un mensaje.

“CD”: si 2 nodos de la red comienzan a transmitir un mensaje, ambos detectan la colisión. Un método de arbitración basado en prioridades resuelve el conflicto.

Se utiliza un par de cables trenzados (bus diferencial) para conseguir alta inmunidad a las interferencias electromagnéticas (EMIs). En algunos casos puede ir apantallado.

La impedancia característica de esta línea es del orden de 120Ω por lo que se emplean impedancias (resistencias) de este valor para en ambos extremos del bus para evitar ondas reflejadas y que el bus se convierta en una antena.

Longitud máxima de 1000m (a 40Kbps).

Velocidad máxima de 1Mbps (con una longitud de 40m).

En los coches se utiliza a 125kbit/s y a 500kbit/s.


Anexos 15

Capas modelo OSI.

Figura 22) Modelo OSI

Capa física.

La capa física es la responsable de la transferencia de bits entre distintos módulos que componen la red. Definen aspectos como niveles de señal, codificación, sincronización, etc...

Las características de las señales eléctricas en el bus fueron establecidas por el Standard ISO 11898.

Los módulos conectados al bus interpretan dos niveles lógicos:

Dominante: la tensión diferencial (CAN_H = 3,5V – CAN_L = 1,5V) es del orden de 2 voltios.

Recesivo: la tensión diferencial (CAN_H = CAN_L = 2,5 V) es del orden de 0 voltios.

Otra de las partes a destacar el la velocidad a la que se transmiten los mensajes en la red, en la tabla se muestran las velocidades según las distancias (son orientativos):


Anexos 16

Capa enlace.

Una de las características que distingue a CAN de otras normas es su técnica de acceso al medio que se denomina CSMA/CD, técnica de contienda.

El acceso al medio por medio de técnicas de acceso múltiple y detección de conflicto evolucionaron y ahora CAN añade la resolución de colisión, CAN resuelve la colisión con la supervivencia de una de las tramas que es la de mayor prioridad.

La resolución se hace aplicando una función lógica determinista a cada bit, que se resuelve con la prioridad del nivel definido como bit de tipo dominante y se hace realizando una función AND de todos los bits transmitidos simultáneamente. Cada transmisor escucha continuamente el valor que hay en el bus y se retira cuando dicho valor no coincide con el que dicho transmisor a forzado, si hay coincidencia continúa. Sobrevive el de mayor prioridad.

2.1. chipKIT MAX32.

La placa chipKIT MAX32 se encuentra presente en todos los módulos de la red CAN y existe poco más que añadir sobre ella.

2.2. Transceiver MCP2551.

chipKIT 32MAX, presenta entre sus funcionalidades la posibilidad de implementar dos CAN bus. Para ello, se encuentra dotada de dos controladores CAN, no así de transceiver. En este caso se empleará el MCP 2551, cuyas principales características son:

Bloque de diagramas.

Figura 23) Bloque de diagramas.


Anexos 17

Pines.

Figura 24) Pines del MCP 2551

Valores máximos.

2.3. Código del módulo 0. // Incluir librerías:






// ------------------------------------------------------------------------


// ------------------------------------------------------------------------



Anexos 18

//FILTROS




























Anexos 19






// ------------------------------------------------------------


// ------------------------------------------------------------




byte DatosMsg[7];

// ------------------------------------------------------------


// ------------------------------------------------------------








// ------------------------------------------------------------


// ------------------------------------------------------------






void rxCAN1(void);

// ------------------------------------------------------------

// Definición de procedimientos

// ------------------------------------------------------------


Anexos 20

void setup(){




// -------------------------Inicializar cada controlador CAN que va a ser usado. (En este caso solo se utiliza el CAN1)




initCan1 (modulo0can1); //Inicialización de los diferentes nodos




// -------------------------Comprobación de que los nodos conectados al bus can están correctos












Anexos 21







Serial.print(43,BYTE); // Dice cual es el estado de los modulos al panel SCADA



// FIN BUS CAN

//-----------------------------------------------------------------------------------

// ZONA DE ENTRADAS Y SALIDAS

//------------------------------------------------------------------------------------

pinMode(10,OUTPUT); //Control analogico

analogWrite(10,0);


analogWrite(6,0);


analogWrite(6,0);

pinMode(0,INPUT); //Indicador analogico



pinMode(33,INPUT); //Indicador digital



pinMode(25,OUTPUT); //Control digital

digitalWrite(25,0);


digitalWrite(25,0);



Anexos 22

digitalWrite(30,0);

}

void loop(){

unsigned int MODULO1_ID[] = {35,0}; // Array de indicadores digitales del modulo 1

unsigned int PINES_MODULO1_ID[] = {35}; // Array de indicadores digitales del modulo 1

unsigned int MODULO2_ID[] = {}; // Array de indicadores digitales del modulo 2

unsigned int PINES_MODULO2_ID[] = {}; // Array de indicadores digitales del modulo 2

unsigned int MODULO3_ID[] = {}; // Array de indicadores digitales del modulo 3

unsigned int PINES_MODULO3_ID[] = {}; // Array de indicadores digitales del modulo 3

unsigned int MODULO1_IA[] = {1,0}; // Array de indicadores analogicos del modulo 1

unsigned int PINES_MODULO1_IA[] = {1}; // Array de indicadores analogicos del modulo 1

unsigned int MODULO2_IA[] = {}; // Array de indicadores analogicos del modulo 2

unsigned int PINES_MODULO2_IA[] = {}; // Array de indicadores analogicos del modulo 2

unsigned int MODULO3_IA[] = {}; // Array de indicadores analogicos del modulo 3

unsigned int PINES_MODULO3_IA[] = {}; // Array de indicadores analogicos del modulo 3

unsigned int cantidad =3; // Cantidad de indicadores digitales

unsigned int cantidadanalog =3; // Cantidad de indicadores analogicos

unsigned int pines_digi_entrada[] = {33,0,35,0,35,1}; // Array de indicadores digitales

unsigned int pines_analog_entrada[] = {0,0,1,0,1,1}; // Array de indicadores analogicos

//-------------------------------------------------------------------------------------------------------------------

//ZONA DE COMUNICACIONES. NO REALIZE NINGÚN CAMBIO POR FAVOR.

//-------------------------------------------------------------------------------------------------------------------

//Declaro variables para BUS CAN

boolean CONFIGURADO;

boolean CONFIGURADOM1;



int PIN;

int MODULO;

//-------------------CONFIGURACION DE LOS MODULOS INTEGRADOS EN EL BUS CAN.

byte tamano;

byte punteroCAN;

byte intentos;

if (CONFIGURADO == false){


Anexos 23

otra: punteroCAN = 0; //MODULO 1





}

tamano = 0;

punteroCAN=0;





}

txCAN1(FILTROINFORMATIVO_FC_M1,0xFF,0x00,0x00); //Le indico que ya le he mandado todos los valores para que se configure


if (DatosMsg[0] == FILTROINFORMATIVO_ACK_M1 && DatosMsg[1] == 0xFF ){


goto M2;

}

else {


if (intentos == 3){

goto M2;

}

else{

goto otra;

}

}

intentos = 0;







Anexos 24

}

tamano = 0;

punteroCAN=0;





}





goto M3;

}

else{



goto M3;

}

else{



goto M2;

}

}

intentos = 0;






}

tamano = 0;

punteroCAN=0;


Anexos 25





}





goto M4;

}

else{



goto M4;

}

else{



goto M3;

}

}

M4: CONFIGURADO == true; //En realidad no se pondría configurado a true hasta que todos los modulos estarían OK!

}


Anexos 26

//----------------------------------------------------------------------------------------------------------------------------

//Declaro variables para controles.

unsigned int dato; // variable con la que voy desapilando el buffer.

int num_led; //Me indica el LED a encender en los controles

int brillo; //Me indica el brillo que le quiero dar al LED en los controles analogicos

int estado; // Me indica el estado de los controles digitales

//Declaro variables para indicadores

int punteroindicadoresdig;

int datoindic; // Dato que le mando a VB para informarle de 7 en 7 del estado de los indicadores

int datoindic2; // Dato que le mando a VB para informarle de 7 en 7 del estado de los indicadores

int datoindic3;

int datoindic4;

int datoindic5;

int datoindic6;

int datoindic7;

int datoindic8;

int datoindic9;

int datoindic10;

int checksum; //Dato con el que comparo a ver si puedo comenzar a enviar el estado de los indicadores

datoindic =0;

checksum = 0;

datoindic2 = 0;

datoindic3 = 0;

datoindic4 = 0;

datoindic5 = 0;

datoindic6 = 0;

datoindic7 = 0;

datoindic8 = 0;

datoindic9 = 0;

datoindic10 = 0;

int punteroindicadoresanalog;


Anexos 27

int checksumanalog;

checksumanalog = 0;

//MAPA DE MEMORIA

int zonas_controles_digitales[80]; //ZONA EN LA QUE ESTA EL ESTADO DE LOS CONTROLES DIGITALES, ORDENADOS POR PINES. EJ 46 VALOR, ESTADO DEL PIN 46

int zonas_controles_analogicos[11]; //ZONA EN LA QUE ESTA EL ESTADO DE LOS CONTROLES ANALOGICOS, SE ORDENAN DE LA MISMA MANERA QUE EN EL ANTERIOR

int zonas_indicadores_digitales[80]; //ZONA EN LA QUE SE ENCUENTRA EL ESTADO DE LOS INDICADORES DIGITALES, ORDENADOS POR LOS PINES INDICADOS EN LA VARIABLE ARRAY. EL PRIMER VALOR

int i=0; // SERA EL ESTADO DEL PIN 33.

for(i=0; i<80; i++){

zonas_indicadores_digitales[i]=0;

}

int zonas_indicadores_analogicos[16]; //ZONA EN LA QUE SE ENCUENTRA EL ESTADO DE LOS INDICADORES ANALOGICOS

//Zona en la que se va a enviar la configuración de los pines a cada módulo

//Zona en la que se va a leer el buffer de entrada, para poder actualizar los controles.

if(Serial.available()) {

while (Serial.available()>0){ //Modulo 0


if (dato == 0){


if ((dato & 0x01)== 1){


//delay(1000);


brillo = dato;

analogWrite(num_led,brillo);

zonas_controles_analogicos[num_led] = brillo;

}

else{



Anexos 28

//delay(1000);

estado = (dato & 0x80) >> 7;

digitalWrite(num_led,estado);

zonas_controles_digitales[num_led] = estado;

}

}





if ((dato & 0x01)== 1){



brillo = dato;


}

else{


estado = (dato & 0x80) >> 7;


}

}





if ((dato & 0x01)== 1){



brillo = dato;


}


Anexos 29

else{


estado = (dato & 0x80) >> 7;


}

}





if ((dato & 0x01)== 1){



brillo = dato;


}

else{


estado = (dato & 0x80) >> 7;


}

}

}

}

//Zona en la que se va a enviar la tabla de indicadores, para que los lea VB.

int punteroauxiliar; // Con este recorro la tabla de pines indicadores digitales

int punteroM1ID;

punteroindicadoresdig = 0; //Indicadores DIGITALES

punteroauxiliar =0;

punteroM1ID = 0;

while (punteroindicadoresdig != cantidad * 2){


Anexos 30

PIN = pines_digi_entrada[punteroauxiliar];

punteroauxiliar = punteroauxiliar +1 ;

MODULO = pines_digi_entrada[punteroauxiliar];


switch (MODULO){

case 0: //MODULO 0

zonas_indicadores_digitales[punteroindicadoresdig] = digitalRead (PIN);

punteroindicadoresdig = punteroindicadoresdig +1 ;

break;

case 1: //MODULO 1

while (PIN != MODULO1_ID[punteroM1ID]){

punteroM1ID = punteroM1ID + 2;

}


zonas_indicadores_digitales[punteroindicadoresdig] = MODULO1_ID[punteroM1ID];

punteroM1ID = 0;


break;

case 2: //MODULO 2



}



punteroM1ID = 0;


break;

case 3: //MODULO 3



}




Anexos 31

punteroM1ID = 0;


break;

}

}

punteroindicadoresdig = 0;

switch (cantidad) {

case 1 ... 8:

while (punteroindicadoresdig != 8){

datoindic = datoindic <<1;

datoindic = datoindic + zonas_indicadores_digitales[punteroindicadoresdig];

punteroindicadoresdig = punteroindicadoresdig +1;

}

checksum = datoindic ^17;


Serial.print(datoindic,BYTE);

Serial.print(checksum,BYTE);

break;

case 9 ... 16:



datoindic = datoindic +

zonas_indicadores_digitales[punteroindicadoresdig];


}


datoindic2 = datoindic2 <<1;

datoindic2 = datoindic2 + zonas_indicadores_digitales[punteroindicadoresdig];


}

checksum = (datoindic ^ datoindic2) ^17;



Anexos 32


Serial.print(datoindic2,BYTE);


break;

case 17 ... 24:





}





}





}

checksum = (datoindic ^ datoindic2 ^ datoindic3) ^17;






break;

case 25 ... 32:





}




Anexos 33



}





}





}

checksum = (datoindic ^ datoindic2 ^ datoindic3 ^datoindic4) ^17;







break;

case 33 ... 40:





}





}




Anexos 34



}





}





}

checksum = (datoindic ^ datoindic2 ^ datoindic3 ^datoindic4 ^datoindic5) ^17;








break;

case 41 ... 48:





}





}



Anexos 35




}





}





}





}

checksum = (datoindic ^ datoindic2 ^ datoindic3 ^datoindic4 ^datoindic5^datoindic6) ^17;









break;

case 49 ... 56:






Anexos 36

}





}





}





}





}





}





}

checksum = (datoindic ^ datoindic2 ^ datoindic3 ^ datoindic4 ^ datoindic5 ^ datoindic6 ^ datoindic7) ^17;



Anexos 37









break;

case 57 ... 64:





}





}





}





}






Anexos 38

}





}





}





}

checksum = (datoindic ^ datoindic2 ^ datoindic3 ^ datoindic4 ^ datoindic5 ^ datoindic6 ^ datoindic7 ^ datoindic8) ^17;











break;

case 65 ... 72:





}


Anexos 39





}





}





}





}





}





}





Anexos 40


}





}

checksum = (datoindic ^ datoindic2 ^ datoindic3 ^ datoindic4 ^ datoindic5 ^ datoindic6 ^ datoindic7 ^ datoindic8 ^ datoindic9) ^17;












break;

case 73 ... 80:





}





}




Anexos 41



}





}





}





}





}





}





}


Anexos 42





}

checksum = (datoindic ^ datoindic2 ^ datoindic3 ^ datoindic4 ^ datoindic5 ^ datoindic6 ^ datoindic7 ^ datoindic8 ^ datoindic9 ^ datoindic10) ^17;













break;

}

int punteroM1IA; //Indicadores ANALOGICOS

punteroindicadoresanalog = 0;

punteroauxiliar =0;

punteroM1IA = 0;

PIN = 0;

MODULO = 0;

while (punteroindicadoresanalog != cantidadanalog * 2){

PIN = pines_analog_entrada[punteroauxiliar];


MODULO = pines_analog_entrada[punteroauxiliar];


switch (MODULO){

case 0: //MODULO 0

zonas_indicadores_analogicos[punteroindicadoresanalog] = analogRead (PIN);


Anexos 43

punteroindicadoresanalog = punteroindicadoresanalog +1 ;

break;

case 1: //MODULO 1

while (PIN != MODULO1_IA[punteroM1IA]){

punteroM1IA = punteroM1IA + 2;

}


zonas_indicadores_analogicos[punteroindicadoresanalog] = MODULO1_IA[punteroM1IA];

punteroM1IA = 0;


break;

case 2: //MODULO 2



}



punteroM1IA = 0;


break;

case 3: //MODULO 3



}



punteroM1IA = 0;


break;

}

}

punteroindicadoresanalog = 0;

checksumanalog = 0;

while (punteroindicadoresanalog != cantidadanalog){


Anexos 44

Serial.print(zonas_indicadores_analogicos[punteroindicadoresanalog]);

checksumanalog = checksumanalog ^ zonas_indicadores_analogicos[punteroindicadoresanalog] ;


Serial.print (47,BYTE);

}

checksumanalog = checksumanalog ^17;

Serial.print (checksumanalog);

Serial.print (46,BYTE);

// -------------------------------------ZONA DESTINADA UNICAMENTE AL BUS CAN -------------------------------------------------

// ------------------------------------------------------------

// Labores de intercambio con el CAN

// ------------------------------------------------------------

byte dato0;

byte dato1;

byte dato2;

byte dato3;

byte dato4;

byte dato5;

byte dato6;

int analogico;

int tipo;


goto PROGRAMA;

}

rxCAN1(DatosMsg);

DatosMsg[0] = dato0; //leo el dato que me ha llegado






tipo = dato0 & 100000L;


Anexos 45

tipo = tipo >> 5;

if (dato0 == FILTROINFORMATIVO_ESTADO_M3A || dato0 == FILTROINFORMATIVO_ESTADO_M2A || dato0 == FILTROINFORMATIVO_ESTADO_M1A ){ //Filtro el mensaje para saber si es un dato que tengo que recoger

//Nos ha llegado un dato analógico

analogico = dato2 * 1000 + dato3 * 100 + dato4 * 10 + dato5;

switch (tipo){

case 1:

tamano = 0;


punteroCAN = 0;





}


}

break;

case 2:

tamano = 0;


punteroCAN = 0;





}


}

break;

case 3:

tamano = 0;


punteroCAN = 0;


Anexos 46





}


}

break;

break;

}

}

if (dato0 == FILTROINFORMATIVO_ESTADO_M3D || dato0 == FILTROINFORMATIVO_ESTADO_M2D || dato0 == FILTROINFORMATIVO_ESTADO_M1D ){ //Nos ha llegado un dato digital

switch (tipo){

case 1:

tamano = 0;


punteroCAN = 0;





}


}

break;

case 2:

tamano = 0;


punteroCAN = 0;





}



Anexos 47

}

break;

case 3:

tamano = 0;


punteroCAN = 0;





}


}

break;

}

}

analogico = 0;

//-------------------------------------------------------------------------------------------------------------------------------------------

// ESCRIBA EL CODIGO PROGRAMA A PARTIR DE ESTA ZONA.

//´------------------------------------------------------------------------------------------------------------------------------------------

PROGRAMA: delay (20);

//-------------------------------------------------------------------------------------------------------------------------------------------

// FIN.

//´------------------------------------------------------------------------------------------------------------------------------------------

}

// ------------------------------------------------------------


// ------------------------------------------------------------


Anexos 48

// Descripción:



{






















Anexos 49







// ID=0x110, ID=0x120, …
















}


Anexos 50

/*** txCAN1remota

**

** Descripción:





// cada vez..

{




*tengo que meter en el otro programa de

*la nota de aplicación lo que tiene que

*transmitir cada pulsador por el chanel0 */




{











Anexos 51















}

}

/*_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________*/

/* ------------------------------------------------------------ */

/*** txCAN1

**

** Descripción:



Anexos 52

void txCAN1(uint32_t rxnode, uint8_t dato0, uint8_t dato1, uint8_t dato2) // en la variable piso va metido el bit que quiero que se ponga a


{







{














//message->data[3] = dato3;






Anexos 53






}

}

//------------------------------------------------------------------------------------------------------------------------------------




{



return;

}








Anexos 54


}

/* ------------------------------------------------------------------------------------------------------------------------------------------------ *







DatosMsg[0]= 0;

DatosMsg[1]= 0;

return ; }















return ;

}

/* --------------------------------------------------------------------------- */


/* --------------------------------------------------------------------------- */


Anexos 55


**

** Descripción:



{










{




{






Anexos 56







}

}







}

2.4. Código del resto de módulos. // Incluir librerías:






// ------------------------------------------------------------------------


// ------------------------------------------------------------------------


Anexos 57


//Nodos de los modulos




// ------------------------------------------------------------


// ------------------------------------------------------------




byte DatosMsg[7];

// ------------------------------------------------------------


// ------------------------------------------------------------









Anexos 58

// ------------------------------------------------------------


// ------------------------------------------------------------






void rxCAN1(void);

// ------------------------------------------------------------

// Definición de variables globales

// ------------------------------------------------------------

uint8_t modulo0 = 0x00;

uint8_t modulo1 = 0x01;

byte dato0;

byte dato1;

byte dato2;

byte dato3;

byte dato6;

byte miles;

byte centenas;

byte decenas;

byte unidades;

byte punteroID;

byte punteroIA;

unsigned int MODULO_ID[] = {} ; // Array de pines entradas digitales del modulo

unsigned int MODULO_IA[] = {}; // Array de pines entradas analogicas del modulo

byte tamano;

void setup(){


Anexos 59

int valor_analogico;

byte dato;

byte datomodulo1;

pinMode(11,INPUT); // A estos pines estan conectados los switches

pinMode(12,INPUT);

pinMode(83,INPUT);

pinMode(84,INPUT);

pinMode(85,INPUT);


datomodulo1 = dato << 4;



dato = 0;


datomodulo1 = (dato << 2) + datomodulo1;

dato = 0;



dato = 0;


datomodulo1 = dato + datomodulo1;

dato = 0;

switch (dato){

case 1:

//FILTROS






Anexos 60

#define FILTROINFORMATIVOESTADOM1D 0x1011L; //Mando el estado de un pin digital al modulo 0

#define FILTROINFORMATIVOESTADOM1A 0x1011L; //Mando el estado de un pin analogico al modulo 0



break;

case 2:

//FILTROS









break;

case 3:

//FILTROS







Anexos 61




break;

}






ESPERA1: if (isCAN1MsgReceived == false){

// CAN1 no recibio ningún mensaje para salir de la función, nos mantenemos a la espera

goto ESPERA1;

}

rxCAN1(DatosMsg);

dato0 = DatosMsg[0]; // almaceno del dato




if (dato0 == 0x01){ // El dato que acaba de llegar me interesa ¡¡¡¡¡ESTA ES LA VARIABLE A MODIFICAR PARA CADA MODULO!!!!

if (dato2 == 0xFF){ // Si le llega ese dato es que ya se ha configurado y se lo remite al modulo0

goto CONFIGURADO;

}

else{

pinMode(dato1,INPUT);

switch(dato2){

case 0:


Anexos 62

MODULO_ID[punteroID] = dato1;


break;

case 1:

MODULO_IA[punteroIA] = dato1;


break;

}

goto ESPERA1; // No ha terminado de configurarse así que debe de leer otra vez

}

}

CONFIGURADO: txCAN1(modulo0, 0xFF,0xFF,modulo1,0x00,0x00,0x00);

// YA ESTA CONFIGURADO Y PUEDE COMENZAR A TRABAJAR EN EL LOOP

}

void loop(){

// Leo entradas digitales y le remito su estado al modulo0

// En primer lugar obtengo el tamaño de MODULO_ID

byte valor_analogico;

tamano = sizeof(MODULO_ID)/4;

punteroID = 0;

dato0 = 0;

dato1 = 0;

dato2 = 0;

while (punteroID <= tamano){ // recorro MODULO_ID leyendo el dato de cada uno de los pines y remitiendoselo a modulo0

dato2=digitalRead (MODULO_ID[punteroID]);


txCAN1(modulo0, MODULO_ID[punteroID],0x00,0x00,0x00,0x00,0x00);


}

tamano = sizeof(MODULO_IA)/4;

punteroIA = 0;


Anexos 63

while (punteroIA <= tamano){ // recorro MODULO_IA leyendo el dato de cada uno de los pines y remitiendoselo a modulo0

valor_analogico = analogRead (MODULO_IA[punteroIA]);


txCAN1(modulo0, MODULO_IA[punteroIA], miles, centenas, decenas, unidades,0x00);


}

//-------------------------------------------------------------------------------------------------------------------------------------------

// ESCRIBA EL CODIGO PROGRAMA A PARTIR DE ESTA ZONA.

//´------------------------------------------------------------------------------------------------------------------------------------------

delay (20);

//-------------------------------------------------------------------------------------------------------------------------------------------

// FIN.

//´------------------------------------------------------------------------------------------------------------------------------------------

}

// ------------------------------------------------------------


// ------------------------------------------------------------

// Descripción:



{





Anexos 64
























Anexos 65


// ID=0x110, ID=0x120, …
















}

/*** txCAN1remota

**

** Descripción:





// cada vez..


Anexos 66

{




*tengo que meter en el otro programa de

*la nota de aplicación lo que tiene que

*transmitir cada pulsador por el chanel0 */




{




















Anexos 67






}

}

/*_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________*/

/* ------------------------------------------------------------ */

/*** txCAN1

**

** Descripción:


void txCAN1(uint32_t rxnode, uint8_t dato0, uint8_t dato1, uint8_t dato2, uint8_t dato3, uint8_t dato4, uint8_t dato5) // en la variable piso va metido el bit que quiero que se ponga a


{





Anexos 68




{
























}


Anexos 69

}

//------------------------------------------------------------------------------------------------------------------------------------




{



return;

}








}

/* ------------------------------------------------------------------------------------------------------------------------------------------------ *








Anexos 70

DatosMsg[0]= 0;

DatosMsg[1]= 0;

return ; }















return ;

}

/* --------------------------------------------------------------------------- */


/* --------------------------------------------------------------------------- */


**

** Descripción:



{




Anexos 71








{




{











}

}


Anexos 72







}


Anexos 73

3. Anexo 3. Código de la aplicación SCADA.

El código de la aplicación SCADA ya ha sido explicado e integrado paso a paso en la memoria casi en su totalidad. Aun así, si el lector lo desea podrá consultarlo en la carpeta del CD adjunto “Proyecto SCADAv7.0”.


Anexos 74

4. Anexo 4. Contenido del cd adjunto.

El contenido del cd adjunto es el siguiente:

• ANEXOS. • Datashetts del bus CAN. • Datasheets del hardware. • Memoria. • Planos. • Pliego de condiciones. • Portada y índice general. • Presupuesto. • Archivos Top Solid. • Proyecto SCADAv7.0. • Manual de usuario.


Anexos 75

Logroño, a 3 de septiembre de 2013.

Alberto Martínez Inchusta.

Planos

Índice de Planos. 1. Plano 1. Entradas digitales ..................................................................................................... 1

2. Plano 2. Salidas digitales ......................................................................................................... 2

3. Plano 3. Entradas analógicas ................................................................................................. 3

4. Plano 4. Estructura hardware del autómata. ................................................................... 4

5. Plano 5. Placa principal. ........................................................................................................... 5

6. Plano 6. Esquema electrónico de las salidas digitales rápidas. ................................ 6

7. Plano 7. Esquema electrónico de las salidas digitales a triac.................................... 7

8. Plano 8. Esquema electrónico de las entradas analógicas. ........................................ 8

9. Plano 9. Esquema electrónico de las entradas digitales. ............................................ 9

Controlador modular programable basado En procesadores de 32 bits y CAN bus

Planos 1

1. Plano 1. Entradas digitales


Planos 2

2. Plano 2. Salidas digitales


Planos 3

3. Plano 3. Entradas analógicas


Planos 4

4. Plano 4. Estructura hardware del autómata.


Planos 5

5. Plano 5. Placa principal.

bibybape

Texto escrito a máquina

Información disponible en disco (CD-ROM)


Planos 6

6. Plano 6. Esquema electrónico de las salidas

digitales rápidas.

bibybape


bibybape


bibybape




Planos 7

7. Plano 7. Esquema electrónico de las salidas

digitales a triac.

bibybape




Planos 8

8. Plano 8. Esquema electrónico de las entradas

analógicas.

bibybape




Planos 9

9. Plano 9. Esquema electrónico de las entradas

digitales.

bibybape




Planos 10



Pliego de

condiciones

Índice del pliego de condiciones. 1. Disposiciones Generales. ......................................................................................................... 1

1.1. Introducción. ........................................................................................................................ 1

1.2. Objeto. ..................................................................................................................................... 2

1.3. Propiedad intelectual. ...................................................................................................... 3

2. Disposiciones legales y normativa aplicable. .................................................................. 4

3. Condiciones facultativas. ......................................................................................................... 6

3.1. Dirección. ............................................................................................................................... 6

3.2. Libro de órdenes................................................................................................................. 7

4. Condiciones de ejecución y montaje. .................................................................................. 8

4.1 Condiciones de fabricación del circuito impreso. .................................................. 8

4.2 Pruebas y ensayos del montaje de la placa. ............................................................. 9

4.2.1 Prueba de alimentación. ......................................................................................... 9

4.2.2 Prueba de la placa. .................................................................................................... 9

4.2.3 Conexionado de los componentes....................................................................... 9

4.3 Conexionado de sensores y actuadores. .................................................................. 10

4.3.1 Entradas digitales. ................................................................................................... 10

4.3.2 Salidas digitales. ....................................................................................................... 11

4.3.3 Entradas analógicas. ............................................................................................... 12

4.4 Especificaciones técnicas de la parte hardware. .................................................. 13

4.4.1 Placa principal. ......................................................................................................... 13

4.4.2 Módulo de entradas analógicas. ......................................................................... 14

4.4.3 Módulo de entradas digitales. ............................................................................. 16

4.4.4 Módulo de salidas digitales rápidas. ................................................................ 18

4.4.5 Módulo de salidas digitales a triac. ................................................................... 19

4.4.6 chipKIT MAX32. ....................................................................................................... 20

4.5 Especificaciones técnicas del CAN bus. .................................................................... 21

4.5.1 MCP2551..................................................................................................................... 23

4.6 Instalación y uso de las aplicaciones ........................................................................ 25

4.7. Conservación...................................................................................................................... 26

4.8. Funcionamiento normal del equipo .......................................................................... 27

5. Condiciones de materiales y equipos. .............................................................................. 28

5.1. Condiciones técnicas de los materiales. .................................................................. 28

5.2. Condiciones técnicas del material informático .................................................... 29

5.3. Condiciones técnicas de los circuitos impresos. .................................................. 30

5.4. Condiciones técnicas de los elementos pasivos. .................................................. 31

5.5. Hardware Open Source. Condiciones de utilización ........................................... 32

6. Manual de usuario. .................................................................................................................. 34

7. Disposición final. ...................................................................................................................... 48

Controlador modular programable basado en procesadores de 32 bits y CAN bus

Pliego de condiciones. 1

1. Disposiciones Generales.

1.1. Introducción.

Las características y la descripción del proyecto “Controlador modular

programable basado en procesador de 32 bits y CAN bus”, los componentes que

intervienen, el cableado y conexionado eléctrico y control del funcionamiento del

mismo se detallan en el documento de la memoria y en los correspondientes

planos del documento.

En este documento se exponen todas las condiciones técnicas de montaje,

especificaciones a cumplir por los elementos y materiales normalizados y

comerciales que se deben considerar a la hora de llevar a cabo la realización del

proyecto.

En caso de no realizarse según las condiciones tal y como se presentan en

este documento, el proyectista no se responsabilizará de los posibles fallos y

averías propios del funcionamiento, repercutiéndose todo el peso del problema

sobre terceras personas.

Todas las modificaciones de las que pueda ser susceptible el proyecto,

deberán ser aprobadas por el ingeniero o proyectista.



1.2. Objeto.

La realización del presente Proyecto titulado “Controlador modular

programable basado en procesador de 32 bits” se enmarca bajo la designación de

Proyecto Fin de Carrera y tiene como propósito culminar con éxito los estudios de

Ingeniería Industrial superior.

El autor del presente proyecto ha cursado estos estudios en la Universidad de la

Rioja, cumpliendo en su elaboración las directrices especificadas por dicho centro

en la normativa del proyecto fin de carrera aprobada por el consejo de Gobierno el

15 de abril de 2005.



1.3. Propiedad intelectual.

Según el artículo 13 de la normativa vigente en el centro, la propiedad

intelectual del autor y director del Proyecto o Trabajo Fin de Carrera se regirá por

el Real Decreto Legislativo 1/1996, de 12 de abril, por el que se aprueba el texto

refundido de la Ley de Propiedad Intelectual, y por la normativa vigente en la

Universidad de La Rioja.



2. Disposiciones legales y normativa aplicable.

La realización del proyecto se regirá por la Ordenanza General de Seguridad

e Higiene en el Trabajo del 7 de abril de 1970 y posteriores revisiones.

Así mismo, se regirá por el Reglamento Electrotécnico de Baja Tensión, en el

que se tendrá en cuenta las siguientes normativas:

• M.I. B.T.029, la cual se refiere a instalaciones de pequeñas tensiones,

menores de 50 voltios.

• M.I. B.T.031, la cual se refiere a las condiciones generales de instalación,

de utilización, así como de los requisitos a cumplir a la hora del diseño.

El proyecto cumple también con las siguientes normativas DIN y UNE:

• Los materiales que pueden ser utilizados para la realización de placas de

circuito impreso UNE 20-621-85/3.

• Los espesores de los materiales con recubrimiento metálico y sus

tolerancias especificadas en la norma UNE 20-621-84/3.

• La norma UNE 20552 especifica las tolerancias sobre el espesor total en

la zona de contactos.

• En cuanto a la anchura de las pistas, según la intensidad que circule por

el material conductor, se referirá a la norma UNE 20-621.

• Los diámetros de los taladros están especificados en la norma UNE 20-

621-84/3.

• La norma UNE 20-612/2 recoge varios tipos de ensayos que pueden

realizarse y los materiales, como pueden ser los ensayos de espesor,

adherencia, porosidad, etc.

• En las distancias entre taladros para la colocación de componentes, se

seguirá lo indicado en la norma UNE 20-524/1, UNE 20-524/2 y UNE 20-524/3.

• Reglas de seguridad para los aparatos electrónicos de norma UNE 20-

514-82.

• DIN 40801, referente a circuitos impresos, fundamentos, orificios y

espesores.

• DIN 40803, referente a circuitos impresos, placas y documentación.

• DIN 40804, referente a circuitos impresos, conceptos.

• DIN41494, referente a las formas de construcción para dispositivos

electrónicos.

• Reglas para el diseño y utilización de placas de circuito impresas UNE

20-621-3.

• Especificación para la realización de placas de simple o doble cara con

agujeros no metalizados y metalizados UNE 20-621-4 y UNE 20-621-5.

• Especificación para las placas impresas multicapas UNE 20-621-6.



• UNE 20902 que hace referencia a la técnica de circuitos impresos,

terminología.

• UNE-EN 60249 en la cual se citan los materiales base para circuitos

impresos.

Este proyecto debido a sus características se encuentra recogido dentro del reglamento eléctrico de baja tensión.

“Se calificará como instalación eléctrica de baja tensión todo conjunto de aparatos y circuitos asociados en previsión de un fin particular, producción, conversión, transformación, distribución, o utilización de la energía eléctrica, cuyas tensiones nominales sean iguales o inferiores a 1000 voltios para corriente alterna y 1500 voltios para corrientes continuas.”



3. Condiciones facultativas.

3.1. Dirección.

La dirección del montaje estará realizada en su totalidad por el ingeniero o

proyectista o por otra persona que esta delegue atendiendo a la capacidad de dicha

persona para realizar este trabajo.

Una vez realizado el montaje, su utilización podrá ser realizada por

cualquier persona con conocimientos suficientes demostrables sobre el proyecto,

la tecnología en él implicada y su funcionamiento. En caso de avería o pérdida de

datos por incorrecta utilización, el proyectista queda exento de culpa.



3.2. Libro de órdenes.

El montaje de los elementos del proyecto se realizará atendiendo a los

documentos y planos del mismo.

Si es necesario realizar una modificación, se realizará bajo el pertinente

consentimiento del propio ingeniero o proyectista.



4. Condiciones de ejecución y montaje.

4.1 Condiciones de fabricación del circuito impreso.

Tanto el circuito impreso de la placa principal, así como cada uno de los

módulos de entradas y salidas deberá regirse por la norma UNE-621-80, en la cual

se especifican los ensayos a los que debe ser sometido el circuito impreso, así como

los métodos para la ejecución de dichos ensayos.



4.2 Pruebas y ensayos del montaje de la placa.

Una vez montados todos los componentes y soldados a la placa, se

procederá a efectuar los siguientes ensayos:

4.2.1 Prueba de alimentación.

Para verificar el correcto funcionamiento de cada placa, se debe alimentar

con -24÷48V.

Se deberá comprobar que al conectar ambas tensiones no se produzca

ningún tipo de fallo tal y como un cortocircuito entre las alimentaciones.

Las placas chipKIT disponen de un LED de rojo el cual se ilumina cuando la

placa está siendo alimentada correctamente. Si este LED se desvanece lentamente

al realizar alguna conexión es el principal indicativo de que se está produciendo un

cortocircuito y el limitador de corriente está realizando su trabajo.

4.2.2 Prueba de la placa.

Para realizar el ensayo de la puesta en marcha de la placa, se deberá utilizar

los ejemplos de chipKIT.

Se hará uso del programa de ejemplo denominado “Blink” que hace

parpadear intermitentemente cada segundo el LED que la placa de interfaz tiene

conectada al pin 13, que se puede identificar en la placa por estar marcado con una

LD. Este ejemplo es el más simple de todos, ideal para asegurar que si se produce

algún fallo sea de hardware y no esté siendo enmascarado por un fallo de software.

Si se quiere comercializar en la UE, será necesario que el sistema sea

sometido a los ensayos pertinentes entre los que destaca la compatibilidad

electromagnética, así como otros ensayos preceptivos.

4.2.3 Conexionado de los componentes.

El conexionado se realiza siguiendo los esquemas que se encuentran en el

CD, ubicados en la carpeta “Adjuntos del proyecto”.



4.3 Conexionado de sensores y actuadores.

4.3.1 Entradas digitales.

Figura 1) Conexionado de sensores a los borneros de los módulos de entradas digitales.



4.3.2 Salidas digitales.

Figura 2) Conexionado de actuadores tanto a las salidas digitales rápidas como a las salidas a triac.



4.3.3 Entradas analógicas.



4.4 Especificaciones técnicas de la parte hardware.

4.4.1 Placa principal.

Figura 3) Simulación en 3D de la placa principal.

El aspecto de la placa principal es el de la imagen inferior, en ella se pueden

observar los distintos zócalos que albergarán los módulos de entradas/salidas, así

como los diferentes componentes electrónicos que forman:

• La fuente de alimentación de los módulos.

• El hardware de las cinco salidas analógicas.

El esquema electrónico de la fuente de alimentación es el siguiente:

Figura 4) Circuito electrónico de la fuente de alimentación

Esta fuente de alimentación convierte de +/-24 Vcc a +/-15Vcc.

Características técnicas de esta fuente.



FUENTE DE ALIMENTACION

Tensión de entrada máximo 24v

Tensión de salida máximo 15v

Tensión de entrada mínimo -24v

Tensión de salida mínimo -15v

Intensidad de entrada máxima 1.2 A

Corriente de pico a la entrada 2.4 A

Frecuencia de trabajo 120 Hz

Rango de temperaturas -65÷150 ºC

Precio euros

Figura 5) Especificaciones técnicas de la fuente de alimentación.

Para las salidas analógicas se emplea un FOD8321, cuya limitación podría

venir impuesta por su frecuencia de operación, ya que la función analogWrite() de

chipKIT, genera una onda cuadrada estable (PWM) en un pin de salida analógica.

La frecuencia de esta señal PWM será aproximadamente de 490Hz.

El FOD8321 presenta una frecuencia de operación de 50 KHz muy superior a

los 490 Hz del PWM que emplean las salidas analógicas de chipKIT, de tal manera

que esté integrado puede dar cobertura a este tipo de salidas.

4.4.2 Módulo de entradas analógicas.

El módulo de cuatro entradas analógicas presenta los siguientes bloques.

Figura 6) Bloques que componen los módulos de entradas analógicas.



Por lo tanto ante lo mostrado en la figura 1, se puede ver que los

componentes electrónicos que condicionan los valores máximos y mínimos tanto

de entrada como de salida en voltajes son los analog switch ADG 5413 y el AD7512DITQ.

El primero de los componentes presenta las siguientes características:

• Rango de tensiones de entrada cuando trabaja en modo simple 9v ÷ 40v.

• Intensidad máxima a la entrada de 30mA.

• Pico de intensidad a la entrada 278mA.

• Rango de temperaturas:

o Operación -40 a 125 ºC

o Almacenamiento -65ºC a 150ºC

• Frecuencias de trabajo a temperatura ambiente.

• Ton típico de 170 ns

• Ton máximo de 202 ns

• Toff típico de 120 ns

• Toff máximo de 140 ns

El segundo componente presenta las siguientes características.

• Detecta nivel alto a partir de 3v y el mínimo con 0.8v máximo.

• Rango de temperaturas entre -55 y 125 ºC


• Ton máximo de 1 us.

• Toff máximo de 1 us.

Los bloques de conversión intensidad-voltaje y el de reducción de voltaje,

presentan como datos más interesantes sus rangos de temperaturas, ya que su

respuesta dinámica es más rápida que la del ADG 5413 y por lo tanto es este

elemento el que condiciona el ton y el toff del módulo. Así mismo los rangos de

intensidad y voltaje de entrada son condicionados por el ADG 5413 y los de salida

por el AD7512DITQ.

De manera que tanto el RCV420 como el LM358 se mueven en un rango de

-25 a 85 ºC.

Con las situaciones más desfavorables este tipo de módulos presenta las

siguientes características.



ENTRADAS ANALÓGICAS

Número de Entradas 4

Rango de voltajes de entrada(V) 9÷40 v

Retraso de señal a ON 202 ns

Retraso de señal a OFF 140 ns

Voltaje a salida máximo de estado OFF 0.8 v

Voltaje a salida mínimo de estado ON 3.3 v

Intensidad máxima de entrada 30 mA


Precio 50 euros

Figura 7) Especificaciones técnicas del módulo de entradas analógicas.

4.4.3 Módulo de entradas digitales.

La electrónica bajo la que se ha diseñado los módulos de entradas digitales,

reduce el voltaje que llega de los sensores y además, aísla al chipKIT de picos de

tensión que podrían destruir la placa de desarrollo.

Figura 8) Circuito electrónico que aísla y adapta niveles.

Los rangos de tensión de entrada entre los que trabaja son los siguientes:

• Entre 0 y 5.1 voltios es un 0 digital.

• Entre 5.1 y 48 voltios es un 1 digital.

Los rangos de tensión a la salida en función del valor a la entrada:

• Vin entre 0 y 5.1 voltios, a la salida aparece 1.2 voltios máximo

• Vin entre 5.1 y 48 voltios, a la salida aparece entre 2.7 y 5 voltios.

El componente electrónico que más influye en las especificaciones

dinámicas, es el optoacoplador 4N25 – 300E. Las características de este

componente son:



• Tensión entre sus pines 1 y 2 con la que empieza a conducir: 1.5v

• Intensidad con la que empieza a conducir: 10 mA.

• Intensidad máxima de entrada de 60mA.

• Tensión máxima entre sus pines 1 y 2 de 5v.





• Ton de 2us.

• Toff de 2us.

Por su parte el zener 1N4733A, que posee una tensión nominal zener de 5.1

voltios, posee un rango de temperaturas bastante amplio, en concreto, -65 a 200

ºC.

ENTRADAS DIGITALES


Rango de voltajes de entrada(V) 5.1÷48 v

Retraso de señal a ON 2us

Retraso de señal a OFF 2us

Voltaje a salida máximo de estado OFF 1.2 v

Voltaje a salida mínimo de estado ON 5v



Precio 9 euros

Figura 9) Especificaciones técnicas del módulo de entradas analógicas.



4.4.4 Módulo de salidas digitales rápidas.

La electrónica de los módulos de salidas digitales rápidas es muy sencilla,

basándose únicamente en un convertidor de intensidad a voltaje, en concreto el

FOD 8321.

Figura 10) Circuito electrónico de las salidas digitales rápidas.

Características de este componente electrónico.

• Rango de tensiones recomendable de entrada 5v máximo.

• Rango de tensiones de salida 0 a 35v.

• Intensidad máxima de salida de 2.5 A.

• Intensidad media a la entrada 25mA.





• Frecuencia de operación 25KHz.

• Ton típico de 500 ns

• Toff típico de 500 ns

SALIDAS DIGITALES RAPIDAS


Rango de voltajes de salida(V) 0÷35 v

Retraso de señal a ON 500 ns

Retraso de señal a OFF 500 ns

Voltaje de entrada máximo 5 v



Precio 7 euros

Figura 11) Especificaciones técnicas del módulo de salidas digitales rápidas.



4.4.5 Módulo de salidas digitales a triac.

Las interfaces de salidas digital con triac, están basadas en un diodo

luminiscente y un triac sensible a la luz (optotriac), en concreto el MOC3021 que

controla a un triac de mayor potencia.

Figura 12) Circuito electrónico de las salidas digitales a triac.

Características de este componente electrónico.

• Rango de tensiones 115/230vac.

• Rango de tensiones pico hasta 400v.

• Rango de 1 lógico hasta 1A.

• Intensidad media a la entrada 25mA.



• Niveles tensión de salida 1 lógico hasta 3Vp.

• Niveles tensión de salida 0 lógico hasta 1.8Vp

SALIDAS DIGITALES a triac


Rango de voltajes de salida(V) 115÷230

Vac Rango de 1 lógico hasta 1A

Intensidad media a la entrada 25mA

Voltaje de salida máximo para 1 lógico 3Vp

Voltaje de salida máximo para 1 lógico 1.8Vp


Precio 19 euros

Figura 13) Especificaciones técnicas del módulo de salidas digitales a triac.



4.4.6 chipKIT MAX32.

chipKIT MAX32

Microcontrolador PIC32MX795F512L

Memoria FLASH 128K

Voltaje de operación 3.3v

Frecuencia de operación 80 Mhz

Voltaje de entrada 7v a 15v

Voltaje de entrada máximo 20v

I/O pins 83

Entradas analógicas 16

Rango de voltaje de las entradas analógicas De 0v a 3.3v

Intensidad de entrada a los pines +/-18mA

Periféricos. Ethernet

2 controladores CAN

USB 2.0

Figura 14) Especificaciones técnicas del chipKIT 32MAX



4.5 Especificaciones técnicas del CAN bus.

La capa física del CAN bus es responsable de la transferencia de bits entre

los distintos módulos que componen la red. Define aspectos como niveles de señal,

codificación, sincronización y tiempos en que los bits se transfieren al bus.

En la especificación original del CAN, la capa física no fue definida,

permitiendo diferentes opciones para la elección del tipo de unidad y niveles

eléctricos de transmisión. Las características de las señales eléctricas en el bus

fueron establecidas mas tarde por el estándar ISO 11898.

La especificación CiA (CAN in Automotion), complementó las definiciones

respecto al medio físico y conectores. Los módulos conectados al bus interpretan

dos niveles lógicos denominados:

• Dominante: la tensión diferencial (CAN_H - CAN_L) es del orden de

2.0vcon CAN_H = 3.5 v y CAN_L = 1.5v (nominales).

• Recesivo: la tensión diferencial (CAN_H - CAN_L) es del orden de 0v con

CAN_H = CAN_L = 2.5v (nominales).

Otra de las partes a destacar de esta comunicación, es la velocidad con la

que se transmiten los mensajes a través de la red. Lo normal es tener buses de

corta longitud, para así obtener un funcionamiento óptimo. Pero si por el contrario

tenemos redes de largas longitudes eso irá mermando la velocidad de transmisión,

debido a los retardos en la línea, impedancias, tolerancias de los osciladores, etc.

Para atenuar estas carencias se colocan en los extremos del bus impedancias de

carga para una mayor estabilidad.

A continuación, se muestran los valores típicos (son orientativos) de

transmisión según la longitud de los buses:

Velocidad (Bit/seg) Tiempo de bit (microseg) Longitud máxima (metros)

1 Mbps 1 microseg 30 m

800 Kbps 1,25 microseg 50 m

500 Kbps 2 microseg 100 m








El número máximo de módulos no está limitado por la especificación

básica y depende de las características de los controladores CAN (SJA 1000). Las

especificaciones de buses de campo lo limitan a 32 o 64.

El bus CAN utiliza transmisión serie asíncrona, y codificación NRZ,

utilizando para evitar problemas el bit stuffing, inserción de un bit

complementario tras 5 bits con el mismo valor, y una cuidadosa temporización de

bit. Todos los dispositivos en una red CAN tienen su propio reloj, generalmente un

oscilador de cuarzo, que pueden tener periodos ligeramente diferentes. Pese a

ello, la velocidad de transmisión se ajusta para que sea la misma en todos los

dispositivos aunque tengan frecuencias de oscilador diferentes. Al no ser estas

frecuencias totalmente estables, los dispositivos se resincronizan con la corriente

de bits.

El tiempo nominal de bit (Bit timing) se divide en cuatro fases:

• Sincronización, donde se espera el flanco.

• Retardo de propagación, compensando el desfase debido a los retardos

de propagación.

• Buffer 1 y 2, que son los tiempos antes y después del punto de muestreo

nominal, variables para realizar la resincronización.

Se utilizan medios de transmisión eléctricos y ópticos, aunque sería posible

utilizar transmisión por red eléctrica y sin cables. Se suelen utilizar cables de par

trenzado UTP o STP, con transmisión diferencial, y hay que tener en cuenta los

parámetros del cable cuando las distancias son largas ya que afectan a la tasa de

transferencia.

La topología básica es en bus, incluyendo dos terminadores a los extremos, para evitar reflexiones en la señal. Otras topologías más complejas se

pueden usar gracias al uso de repetidores, que añaden retardo a la propagación de

la señal. De puentes, que conectan dos redes lógicas separadas a nivel de enlace.

Solo retransmiten aquellos mensajes que no son locales, y de pasarelas, que

conectan redes con diferentes protocolos de alto nivel, cuando estos están

presentes.



4.5.1 MCP2551.

Como ya se explicó en la memoria, un enlace CAN requiere entre

otros elementos un controlador y un transceiver. El primero de ellos, lo

aporta por partida doble el chipKIT 32MAX, sin embargo, debe ser el usuario el que acople el transceiver MCP 2551 para poder crear esta red

de comunicación.

Figura 15) Explicación grafica de toda la estructura hardware necesaria en cada uno de los nodos del CAN bus.

Este componente tiene como principales características soportar la tasa de

transferencia máxima de 1 Mbps que se especifica en el protocolo CANopen,

implementar los requerimientos de la capa física ISO-11898, detección de fallos en

la tierra y permite conectar un máximo de 112 Nodos al Bus.

Figura 16) Patillaje del MCP 2551.



Figura 17) Diagrama de bloques del MCP2551

La descripción detallada de cada pin se muestra a continuación:

• Pin 1: TxD: Entrada digital que recibe los datos que van a ser enviados

por el Bus.

• Pin 2: VSS: Referencia de tierra.

• Pin 3: VDD: Tensión de alimentación (+5V).

• Pin 4: RxD: Señal digital que transmite los datos recibidos por el bus.

• Pin 5: Vref: Tensión de referencia a la salida definida como Vdd/2.

• Pin 6: CANL: Parte baja de la señal diferencial del Bus.

• Pin 7: CANH: Parte alta de la señal diferencial del Bus.

• Pin 8: RS: Este pin permite seleccionar distintos modos de operación

(High Speed, Slope Control, Standby) mediante una resistencia externa.



4.6 Instalación y uso de las aplicaciones

Para el correcto funcionamiento de todo el sistema, se debe instalar el

controlador de la placa de chipKIT en el caso de que sea necesario para su

funcionamiento siguiendo las instrucciones que se encuentran en la página web de

digilent.

Además se debe tener instalado el paquete de office.

La aplicación SCADA podría requerir algún tipo de .dll, si se da el caso, el

usuario deberá descargarla y depositarla allí donde se indique.

Para el manejo de la aplicación se puede consultar el Manual de Usuario.



4.7. Conservación

Si para el montaje y puesta en marcha de los equipos y materiales que

componen el hardware y software se siguen todas las indicaciones,

recomendaciones y se cumplen las especificaciones que se dan en el pliego de

condiciones, anexos y memoria, la vida útil de los elementos estará supeditada a

aquella que de el fabricante siguiendo sus recomendaciones de mantenimiento.



4.8. Funcionamiento normal del equipo

Una vez realizados todos los pasos anteriores, el equipo estará listo para

funcionar permanentemente.

El equipo no necesita de un mantenimiento riguroso, siempre que su uso se

realice dentro de los límites especificados para cada componente.

El deterioro de los materiales puede ser debido al propio envejecimiento

del material con el paso del tiempo.



5. Condiciones de materiales y equipos.

5.1. Condiciones técnicas de los materiales.

Lo materiales a emplear en este proyecto deberán cumplimentar todas y

cada una de las normas descritas en el presente documento y podrán ser

sometidos a diferentes pruebas y ensayos para asegurarse así de su correcto

funcionamiento. En caso de no realizarse dichas pruebas y ensayos, el proyectista

quedará exento de responsabilidad en el posible deterioro de los elementos

durante su utilización.

Estos materiales deben cumplir las especificaciones citadas para cada uno

de ellos.

Si son reemplazados por unos nuevos, estos deben tener las mismas

características que los que reemplazan, inhibiéndose de cualquier responsabilidad

por fallo si estos requisitos no son cumplidos.



5.2. Condiciones técnicas del material informático

Los requisitos mínimos del sistema informático necesario para poder

ejecutar el software diseñado, son los siguientes:

• Ordenador personal con procesador Intel Pentium IV a 2.0 GHz o

equivalente.

• 512 MB de memoria RAM DDR.

• Un puerto USB libre para la conexión de la placa de interfaz.

• 100 MB de espacio en disco duro para la instalación del software.

• Microsoft Windows XP

Para la realización del presente proyecto se ha utilizado la siguiente

configuración de hardware y software:

• Ordenador personal con sistema operativo MAC OS X Lion.

• Navegador de internet.

• Compilador de chipKIT

• Licencias Visual Basic.

• Microsoft Word 2010.

• Microsoft Visio 2010.

• Autocad 2010.

• Software gratuito de diseño de circuitos KiCAD, con el objetivo de

que cualquiera pueda realizar cambios personales sobre las placas.



5.3. Condiciones técnicas de los circuitos impresos.

Las placas de los circuitos impresos serán de fibra de vidrio y tendrán un

espesor no inferior a 750 um. Siendo una vez atacadas con ácido las placas para

crear las pistas, cubiertas con un barniz protector fotosensible de manera que el

proceso no oculte las zonas donde se deberán realizar la soldadura de los

componentes.

Se deberá tener especial cuidado en el proceso de soldadura de ciertos

componentes tales como los semiconductores, tratando de reducir en la medida de

lo posible el tiempo del proceso, ya que debido a la sensibilidad de éstos a la

temperatura se podrían producir daños por sobrecalentamiento.



5.4. Condiciones técnicas de los elementos pasivos.

Las resistencias y condensadores tendrán unas tolerancias o márgenes de

error permisibles.

En el caso de las resistencias se considerará aceptable un error de hasta el

5%, siendo tolerable para los condensadores un valor del 20%.



5.5. Hardware Open Source. Condiciones de

utilización

El hardware open-source (de fuente abierta) comparte muchos de los

principios y metodologías del software libre y de código abierto. En particular, los

usuarios deben poder conocer en profundidad este hardware para comprender su

funcionamiento, modificarlo y compartir dichos cambios. Para facilitar esta tarea,

el CD que acompaña al proyecto contiene todos los ficheros originales (KiCAD) del

diseño del hardware. En estos ficheros se permiten realizar trabajos personales y

comerciales derivados, siempre que estos den crédito al autor, al director del

proyecto y a la Universidad de la Rioja, y publiquen sus diseños bajo la misma

licencia que Arduino: Creative Commons Attribution Share-Alike.

El software también open-source. El código fuente para el ambiente Java se

publica bajo la GPL y las bibliotecas C/C++ del microcontrolador bajo la LGPL.

Los diseños de referencia de la placa Arduino se encuentran disponibles en

la página hardware. Estos se encuentran bajo licencia Creative Commonos

Attribution Share-Alike, por lo que se es libre de utilizar y adaptarlos para sus

propias necesidades sin pedir permiso o pagar tarifa alguna. Si el usuario planea

hacer algo de interés para la comunidad, se sugiere discutir tus ideas en el foro de

desarrollo de hardware, para que los potenciales usuarios puedan aportar sus

sugerencias.

Si estás fabricando tu propia placa, ¡Inventa un nombre tu mismo! Esto

permitirá a la gente identificarte con tus productos y ayudarte a construir tu

propia marca. Se creativo: trata de sugerir lo que la gente hará con tu placa, o

enfatizar en su forma o características, o tan solo escoge una palabra al azar que

suene bien. "Arduino" es una marca registrada del equipo Arduino y no debe

utilizarse para variantes no oficiales. Si estás interesado en que tu diseño se

incluya junto con las placas oficiales, por favor consulta la sección Así que quieres

hacerte un Arduino y ponte en contacto con el equipo Arduino. Ten en cuenta que

aun cuando no intentamos restringir la utilización del sufijo "duino", su utilización

tiende a espantar a los miembros italianos del equipo (al parecer suena horrible);

sera mejor que lo evites.

Utilizar una placa Arduino dentro de un producto comercial no requiere que

reveles o liberes ninguna de las partes de su diseño.

Derivar el diseño de un producto comercial a partir de los ficheros Eagle de

la placa Arduino requiere que publiques los ficheros modificados bajo la misma

licencia Creative Commons Attribution Share-Alike. Puedes fabricar y vender el

producto resultante.

Utilizar el núcleo y las bibliotecas de Arduino para el firmware de un

producto comercial no requiere que publiques el código fuente para el firmware.



La LGPL requiere que se liberen los ficheros objeto que permitan el re-enlace al

firmware para versiones actualizadas de las bibliotecas y núcleo de Arduino.

Cualquier modificación al núcleo y bibliotecas debe ser publicado bajo la LGPL.

El código fuente del ambiente Arduino está cubierto bajo la GPL, que

requiere que cualquier modificación sea de código libre bajo la misma licencia. No

previene la venta de software derivado o su incorporación en productos

comerciales.

En todos los casos, los requerimientos exactos son determinados por la

licencia aplicable. Adicionalmente, consulta las preguntas anteriores para

información sobre la utilización del nombre "Arduino".



6. Manual de usuario.

El presente manual está redactado para la versión 7.0 del software de

supervisión SCADA. Pretende ser una guía útil para el usuario, que le enseñe a

crear una aplicación a su medida.

Para ello se realiza un ejemplo de cada uno de los controles posibles a crear.

Junto a estos ejemplos, se muestra al usuario como poner en marcha la aplicación,

además de mostrar la utilidad de todos los botones.



La primera pantalla de la aplicación es una pantalla de presentación, en la

que aparecen dos botones, los cuales rezan de la siguiente manera, “PROYECTO

NUEVO” y “PROYECTO EXISTENTE”. El primero de los botones permite crear un

SCADA desde cero, por su parte el segundo botón concede al usuario la posibilidad

de partir de un panel SCADA ya realizado o en proceso de realización.


Se va a partir del supuesto caso en que el usuario decide crear el proyecto

desde cero, ya que la única diferencia que existe con respecto a la otra opción es la

no necesidad de pasar por una pantalla intermedia, que se va a analizar a

continuación. Si por el contrario, se pulsaría la opción de “PROYECTO EXISTENTE”,

la aplicación direccionaría al usuario a la última de las pantallas, una vez ahí, este

debería pulsar el botón cargar y seleccionar el archivo (.xlsx) que desea cargar.

La siguiente pantalla a la que nos conducirá la aplicación será un formulario

limpio, que recibirá al usuario con una ventana emergente, en la que se le pedirá

que “delimite la zona en la que se desea colocar la imagen de fondo”.


El primer paso a realizar en esta pantalla, será delimitar el área en la que se

quiere colocar la imagen. Esto se consigue de la misma manera que cuando se

quiere realizar una selección sobre cualquier aplicación Windows. Una vez que ya

se le ha indicado a la aplicación el área en la que se quiere imprimir la imagen

aparecerá de nuevo otra ventana emergente, que indicará al usuario cual es el paso

siguiente, “Cargue la imagen de fondo”.




Pulsando sobre el botón cargar, se desplegará una pantalla emergente en la

que se solicitará la ruta de la imagen de fondo.


Una vez seleccionado el archivo .jpeg que se desea cargar, inmediatamente

se colocará la imagen sobre el fondo.




Se pulsa el botón siguiente para pasar a la siguiente página en la que se

podrá llevar a cabo la creación de los diferentes elementos que permitirán al

usuario interacturar con el proceso.

Una vez situado en la tercera página, de nuevo aparecerá una ventana

emergente en la que pedirá al usuario que “marque las zonas a controlar y

edítelas”.



De manera, que siguiendo las instrucciones del asistente la siguiente tarea

será crear las diferentes zonas de control. Para ello, de nuevo se marca la zona

sobre la que se desea situar el elemento de control, en caso de que el usuario no

esté convencido con el resultado obtenido, posee un botón de “MODIFICAR” que le

permite borrar esta zona y volver a crear otra.

Una vez que el usuario decida que esa es la zona final sobre la que desea

colocar el elemento de control, pulsará en la zona remarcada y le aparecerá una

ventana emergente a modo de formulario, que deberá rellenar para seleccionar si

desea crear un botón, un shape, un slider, una etiqueta o una progressbar.




En caso de querer crear un botón el formulario deberá ser rellenado de la

siguiente manera.


De manera que estamos creando un control booleano, cuyo estado por

defecto es apagado y que configura al pin 25 del módulo cero como salida. Así

mismo, en la parte de la derecha del formulario, permite elegir si se quiere un

botón de color (que se ponga en verde cuando el actuador este encendido o en rojo



en caso contrario) o un botón animado en el que se alterne la imagen elegida en

función de la posición en que se encuentre.

Una vez cumplimentado el formulario, se pulsa el botón Agregar, con el fin

de guardar este componente y posteriormente se pulsa Aceptar para posicionar el

control sobre la imagen de fondo.


Si el usuario necesita crear un slider o text, deberá cumplimentar el

formulario de la siguiente manera.


De nuevo creamos un control, pero en este caso los datos con los que

trabaja son de tipo real. Se le indicará por tanto cual será el valor máximo y



mínimo con los que se quiere trabajar y la aplicación de manera interna (como ya

se ha explicado anteriormente) llevará a cabo el escalado. Se configura como salida

analógica el pin 10 de módulo 0 y se le indica a la aplicación que cuando ofrezca el

valor en el que este posicionado el slider lo acompañe de la unidad de medida que

se le indique.

Una vez realizado el formulario se seguirán la operativa será la misma que

la expuesta en el punto anterior.


En caso de querer crear un text, el formulario se rellena de la misma manera

que en el anterior punto a excepción de que hay que marcar el check “text

Analógico”.





Para crear una progressbar el proceso es el mismo que con el resto de

controles, únicamente cambia la manera de rellenar el formulario.




En este caso se ha seleccionado un indicador (pin 0 del módulo 0), que

trabajará con datos reales (analógicos), cuyos valores oscilarán entre 0 y 30.

En la parte derecha se puede seleccionar la forma de relleno, o bien vertical

o bien horizontal, así como el color de fondo y el color de la barra de progreso. De

nuevo se le da la posibilidad al usuario de definir las unidades con las que está

trabajando y que acompañarán al dato que indica cual es el valor de la entrada

analógico (esta valor ya está escalado, en este caso entre 0 y 30).

Así mismo el usuario podrá utilizar el servicio de gestión de alarmas

marcando el check “Generar alarma”. Los campos que debe de rellenar es el valor

límite a partir del cual quiere que se genere la alarma y el texto que quiere que

aparezca.





El último elemento a crear, es un shape, que requiere rellenar el formulario

como se expone a continuación.


Con este formulario se indica que el pin 35 del módulo 0 debe trabajar como

entrada digital (Booleano, Indicador) y que parte de un estado por defecto de cero

(en este caso de apertura total de la válvula). En la parte de la derecha existen dos

zonas que pinchando sobre ellas dan la posibilidad al usuario de seleccionar la ruta

de las imágenes que deben aparecer en función del estado de las entrada.

Además se ha seleccionado que se genere una alarma cuando el sensor

transmita cero voltios.




De nuevo se pulsa Agregar y Aceptar y se cierra la ventana emergente

apareciendo el shape en la página principal.


Una vez que se tienen creados todos los elementos de control necesarios, es

una práctica recomendable guardar la aplicación, para ello se pulsa el botón

“GUARDAR” y se presentara una ventana emergente que solicitara al usuario el

nombre que quiere dar al archivo y donde lo quiere guardar, tras cumplimentar

ambas acciones la aplicación SCADA ya estará salvada y esperando a que en algún

otro momento pueda ser cargada.




El siguiente paso es generar el código que necesita el chipKIT principal para

poder gestionar tanto las comunicaciones con el PC como con los distintos

módulos integrados en el bus CAN, así como la configuración de los pines de cada

uno de los módulos que existen en la red CAN.

Para ello, se pulsa el botón “PROGRAMAR chpKIT”, la ventana emergente

que aparece es la siguiente.


*Antes de realizar esta acción el usuario debe asegurarse que está conectado

el PC con la placa de desarrollo mediante el cable USB.



Una vez que aparezca el entorno de programación de chipKIT, el usuario

deberá buscar la zona en la que ponga “Escriba el código programa a partir de esta

zona” y ahí programar su algoritmo de control. Cuando ya lo tenga programado

deberá cargar el programa a la placa, mediante la pulsación del botón:


En ese momento se comenzará a transferir el programa, mientras se este

realizando esta acción no se debe modificar ninguna línea de la programación.


Una vez se ha transferido el programa de manera correcta, se pulsa el botón

“CONECTAR” que permitirá establecer las comunicaciones entre los diferentes

módulos y el panel SCADA. Inmediatamente después de realizar esta acción, saltará

un aviso en el que se comunicará el estado de todos los módulos de la red CAN y el

usuario deberá decidir si desea continuar o por el contrario reiniciar la conexión.




7. Disposición final.

Las partes contratantes, dirección técnica y empresa, se ratifican en el

contenido del siguiente pliego de condiciones, en el cual tiene igual validez, a todos

los efectos, que una escritura pública, prometiendo fiel cumplimiento.

Presupuesto

Índice de Presupuesto. 1. Introducción. ................................................................................................................................ 1

2. Mediciones. ................................................................................................................................... 2

2.1. Partida hardware del sistema. ...................................................................................... 2

2.2. Partida software de programación. ............................................................................ 3

2.3. Partida placas de desarrollo. ......................................................................................... 3

2.4. Partida mano de obra. ...................................................................................................... 3

3. Cuadros de precios unitarios. ................................................................................................ 4

3.1. Partida hardware del sistema. ...................................................................................... 4


3.3 Partida placas de desarrollo. ......................................................................................... 5


4. Presupuesto parcial................................................................................................................... 6

4.1 Partida hardware del sistema. ...................................................................................... 6


4.3. Partida placas de desarrollo. ......................................................................................... 8


5. Presupuesto total. .................................................................................................................... 10

Telecontrol de la Red de Abastecimiento de Améscoa Baja: Mediante tecnología WiMAX.

Presupuesto 1

1. Introducción. A lo largo de esta sección se desglosara el presupuesto en base a:

• Mediciones: listado de todos los componentes y equipos necesarios, para

realizar el autómata.

• Cuadro de precios unitarios: en este apartado se contemplarán los precios

individuales de cada uno de los elementos necesarios.

• Precios parciales: en este apartado se contemplarán los precios parciales de

cada una de las partidas.

• Precios totales: se calculará el presupuesto total al que asciende el presente

proyecto.


Presupuesto 2

2. Mediciones. En este apartado se enumerarán los elementos utilizados en la red de

abastecimiento de Améscoa Baja, así como la cantidad de cada uno de ellos.

2.1. Partida hardware del sistema.

Módulo de siete entradas digitales.

DESCRIPCIÓN UNIDADES Resistencia de diferentes valores 35

Diodo led 7

Diodo zener 7

Optoacoplador 4N-25-300E 7

Condensador 7

Módulo de seis salidas digitales rápidas.

DESCRIPCIÓN UNIDADES Conversor corriente-tensión FOD 8321 6

Condensador 6

Módulo de seis salidas digitales a TRIAC.

DESCRIPCIÓN UNIDADES Circuito opto-triac MOC3021 6

Diodo led 6

Resistencias 24

Condensadores 12

TRIAC 6

Módulo de cuatro entradas analógicas.

DESCRIPCIÓN UNIDADES Analog-switches ADG 5413 4

Analog-switches AD 7512DI 2

Micro switches 4

Resistencias 12

LM 358 4

RCV 420 4


Presupuesto 3

Placa de potencia principal.

DESCRIPCIÓN UNIDADES Zócalos 12

Fuente de alimentación 1

Pin-head 7

Salidas analógicas 5

Borneros 36

Micro-switches 5

2.2. Partida software de programación. DESCRIPCIÓN UNIDADES Visual Basic Studio 1

2.3. Partida placas de desarrollo. DESCRIPCIÓN UNIDADES chipKIT MAX 32 16

2.4. Partida mano de obra.

DESCRIPCIÓN UNIDADES (Horas)

Análisis de la solución software. 5

Análisis y diseño de la parte hardware. 60

Depuración del programa en chipKIT 32MAX. 40

Programación del panel SCADA. 110

Programación de la comunicación serie y CAN bus. 80

Documentación. 50


Presupuesto 4

3. Cuadros de precios unitarios. En este apartado quedan reflejados los precios unitarios de todos los elementos

necesarios para llevar a cabo el proyecto, y que junto con el estado de mediciones

sirven para realizar el presupuesto.

3.1. Partida hardware del sistema.


DESCRIPCIÓN PRECIO UD.(€) Resistencia de diferentes valores 0.1

Diodo led 0.15

Diodo zener 0.1

Optoacoplador 4N-25-300E 0.3

Condensador 0.15


PRECIO UD.(€) PRECIO UD.(€) Conversor corriente-tensión FOD 8321 0.94

Condensador 0.15


DESCRIPCIÓN PRECIO UD.(€) Circuito opto-triac MOC3021 0.35

Diodo led 0.15

Resistencias 0.1

Condensadores 0.15

TRIAC 1.88


DESCRIPCIÓN PRECIO UD.(€) Analog-switches ADG 5413 1.8

Analog-switches AD 7512DI 1.75

Micro switches 0.55

Resistencias 12

LM 358 0.13

RCV 420 7.4


Presupuesto 5


DESCRIPCIÓN PRECIO UD.(€) Zócalos 0.55

Fuente de alimentación 1.65

Pin-head 0.55

Salidas analógicas 1

Borneros 0.75

Micro-switches 0.55

3.2. Partida software de programación. DESCRIPCIÓN PRECIO UD.(€) Visual basic studio 1283.65

3.3 Partida placas de desarrollo. DESCRIPCIÓN PRECIO UD.(€) chipKIT MAX 32 40


DESCRIPCIÓN PRECIO UD.(€)

Análisis de la solución software. 30

Análisis y diseño de la parte hardware. 30

Depuración del programa en chipKIT 32MAX. 30

Programación del panel SCADA. 30

Programación de la comunicación serie y CAN bus. 30

Documentación. 30


Presupuesto 6

4. Presupuesto parcial.

4.1 Partida hardware del sistema.



UNIDADES PRECIO (€)

Resistencia de diferentes valores 0.1 35 3.5

Diodo led 0.15 7 1.05

Diodo zener 0.1 7 0.7

Optoacoplador 4N-25-300E 0.3 7 2.1

Condensador 0.15 7 1.05




Conversor corriente-tensión FOD 8321 0.94 6 5.64

Condensador 0.15 6 0.9




Circuito opto-triac MOC3021 0.35 6 2.1

Diodo led 0.15 6 0.9

Resistencias 0.1 24 2.4

Condensadores 0.15 12 1.8

TRIAC 1.88 6 11.28


Presupuesto 7




Analog-switches ADG 5413 1.8 4 7.2

Analog-switches AD 7512DI 1.75 2 8.75

Micro switches 0.55 4 2.2

Resistencias 0.1 12 1.2

LM 358 0.13 4 0.52

RCV 420 7.4 4 29.6




Zócalos 0.55 12 6.6

Fuente de alimentación 1.65 1 1.65

Pin-head 0.55 7 3.85

Salidas analógicas 1 5 5

Borneros 0.75 36 27

Micro-switches 0.55 5 2.75

PARTIDA TOTAL PARTIDA Partida de hardware del sistema. 129.74

Asciende la partida de hardware del sistema a ciento veinte nueve con setenta

y cuatro.


Presupuesto 8

4.2. Partida software de programación.



Visual basic studio 1283.65 1 1283.65

PARTIDA TOTAL PARTIDA Partida software de programación 1283.65

Asciende la partida de software de programación a mil doscientos ocheinta y

tres con seseinta y cinco.

4.3. Partida placas de desarrollo.



chipKIT MAX 32 40 1 40

PARTIDA TOTAL PARTIDA Partida placas de desarrollo 40

Asciende la partida de placas de desarrollo a cuarenta euros.



UNIDADES (Horas)

PRECIO (€)

Análisis de la solución software. 30 5 150

Análisis y diseño de la parte

hardware.

30 60 1800

Depuración del programa en

chipKIT 32MAX.

30 40 1200

Programación del panel SCADA. 30 110 3300

Programación de la comunicación

serie y CAN bus.

30 80 2400

Documentación. 30 50 1500


Presupuesto 9

PARTIDA TOTAL PARTIDA Partida mano de obra. 10350

Asciende la partida de mano de obra a diez mil trescientos cincuenta.


Presupuesto 10

5. Presupuesto total.

PARTIDA PRESUPUESTO (€)

Partida de hardware del sistema. 129.74

Partida software de programación 1283.65

Partida placas de desarrollo 40

Partida mano de obra. 10350

TOTAL PARCIAL 11803.39

I.V.A. 21% sobre total parcial. 2478.71

TOTAL 14282.10

Asciende el precio total del proyecto a la mencionada cantidad de, CATORCE MIL DOSCIENTOS OCHEINTA Y DOS CON DIEZ EUROS.

*Los precios con los que se calcula este presupuesto son del 2013, si el proyecto no

es desarrollado en los dos años siguientes, los precios podrían ser otros.

*Los precios de los componentes electrónicos, están supeditados a la compra de

cien unidades.

*El cálculo de la partida de hardware, está realizado para un módulo de cada tipo.


Presupuesto 11



2013

MANUAL DE USUARIO

DEL PANEL SCADA v7.0

ALBERTO MARTINEZ INCHUSTA

UNIVERSIDAD DE LA RIOJA

Manual de usuario del panel SCADA. 1

El presente manual está redactado para la versión 7.0 del software de

supervisión SCADA. Pretende ser una guía útil para el usuario, que le enseñe a crear

una aplicación a su medida.

Para ello se realiza un ejemplo de cada uno de los controles posibles a crear.

Junto a estos ejemplos, se muestra al usuario como poner en marcha la aplicación,

además de mostrar la utilidad de todos los botones.


La primera pantalla de la aplicación es una pantalla de presentación, en la que

aparecen dos botones, los cuales rezan de la siguiente manera, “PROYECTO NUEVO” y

“PROYECTO EXISTENTE”. El primero de los botones permite crear un SCADA desde

cero, por su parte el segundo botón concede al usuario la posibilidad de partir de un

panel SCADA ya realizado o en proceso de realización.


Se va a partir del supuesto caso en que el usuario decide crear el proyecto

desde cero, ya que la única diferencia que existe con respecto a la otra opción es la no

necesidad de pasar por una pantalla intermedia, que se va a analizar a continuación. Si

por el contrario, se pulsaría la opción de “PROYECTO EXISTENTE”, la aplicación

direccionaría al usuario a la última de las pantallas, una vez ahí, este debería pulsar el

botón cargar y seleccionar el archivo (.xlsx) que desea cargar.

La siguiente pantalla a la que nos conducirá la aplicación será un formulario

limpio, que recibirá al usuario con una ventana emergente, en la que se le pedirá que

“delimite la zona en la que se desea colocar la imagen de fondo”.


El primer paso a realizar en esta pantalla, será delimitar el área en la que se

quiere colocar la imagen. Esto se consigue de la misma manera que cuando se quiere

realizar una selección sobre cualquier aplicación Windows. Una vez que ya se le ha

indicado a la aplicación el área en la que se quiere imprimir la imagen aparecerá de

nuevo otra ventana emergente, que indicará al usuario cual es el paso siguiente,

“Cargue la imagen de fondo”.



Pulsando sobre el botón cargar, se desplegará una pantalla emergente en la

que se solicitará la ruta de la imagen de fondo.


Una vez seleccionado el archivo .jpeg que se desea cargar, inmediatamente se

colocará la imagen sobre el fondo.



Se pulsa el botón siguiente para pasar a la siguiente página en la que se podrá

llevar a cabo la creación de los diferentes elementos que permitirán al usuario

interacturar con el proceso.

Una vez situado en la tercera página, de nuevo aparecerá una ventana

emergente en la que pedirá al usuario que “marque las zonas a controlar y edítelas”.



De manera, que siguiendo las instrucciones del asistente la siguiente tarea será

crear las diferentes zonas de control. Para ello, de nuevo se marca la zona sobre la que

se desea situar el elemento de control, en caso de que el usuario no esté convencido

con el resultado obtenido, posee un botón de “MODIFICAR” que le permite borrar esta

zona y volver a crear otra.

Una vez que el usuario decida que esa es la zona final sobre la que desea

colocar el elemento de control, pulsará en la zona remarcada y le aparecerá una

ventana emergente a modo de formulario, que deberá rellenar para seleccionar si

desea crear un botón, un shape, un slider, una etiqueta o una progressbar.



En caso de querer crear un botón el formulario deberá ser rellenado de la

siguiente manera.


De manera que estamos creando un control booleano, cuyo estado por defecto

es apagado y que configura al pin 25 del módulo cero como salida. Así mismo, en la

parte de la derecha del formulario, permite elegir si se quiere un botón de color (que

se ponga en verde cuando el actuador este encendido o en rojo en caso contrario) o un

botón animado en el que se alterne la imagen elegida en función de la posición en que

se encuentre.


Una vez cumplimentado el formulario, se pulsa el botón Agregar, con el fin de

guardar este componente y posteriormente se pulsa Aceptar para posicionar el control

sobre la imagen de fondo.


Si el usuario necesita crear un slider o text, deberá cumplimentar el formulario

de la siguiente manera.


De nuevo creamos un control, pero en este caso los datos con los que trabaja

son de tipo real. Se le indicará por tanto cual será el valor máximo y mínimo con los

que se quiere trabajar y la aplicación de manera interna (como ya se ha explicado

anteriormente) llevará a cabo el escalado. Se configura como salida analógica el pin 10

de módulo 0 y se le indica a la aplicación que cuando ofrezca el valor en el que este

posicionado el slider lo acompañe de la unidad de medida que se le indique.


Una vez realizado el formulario se seguirán la operativa será la misma que la

expuesta en el punto anterior.


En caso de querer crear un text, el formulario se rellena de la misma manera

que en el anterior punto a excepción de que hay que marcar el check “text Analógico”.




Para crear una progressbar el proceso es el mismo que con el resto de

controles, únicamente cambia la manera de rellenar el formulario.


En este caso se ha seleccionado un indicador (pin 0 del módulo 0), que

trabajará con datos reales (analógicos), cuyos valores oscilarán entre 0 y 30.

En la parte derecha se puede seleccionar la forma de relleno, o bien vertical o

bien horizontal, así como el color de fondo y el color de la barra de progreso. De nuevo

se le da la posibilidad al usuario de definir las unidades con las que está trabajando y

que acompañarán al dato que indica cual es el valor de la entrada analógico (esta valor

ya está escalado, en este caso entre 0 y 30).


Así mismo el usuario podrá utilizar el servicio de gestión de alarmas marcando

el check “Generar alarma”. Los campos que debe de rellenar es el valor límite a partir

del cual quiere que se genere la alarma y el texto que quiere que aparezca.



El último elemento a crear, es un shape, que requiere rellenar el formulario

como se expone a continuación.


Con este formulario se indica que el pin 35 del módulo 0 debe trabajar como

entrada digital (Booleano, Indicador) y que parte de un estado por defecto de cero (en


este caso de apertura total de la válvula). En la parte de la derecha existen dos zonas

que pinchando sobre ellas dan la posibilidad al usuario de seleccionar la ruta de las

imágenes que deben aparecer en función del estado de las entrada.

Además se ha seleccionado que se genere una alarma cuando el sensor

transmita cero voltios.


De nuevo se pulsa Agregar y Aceptar y se cierra la ventana emergente

apareciendo el shape en la página principal.


Una vez que se tienen creados todos los elementos de control necesarios, es

una práctica recomendable guardar la aplicación, para ello se pulsa el botón

“GUARDAR” y se presentara una ventana emergente que solicitara al usuario el

nombre que quiere dar al archivo y donde lo quiere guardar, tras cumplimentar ambas

acciones la aplicación SCADA ya estará salvada y esperando a que en algún otro

momento pueda ser cargada.



El siguiente paso es generar el código que necesita el chipKIT principal para

poder gestionar tanto las comunicaciones con el PC como con los distintos módulos

integrados en el bus CAN, así como la configuración de los pines de cada uno de los

módulos que existen en la red CAN.

Para ello, se pulsa el botón “PROGRAMAR chpKIT”, la ventana emergente que

aparece es la siguiente.


*Antes de realizar esta acción el usuario debe asegurarse que está conectado el

PC con la placa de desarrollo mediante el cable USB.


Una vez que aparezca el entorno de programación de chipKIT, el usuario deberá

buscar la zona en la que ponga “Escriba el código programa a partir de esta zona” y ahí

programar su algoritmo de control. Cuando ya lo tenga programado deberá cargar el

programa a la placa, mediante la pulsación del botón:


En ese momento se comenzará a transferir el programa, mientras se este

realizando esta acción no se debe modificar ninguna línea de la programación.


Una vez se ha transferido el programa de manera correcta, se pulsa el botón

“CONECTAR” que permitirá establecer las comunicaciones entre los diferentes

módulos y el panel SCADA. Inmediatamente después de realizar esta acción, saltará un

aviso en el que se comunicará el estado de todos los módulos de la red CAN y el

usuario deberá decidir si desea continuar o por el contrario reiniciar la conexión.


Controlador modular programable, basado en procesador de ... · Controlador modular programable,...

Documents

Transcript of Controlador modular programable, basado en procesador de ... · Controlador modular programable,...