Memoria Descriptiva

Proyecto Final de carrera

Escuela Superior de Ingenieros

Universidad de Sevilla

Desarrollo del Software de una

Red de Sensores de Medidas de

Consumo Eléctrico Documento 1: Memoria Descriptiva

Presentado para optar al Título de Ingeniero en Automática y Electrónica

Supervisado por:

Luis Fernando Castaño Castaño

Proyectistas:

Diego Francisco Larios Marín DNI: 28760057-Y Sevilla, 10 de Septiembre de 2009

Red de Sensores de Medidas de Consumo Eléctrico

Memoria Descriptiva Documento 1

Diego Francisco Larios Marín Enrique Personal Vázquez i

El presente proyecto denominado “Desarrollo de Software de una Red de Sensores de Medidas de Consumo Eléctrico” se corresponde con el desarrollo de la programación necesaria para el diseño de una red una red de sensores de medidas eléctricas comunicados, capaces de medir corrientes de hasta 16A y que permitan realizar un estudio de consumo energético en una vivienda, así como de todo el software necesario para el desarrollo del nodo central de la instalación y de los interfaces de comunicación.

Dichos sensores estarán formada por dispositivos cuyo tamaño final no podrá exceder las dimensiones que quedan libres entre un enchufe de empotrar y su caja, con el fin de poderlos disimular en la instalación final detrás de dichos enchufes, además de presentar un coste económico que hagan asumible su instalación.

Este proyecto se complementa con el proyecto denominado “Desarrollo de Hardware de una Red de Sensores de Medidas de Consumo Eléctrico”, realizado por Enrique Personal Vázquez, formando ambos proyectos uno más global denominado “Red de Sensores de Medidas de Consumo Eléctrico”.

Con el fin de aumentar la claridad y debido al acuerdo llegado por los autores junto con el tutor de ambos proyectos, D. Luis Fernando Castaño Castaño, se ha decidido que en la presente documentación se incluya el proyecto global completo, lo que permite una mejor comprensión del funcionamiento de los dispositivos, así como quedar más claramente patente los motivos de las decisiones tomadas con respecto al software, decisiones que sin conocer el hardware, al menos levemente, serían difíciles de entender y justificar.



Diego Francisco Larios Marín Enrique Personal Vázquez ii

ÍNDICE DE CONTENIDOS

1 INTRODUCCIÓN. ................................................................................................................. 1

2 OBJETO DEL PROYECTO. ................................................................................................ 2

3 ALCANCE DEL PROYECTO. ............................................................................................. 2

4 ANTECEDENTES. ................................................................................................................. 3

5 VIABILIDAD TECNOLÓGICA DEL PROYECTO. .............. ........................................... 4

6 ANÁLISIS DE LA SITUACIÓN ACTUAL. .................. ...................................................... 5

7 ANÁLISIS DE LAS DISTINTAS SOLUCIONES HARDWARE. .... ................................. 6

7.1 BLOQUE 1: TRANSDUCTORES DE LAS MEDIDAS. ................................................................ 7 7.1.1 Medida de corriente. ................................................................................................... 7

7.1.1.1 Transductor de medida de corriente con aislamiento. ..................................................... 7 7.1.1.2 Transductor de medida de corriente sin aislamiento. ...................................................... 8

7.1.2 Medida de tensión. ...................................................................................................... 9 7.1.2.1 Transductor de medida de tensión con aislamiento. ........................................................ 9 7.1.2.2 Transductor de medida de tensión sin aislamiento. ......................................................... 9

7.1.3 Conclusiones obtenidas referentes a la elección de los transductores de las medidas del dispositivo. ............................................................................................ 10

7.2 BLOQUE 2: ACONDICIONAMIENTO DE LAS SEÑALES. ....................................................... 10 7.2.1 Acondicionamiento de señal sin desplazamiento de nivel. ....................................... 10

7.2.2 Acondicionamiento de la señal con desplazamiento de nivel. .................................. 11

7.2.3 Acondicionamiento de la señal con desplazamiento de nivel, filtro paso bajo y medida diferencial. ................................................................................................... 12

7.2.4 Acondicionamiento de la señal para CAD bipolar, diferencial y con filtro incorporado en el µC. ............................................................................................... 13

7.2.5 Conclusiones obtenidas referentes a la elección del circuito de acondicionamiento de señal. .................................................................................... 14

7.3 BLOQUE 3: ADQUISICIÓN Y PROCESADO DE LA INFORMACIÓN (µC). ............................... 14

7.3.1 Utilización de un µC simple (MSP430F1xxx). ......................................................... 15

7.3.2 Utilización de un µC simple (MSP430F2xxx). ......................................................... 16

7.3.3 Utilización de un µC complejo (MSP430F4xxx). ..................................................... 17

7.3.4 Conclusiones obtenidas referentes a la elección del circuito de adquisición y procesador de la información. .................................................................................. 18

7.4 BLOQUE 4: COMUNICACIONES. ....................................................................................... 19

7.4.1 Comunicaciones cableadas. ..................................................................................... 19 7.4.1.1 Comunicaciones RS232. ............................................................................................... 20 7.4.1.2 Comunicaciones RS485. ............................................................................................... 21

7.4.1.2.1 Comunicaciones Modbus. ..................................................................................... 22 7.4.1.2.2 Comunicaciones Profibus. .................................................................................... 23

7.4.1.3 Comunicaciones EIB/KNX. .......................................................................................... 24 7.4.1.4 Comunicaciones LonWorks. ......................................................................................... 25

7.4.2 Comunicaciones inalámbricas. ................................................................................. 26 7.4.2.1 Z-wave. ......................................................................................................................... 26 7.4.2.2 ZigBee. .......................................................................................................................... 27

7.4.3 Conclusiones obtenidas referentes a las comunicaciones. ....................................... 30

7.5 BLOQUE 5: CONTROL SOBRE LA CARGA. ......................................................................... 30 7.5.1 Control por relé. ....................................................................................................... 30



Diego Francisco Larios Marín Enrique Personal Vázquez iii

7.5.2 Control por triac. ...................................................................................................... 32 7.5.3 Conclusiones obtenidas referentes al diseño del circuito de control de carga. ........ 34

7.6 BLOQUE 6: FUENTES DE ALIMENTACIÓN. ........................................................................ 35 7.6.1 Fuente de alimentación capacitiva sin transformador. ............................................ 35

7.6.2 Fuente de alimentación con transformador a 50Hz. ................................................ 36

7.6.3 Fuente de alimentación conmutada. ......................................................................... 38 7.6.4 Fuente de alimentación flotante para las comunicaciones aisladas......................... 40

7.6.5 Conclusiones obtenidas referentes al diseño de la fuente de alimentación. ............. 40

8 SOLUCIÓN HARDWARE ADOPTADA. ......................................................................... 41

8.1 PROTOTIPO DE VALIDACIÓN DEL DISEÑO. ........................................................................ 41 8.2 PROTOTIPO DE DISEÑO INDUSTRIAL. ............................................................................... 42

8.3 INTERFAZ USB-RS485. .................................................................................................. 43 8.4 TARJETA µC DE PROPÓSITO GENERAL. ............................................................................ 44

9 ANÁLISIS DE LAS DISTINTAS SOLUCIONES SOFTWARE ..... ................................ 45

9.1 DETERMINACIÓN DE LA HERRAMIENTA DE PROGRAMACIÓN A UTILIZAR PARA EL

MICROCONTROLADOR. .................................................................................................... 45

9.1.1 CrossStudio. .............................................................................................................. 45 9.1.2 IAR Embedded Workbench KickStart. ...................................................................... 46 9.1.3 IAR Embedded Workbench. ...................................................................................... 47 9.1.4 Code composer. ........................................................................................................ 48 9.1.5 GNU C compiler for MSP430. .................................................................................. 49 9.1.6 Conclusiones referentes al software de programación. ............................................ 50

9.2 DETERMINACIÓN DEL SOFTWARE DE SCADA. ............................................................... 50 9.2.1 WinCC. ..................................................................................................................... 51 9.2.2 Vijeo Citect. .............................................................................................................. 52 9.2.3 LabView. ................................................................................................................... 53 9.2.4 Programa para PC hecho en Borland C. ................................................................. 54

9.2.5 Conclusiones referentes en cuanto al software de SCADA a utilizar. ...................... 55

9.3 DETERMINACIÓN DEL MÉTODO DE COMUNICACIÓN ENTRE EL SCADA Y LOS

MÓDULOS. ....................................................................................................................... 55 9.3.1 Comunicación mediante programación del protocolo (ActiveX). ............................ 55

9.3.2 Comunicación mediante servidor de variables (módulo OPC). ............................... 56

9.3.3 Comunicación directa mediante driver embebidos en el SCADA............................. 57

9.3.4 Conclusiones referentes al método de comunicación. .............................................. 57

9.4 DETERMINACIÓN DE LAS ALTERNATIVAS REFERENTES AL DISEÑO DEL SOFTWARE

DEL µC. ........................................................................................................................... 57 9.4.1 Implementación del programa del µC con un planificador cíclico. ......................... 57

9.4.2 Implementación del programa del µC con varios niveles de ejecución, sin Sistema Operativo. .................................................................................................... 58

9.4.3 Implementación del programa del µC mediante el uso de un sistema operativo. .... 59

9.4.4 Conclusiones referentes a las alternativas del diseño software. .............................. 59

9.5 DETERMINACIÓN DE LAS ALTERNATIVAS REFERENTES AL MÉTODO DE LA MEDIDA

DE POTENCIA ACTIVA. ..................................................................................................... 59 9.5.1 Medida de la tensión y la corriente de manera simultánea. ..................................... 60

9.5.2 Medida de la potencia con el principio del tiempo reducido de muestreo. .............. 61

9.5.3 Conclusiones referentes al método de la medida de la potencia activa. .................. 63

10 SOLUCIÓN SOFTWARE ADOPTADA. ........................................................................... 63



Diego Francisco Larios Marín Enrique Personal Vázquez iv

10.1 EXPLICACIÓN DETALLADA DE LOS MÓDULOS DEL PROGRAMA DEL

MICROCONTROLADOR. .................................................................................................... 65

10.1.1 Módulo main. ............................................................................................................ 65 10.1.1.1 Definición de la cabecera (Vatimetro.h). .................................................................... 65 10.1.1.2 Definición de las funciones (main.c). .......................................................................... 65

10.1.1.2.1 Función main. ..................................................................................................... 66 10.1.1.2.1.1 Prototipo de la función................................................................................ 67 10.1.1.2.1.2 Tabla de variables globales. ........................................................................ 67 10.1.1.2.1.3 Tabla de variables locales. .......................................................................... 67 10.1.1.2.1.4 Tabla de constantes. .................................................................................... 68

10.1.1.2.2 Función Inicia. .................................................................................................... 69 10.1.1.2.2.1 Prototipo de la función................................................................................ 70 10.1.1.2.2.2 Tabla de variables globales. ........................................................................ 70 10.1.1.2.2.3 Tabla de variables locales. .......................................................................... 70 10.1.1.2.2.4 Tabla de constantes. .................................................................................... 70

10.1.1.2.3 Función Inicia_cad. ............................................................................................. 71 10.1.1.2.3.1 Prototipo de la función................................................................................ 72 10.1.1.2.3.2 Tabla de variables locales. .......................................................................... 72 10.1.1.2.3.3 Tabla de constantes. .................................................................................... 72

10.1.1.2.4 Función IniFlash. ................................................................................................ 73 10.1.1.2.4.1 Prototipo de la función................................................................................ 73 10.1.1.2.4.2 Tabla de variables globales. ........................................................................ 74 10.1.1.2.4.3 Tabla de variables locales. .......................................................................... 74 10.1.1.2.4.4 Tabla de constantes. .................................................................................... 74

10.1.1.2.5 Función SeccionCriticaINT. ............................................................................... 75 10.1.1.2.5.1 Prototipo de la función................................................................................ 75 10.1.1.2.5.2 Tabla de variables de entrada...................................................................... 75

10.1.1.2.6 Función SeccionCriticaLINT. ............................................................................. 76 10.1.1.2.6.1 Prototipo de la función................................................................................ 76 10.1.1.2.6.2 Tabla de variables de entrada...................................................................... 77 10.1.1.2.6.3 Tabla de variables locales. .......................................................................... 77

10.1.1.2.7 Función SeccionCriticaTablaINT. ...................................................................... 78 10.1.1.2.7.1 Prototipo de la función................................................................................ 78 10.1.1.2.7.2 Tabla de variables de entrada...................................................................... 78 10.1.1.2.7.3 Tabla de variables locales. .......................................................................... 78

10.1.1.2.8 Función ControlFlash. ........................................................................................ 79 10.1.1.2.8.1 Prototipo de la función................................................................................ 80 10.1.1.2.8.2 Tabla de variables globales. ........................................................................ 80 10.1.1.2.8.3 Tabla de variables locales. .......................................................................... 80 10.1.1.2.8.4 Tabla de constantes. .................................................................................... 80

10.1.1.2.9 Función ControlEnergia. ..................................................................................... 81 10.1.1.2.9.1 Prototipo de la función................................................................................ 81 10.1.1.2.9.2 Tabla de variables de entrada...................................................................... 82 10.1.1.2.9.3 Tabla de variables locales. .......................................................................... 82 10.1.1.2.9.4 Tabla de constantes. .................................................................................... 82 10.1.1.2.9.5 Tabla de variables de salida. ....................................................................... 82

10.1.1.2.10 Función SD16AISR. ......................................................................................... 83 10.1.1.2.10.1 Prototipo de la función.............................................................................. 84

10.1.1.2.10.2 Tabla de variables globales. ...................................................................... 84 10.1.1.2.10.3 Tabla de variables locales. ........................................................................ 84 10.1.1.2.10.4 Tabla de constantes. .................................................................................. 85

10.1.2 Módulo Medidas. ...................................................................................................... 86 10.1.2.1 Definición de la cabecera (Medidas.h). ....................................................................... 86 10.1.2.2 Definición de las funciones (Medidas.c). .................................................................... 86

10.1.2.2.1 Función CalculaRMS. ......................................................................................... 87



Diego Francisco Larios Marín Enrique Personal Vázquez v

10.1.2.2.1.1 Prototipo de la función................................................................................ 87 10.1.2.2.1.2 Tabla de variables de entrada...................................................................... 87 10.1.2.2.1.3 Tabla de variables de salida. ....................................................................... 88

10.1.2.2.2 Función CalculaMedia. ....................................................................................... 89 10.1.2.2.2.1 Prototipo de la función................................................................................ 89 10.1.2.2.2.2 Tabla de variables de entrada...................................................................... 89 10.1.2.2.2.3 Tabla de variables de salida. ....................................................................... 90

10.1.2.2.3 Función CalculaPact. .......................................................................................... 91 10.1.2.2.3.1 Prototipo de la función................................................................................ 91 10.1.2.2.3.2 Tabla de variables de entrada...................................................................... 91 10.1.2.2.3.3 Tabla de variables de salida. ....................................................................... 92

10.1.2.2.4 Función CalculaPapar. ........................................................................................ 93 10.1.2.2.4.1 Prototipo de la función................................................................................ 93 10.1.2.2.4.2 Tabla de variables de entrada...................................................................... 93 10.1.2.2.4.3 Tabla de variables de salida. ....................................................................... 93

10.1.2.2.5 Función CalculaPreact. ....................................................................................... 94 10.1.2.2.5.1 Prototipo de la función................................................................................ 94 10.1.2.2.5.2 Tabla de variables de entrada...................................................................... 94 10.1.2.2.5.3 Tabla de variables de salida. ....................................................................... 94

10.1.2.2.6 Función CalculaFDP. .......................................................................................... 95 10.1.2.2.6.1 Prototipo de la función................................................................................ 95 10.1.2.2.6.2 Tabla de variables de entrada...................................................................... 95 10.1.2.2.6.3 Tabla de variables de salida. ....................................................................... 95

10.1.2.2.7 Función CalculaEnergia. ..................................................................................... 96 10.1.2.2.7.1 Prototipo de la función................................................................................ 96 10.1.2.2.7.2 Tabla de variables de entrada...................................................................... 96

10.1.2.2.7.3 Tabla de variables de salida. ....................................................................... 96 10.1.2.2.8 Función CalculaFrec. .......................................................................................... 97

10.1.2.2.8.1 Prototipo de la función................................................................................ 98 10.1.2.2.8.2 Tabla de variables de entrada...................................................................... 98 10.1.2.2.8.3 Tabla de variables locales. .......................................................................... 98 10.1.2.2.8.4 Tabla de variables de salida. ....................................................................... 98

10.1.2.2.9 Función CaclulaTemp. ........................................................................................ 99 10.1.2.2.9.1 Prototipo de la función................................................................................ 99 10.1.2.2.9.2 Tabla de variables de entrada.................................................................... 100 10.1.2.2.9.3 Tabla de variables locales. ........................................................................ 100 10.1.2.2.9.4 Tabla de variables de salida. ..................................................................... 100

10.1.2.2.10 Función round. ................................................................................................ 101 10.1.2.2.10.1 Prototipo de la función............................................................................ 101 10.1.2.2.10.2 Tabla de variables de entrada.................................................................. 101 10.1.2.2.10.3 Tabla de variables de salida. ................................................................... 101

10.1.3 Módulo Modbus. ..................................................................................................... 102 10.1.3.1 Definición de la cabecera (modbus.h). ...................................................................... 102 10.1.3.2 Definición de las funciones (modbus.c). ................................................................... 102

10.1.3.2.1 Función IniModbus. .......................................................................................... 103 10.1.3.2.1.1 Prototipo de la función.............................................................................. 104 10.1.3.2.1.2 Tabla de variables de entrada.................................................................... 104 10.1.3.2.1.3 Tabla de variables globales. ...................................................................... 104

10.1.3.2.1.4 Tabla de constantes. .................................................................................. 104 10.1.3.2.1.5 Tabla de variables de salida. ..................................................................... 105

10.1.3.2.2 Función NuevosDatos. ...................................................................................... 106 10.1.3.2.2.1 Prototipo de la función.............................................................................. 107 10.1.3.2.2.2 Tabla de variables de entrada.................................................................... 107

10.1.3.2.2.3 Tabla de variables globales. ...................................................................... 107 10.1.3.2.2.4 Tabla de variables locales. ........................................................................ 107



Diego Francisco Larios Marín Enrique Personal Vázquez vi


10.1.3.2.3 Función Sobretiempo. ....................................................................................... 108 10.1.3.2.3.1 Prototipo de la función.............................................................................. 108 10.1.3.2.3.2 Tabla de variables de entrada.................................................................... 108

10.1.3.2.4 Función CRC16. ............................................................................................... 109 10.1.3.2.4.1 Prototipo de la función.............................................................................. 109 10.1.3.2.4.2 Tabla de variables de entrada.................................................................... 110 10.1.3.2.4.3 Tabla de variables locales. ........................................................................ 110


10.1.3.2.5 Función IniTimerA. .......................................................................................... 111 10.1.3.2.5.1 Prototipo de la función.............................................................................. 111

10.1.3.2.6 Función IniUART. ............................................................................................ 112 10.1.3.2.6.1 Prototipo de la función.............................................................................. 112

10.1.3.2.7 Función AnalizarDatos. .................................................................................... 113 10.1.3.2.7.1 Prototipo de la función.............................................................................. 114 10.1.3.2.7.2 Tabla de variables globales. ...................................................................... 114 10.1.3.2.7.3 Tabla de variables locales. ........................................................................ 114

10.1.3.2.8 Función Error. ................................................................................................... 115 10.1.3.2.8.1 Prototipo de la función.............................................................................. 115 10.1.3.2.8.2 Tabla de variables de entrada.................................................................... 115 10.1.3.2.8.3 Tabla de variables globales. ...................................................................... 115

10.1.3.2.9 Función AddCRC. ............................................................................................ 116 10.1.3.2.9.1 Prototipo de la función.............................................................................. 116 10.1.3.2.9.2 Tabla de variables de entrada.................................................................... 116

10.1.3.2.9.3 Tabla de variables globales. ...................................................................... 116 10.1.3.2.9.4 Tabla de variables locales. ........................................................................ 116

10.1.3.2.10 Función TestModBusFree. .............................................................................. 117 10.1.3.2.10.1 Prototipo de la función............................................................................ 117 10.1.3.2.10.2 Tabla de variables de entrada.................................................................. 118

10.1.3.2.10.3 Tabla de variables globales. .................................................................... 118 10.1.3.2.10.4 Tabla de constantes. ................................................................................ 118 10.1.3.2.10.5 Tabla de variables de salida. ................................................................... 118

10.1.3.2.11 Función IntTimer. ........................................................................................... 119 10.1.3.2.11.1 Prototipo de la función............................................................................ 120 10.1.3.2.11.2 Tabla de variables globales. .................................................................... 120

10.1.3.2.12 Función IntUARTRx. ..................................................................................... 121 10.1.3.2.12.1 Prototipo de la función............................................................................ 121 10.1.3.2.12.2 Tabla de variables globales. .................................................................... 122

10.1.3.2.13 Función IntUARTTx. ...................................................................................... 123 10.1.3.2.13.1 Prototipo de la función............................................................................ 123

10.1.3.2.13.2 Tabla de variables globales. .................................................................... 123

10.1.4 Módulo Flash. ......................................................................................................... 124 10.1.4.1 Definición de la cabecera (Flash.h). .......................................................................... 124 10.1.4.2 Definición de las funciones (Flash.c). ....................................................................... 124

10.1.4.2.1 Función Flash2float. ......................................................................................... 125 10.1.4.2.1.1 Prototipo de la función.............................................................................. 125 10.1.4.2.1.2 Tabla de variables de entrada.................................................................... 125 10.1.4.2.1.3 Tabla de variables locales. ........................................................................ 125 10.1.4.2.1.4 Tabla de variables de salida. ..................................................................... 125

10.1.4.2.2 Función Flash2TablaFloat. ............................................................................... 126 10.1.4.2.2.1 Prototipo de la función.............................................................................. 126 10.1.4.2.2.2 Tabla de variables de entrada.................................................................... 126 10.1.4.2.2.3 Tabla de variables locales. ........................................................................ 126



Diego Francisco Larios Marín Enrique Personal Vázquez vii

10.1.4.2.3 Función EraseFlash. .......................................................................................... 127 10.1.4.2.3.1 Prototipo de la función.............................................................................. 127 10.1.4.2.3.2 Tabla de variables de entrada.................................................................... 127

10.1.4.2.4 Función WriteFlash........................................................................................... 128 10.1.4.2.4.1 Prototipo de la función.............................................................................. 128 10.1.4.2.4.2 Tabla de variables de entrada.................................................................... 129 10.1.4.2.4.3 Tabla de variables locales. ........................................................................ 129 10.1.4.2.4.4 Tabla de constantes. .................................................................................. 129 10.1.4.2.4.5 Tabla de variables de salida. ..................................................................... 129

10.2 EXPLICACIÓN DEL SOFTWARE DE SCADA. ................................................................... 130

11 ESPECIFICACIONES BÁSICAS DEL PROYECTO. ................................................... 130

11.1 CARACTERÍSTICAS MECÁNICAS. .................................................................................... 130

11.2 CARACTERÍSTICAS ELÉCTRICAS. ................................................................................... 130

11.3 INDICADORES DE FUNCIONAMIENTO. ............................................................................ 130

11.4 CARACTERÍSTICAS FUNCIONALES. ................................................................................ 131

12 OTRAS OPCIONES DE FUTURO. ................................................................................. 131

12.1 MEJORAS ECONÓMICAS Y ENERGÉTICAS. ...................................................................... 132 12.2 MEJORAS APLICADAS AL ÁMBITO DE LA DOMÓTICA...................................................... 133 12.3 MEJORAS APLICADAS A OTROS ÁMBITOS. ..................................................................... 133

13 BIBLIOGRAFÍA. ............................................................................................................... 134

14 ENLACES DE INTERÉS .................................................................................................. 135

15 SOFTWARE UTILIZADO. ............................................................................................... 136



Diego Francisco Larios Marín Enrique Personal Vázquez viii

ÍNDICE DE IMÁGENES

Figura 1: Casa a automatizar. A)Vista General. B)Planta baja. C)Planta primera. D)Ático. .......................................................................................................... 5

Figura 2: Diagrama de bloques del hardware del proyecto. .............................................. 6

Figura 3: Transductores de medida aislada de corriente. A: Transformador de corriente. B: Sensor de efecto hall. ................................................................ 8

Figura 4: Transductores de medida no aislada de corriente. A)Resistencia tipo through hole. B)Resistencia tipo SMD. ......................................................... 8

Figura 5: Circuito de medida no aislada de corriente. ....................................................... 8

Figura 6: Transductor de medida aislada de tensión. ........................................................ 9

Figura 7: Circuito de medida no aislada de tensión........................................................... 9

Figura 8: Circuito de acondicionamiento de la señal sin desplazamiento de nivel. ........ 10

Figura 9: Circuito de acondicionamiento de la señal con desplazamiento de nivel. ....... 11

Figura 10: Circuito de acondicionamiento de la señal con desplazamiento de nivel, filtro paso bajo incorporado y medida diferencial. ....................................... 12

Figura 11: Prototipo Acondicionamiento de Señal. ........................................................ 13

Figura 12: Filtro paso bajo RC. ....................................................................................... 13

Figura 13: Familia MSP430 de Texas Instruments. ........................................................ 14

Figura 14: Modelo OSI. ................................................................................................... 19

Figura 15: Conectores estándar RS-232C. ...................................................................... 20

Figura 16: Interfaz Rs232toRs232C. ............................................................................... 21

Figura 17: Prototipos de los circuitos. ............................................................................. 22

Figura 18: Módulo z-wave ZM3102N. ........................................................................... 27

Figura 19: Red ZigBee con topología de malla. .............................................................. 28

Figura 20: Prototipo del circuito. ..................................................................................... 29



Diego Francisco Larios Marín Enrique Personal Vázquez ix

Figura 21: Ejemplo de relé electromagnético. ................................................................. 31

Figura 22: Esquema del circuito de control de carga con relé......................................... 32

Figura 23: Comportamiento del relé en reposo y excitado. ............................................. 32

Figura 24: A) Símbolo del triac. B) Curva característica de un triac. ............................. 33

Figura 25: Esquema del circuito de control de carga con triac. ...................................... 34

Figura 26: Esquema de la fuente de alimentación capacitiva. ......................................... 36

Figura 27: Prototipo de la fuente de alimentación capacitiva. ........................................ 36

Figura 28: Diagrama de una fuente de alimentación convencional................................. 37

Figura 29: Esquema de la fuente de alimentación convencional..................................... 37

Figura 30: Prototipo de la fuente de alimentación convencional. ................................... 38

Figura 31: Diagrama de una fuente de alimentación conmutada. ................................... 38

Figura 32: F.A. flotante para las comunicaciones aisladas.............................................. 40

Figura 33: Dimensiones del transformador HALO TGM-040P3. ................................... 40

Figura 34: Prototipo de validación del diseño. ................................................................ 42

Figura 35: Layout del prototipo de explotación. ............................................................. 43

Figura 36: Interfaz USBtoRs485. .................................................................................... 44

Figura 37: Prototipo Tarjeta uC MSP430F2274 ............................................................. 44

Figura 38: CrossStudio de Rowley Associates. ............................................................... 46

Figura 39: IAR Embedded Workbench KickStart. .......................................................... 46

Figura 40: IAR Embedded Workbench. .......................................................................... 47

Figura 41: Code Composer de Texas Instruments........................................................... 48

Figura 42: GCC para MSP430. ....................................................................................... 49

Figura 43: Herramienta de depuración gratuita para MSP430. ....................................... 50

Figura 44: WinCC de Siemens. ....................................................................................... 51



Diego Francisco Larios Marín Enrique Personal Vázquez x

Figura 45: Vijeo Citect .................................................................................................... 52

Figura 46: LabView de National Instruments. ................................................................ 53

Figura 47: Entorno de desarrollo integrado Borland C. .................................................. 54

Figura 48: Servidor OPC. ................................................................................................ 56

Figura 49: Logotipo de Tiny Os, un sistema operativo desarrollado para microconroladores.................................................................................... 59

Figura 50: Timing de la técnica del principio de muestro reducido. ............................... 61

Figura 51: Formas de onda de la tensión, corriente y potencia instantánea. ................... 62



Diego Francisco Larios Marín Enrique Personal Vázquez xi

ÍNDICE DE TABLAS

Tabla 1: Comparativa entre transductores de corriente. ................................................... 7

Tabla 2: Comparativa entre transductores de tensión. ...................................................... 9

Tabla 3: Características del circuito. .............................................................................. 11



Tabla 6: Características de la familia MSP430F1xxx. ................................................... 16



Tabla 9: Características de las comunicaciones cableadas. ............................................ 19

Tabla 10: Características de las comunicaciones RS-232. ............................................. 20

Tabla 11: Características de las comunicaciones RS-485. ............................................. 21

Tabla 12: Características de las comunicaciones Modbus. ............................................ 23

Tabla 13: Características de las comunicaciones Profibus. ............................................ 24

Tabla 14: Características de las comunicaciones EIB/KNX. ......................................... 24

Tabla 15: Características de las comunicaciones LonWorks. ........................................ 25

Tabla 16: Características de las comunicaciones inalámbricas. ..................................... 26

Tabla 17: Algunas alternativas ZigBee de Texas Instruments. ...................................... 29

Tabla 18: Características del circuito de control de carga con relé. ............................... 31

Tabla 19: Características del circuito de control de carga con triac. .............................. 33

Tabla 20: Características de las fuentes de alimentación capacitivas. ........................... 35

Tabla 21: Características de las fuentes de alimentación convencionales...................... 37

Tabla 22: Características de las fuentes de alimentación conmutada. ............................ 39

Tabla 23: Características del CrossStudio. ..................................................................... 45



Diego Francisco Larios Marín Enrique Personal Vázquez xii

Tabla 24: Características del IAR Embedded Workbench KickStart............................. 47

Tabla 25: Características del IAR Embedded Workbench. ............................................ 48

Tabla 26: Características del Code Composer. ............................................................... 49

Tabla 27: Características del GCC para MSP430. ......................................................... 49

Tabla 28: Características del WinCC. ............................................................................ 51

Tabla 29: Características del Vijeo Citect. ..................................................................... 52

Tabla 30: Características del LabView. .......................................................................... 53

Tabla 31: Características de un programa para PC hecho en Borland C. ....................... 54

Tabla 32: Características del uso de ActiveX. ................................................................ 55

Tabla 33: Características del uso de un servidor OPC. .................................................. 56

Tabla 34: Características del driver embebidos en el SCADA. ..................................... 57

Tabla 35: Características del uso de un planificador cíclico. ......................................... 58

Tabla 36: Características del uso de un planificador con varios niveles de ejecución, sin Sistema Operativo. ......................................................................................... 58

Tabla 37: Características del uso de un sistema operativo para el µC. .......................... 59

Tabla 38: Características del método de medida de la tensión y la corriente de manera simultánea. ..................................................................................................... 60

Tabla 39: Características del método de medida de la potencia con el principio del tiempo reducido de muestreo. ........................................................................ 61



Diego Francisco Larios Marín Enrique Personal Vázquez 1

1 INTRODUCCIÓN.

En este proyecto se va a tratar de desarrollar el prototipo de un medidor de consumo eléctrico que formará parte una red de sensores comunicados que permita realizar un estudio de consumo energético en una vivienda.

Este sensor deberá tener un tamaño tal que permita integrarse directamente en el receptáculo de un enchufe, denominado comúnmente “cajillo”, quedando totalmente disimulado en la instalación final.

El presente proyecto se puede enmarcar dentro de la actual tendencia de la automatización de viviendas, frecuentemente denominada domótica, que aporta una serie de ventajas al usuario, tales como:

o Ahorro energético.

o Aumento del confort.

o Aumento de la seguridad.

o Posibilidad de telecontrol de la instalación.

El presente proyecto se ha desarrollado teniendo en cuenta todos estos factores, por lo que se ha dotado a estos dispositivos de una funcionalidad avanzada que no solo permite medir y monitorizar a distancia el consumo eléctrico, sino que también permite actuar sobre la carga, desconectándola cuando no se cumplan las condiciones de seguridad o de consumo energético prefijado.

Una gran desventaja que presentan las instalaciones domóticas actuales consiste en el elevado precio de los dispositivos, lo que se ve aún más agravado por el coste de las licencias de algunos buses domóticos actuales, tales como LonWorks o EIB.

En el presente proyecto se ha tenido esto en cuenta, tratándose de presentar una solución lo más estándar posible en cuanto a sus comunicaciones, evaluando tanto comunicaciones cableadas como inalámbricas, y que a la vez tenga un coste reducido.

Además del desarrollo del prototipo medidor, el presente proyecto también incluye el desarrollo de un SCADA que permita demostrar el correcto funcionamiento del sistema desarrollado.




2 OBJETO DEL PROYECTO.

Con el presente proyecto se pretende conseguir la realización de un prototipo de una serie de medidores de consumo eléctrico que se puedan empotrar en un enchufe y que permitan medir una corriente de hasta 16A. No obstante, de diseñará con capacidad de soportar un valor mayor de corriente máxima soportada, aunque no sea capaz de medir dicho valor.

Adicionalmente el dispositivo implementará medidas de protección de sobrecorriente configurables, con el fin de mejorar la seguridad de la instalación.

Dichos medidores se comunicaran con un dispositivo que actuará como maestro, desde el cual se podrán realizar consultas y, adicionalmente, actuar activando o desactivando la carga.

La construcción de un ejemplo de nodo maestro también formará parte de los elementos a desarrollar en el presente proyecto.

Paralelamente al desarrollo de este proyecto, se solicitó el desarrollo de unas tarjetas de prototipo económicas con un microcontrolador, que sirvan como punto de partida de futuros desarrollos de proyectos finales de carrera.

3 ALCANCE DEL PROYECTO.

El Proyecto se desarrolla en varias partes claramente diferenciadas:

o Un estudio de los buses de campo, tanto industriales como domóticos para determinar aquellos que mejor se adapten a las necesidades del presente proyecto.

o Diseño del hardware necesario para la construcción del prototipo, que incluye tanto el diseño de las placas de circuito impreso, como el estudio de los componentes utilizados para su desarrollo.

o Diseño del software que llevarán implementado los medidores de potencia.

o Diseño del hardware necesario para la interconexión y comunicación de los elementos medidores con el nodo maestro.

o Diseño de un sistema de supervisión y control que actúe como nodo maestro en un ejemplo de instalación tal que permita demostrar el correcto funcionamiento del sistema.




No es objeto de este proyecto la determinación de los algoritmos necesarios para que en nodo maestro haga un control eficiente de las cargas que se están controlando, ya que esto requeriría de un estudio pormenorizado de la tarifa contratada, tipo de vivienda, grado de electrificación, etc…, datos que pertenecen al ámbito de aplicación de una instalación concreta.

El presente proyecto pretende ser más general, desarrollando las herramientas y el hardware que permita realizar dicha adaptación final de una manera rápida a partir de una modificación del sistema de ejemplo que se desarrollará en la presente documentación.

Tampoco es objeto de este proyecto el estudio de los requisitos necesarios para que este prototipo cumpla con las condiciones exigidas por los organismos oficiales pertinentes para comercializar un producto (condiciones de seguridad, encapsulado del PCB, compatibilidad EMI, etc), puesto que lo que el objetivo del proyecto es el diseño del prototipo, no el diseño de producto comercial final.

Puesto que en la actualidad se pretende desarrollar también una serie de tarjetas microcontroladas multipropósito para usarlas de base para futuros proyectos, se tratará en la medida de lo posible, de desarrollar también las bases necesarias para el diseño de dichas tarjetas, a partir de algunos de los prototipos diseñados.

4 ANTECEDENTES.

La domótica es una disciplina actualmente en auge y que está experimentando un desarrollo importante, especialmente para el control de viviendas para personas con un nivel adquisitivo elevado y para la mejora del control energético en bloques de oficina, siendo esto lo que se suele denominar inmótica.

Por otro lado, las compañías de semiconductores están desarrollando a día de hoy drivers y microcontroladores de dimensiones muy reducidas a coste razonable, lo que permite diseñar dispositivos de tamaño reducido, como el que se pretende desarrollar en el proyecto.

Un ejemplo de esto es el kit ZigBee desarrollado por Texas Instruments1 que se va a utilizar como punto de partida para el desarrollo del presente proyecto, que pese a integrar un microcontrolador, toda la electrónica necesaria para su funcionamiento, un módulo de comunicaciones inalámbricas ZigBee, un interfaz USB a serie y el programador de dicho microcontrolador, su tamaño es similar a un usb stick genérico.

1 http://focus.ti.com/docs/toolsw/folders/print/ez430-rf2480.html




Este kit, que posee un precio asequible, se suministra con un software de prueba ya previamente cargado en los dispositivos, así como una aplicación de PC que permite probar el correcto funcionamiento de éste.

Por otro lado el fabricante de dicho dispositivo permite la descarga gratuita de su página web2, de un compilador de C limitado en cuanto a extensión máxima del tamaño del programa. Además también ofrece una gran cantidad de notas de aplicación donde se describen diseños tanto software como hardware realizados con dicha familia de microcontroladores, siendo estas notas de aplicación las que se van a utilizar como base para el presente proyecto.

5 VIABILIDAD TECNOLÓGICA DEL PROYECTO.

A nivel de desarrollo y prototipado industrial no se han encontrado impedimentos tecnológicos que no permitan la realización del presente proyecto. Esto es en gran medida debido al gran avance de la electrónica la cual ha desarrollado microprocesadores/microcontroladores con gran potencia de cálculo que nos permiten realizar un gran número de operaciones complejas en un tiempo muy breve.

Por otro lado, a nivel de prototipado en el laboratorio sí se ha encontrado un obstáculo importante, originado por la tendencia actual de los fabricantes, los cuales están optando por el diseño de los circuitos integrados en encapsulados BGA y similares (como ocurre con los transceivers de comunicaciones inalámbricos).

Estos encapsulados presentan la ventaja de su reducido coste y dimensiones, pero impiden el desarrollo de prototipos, a no ser que se disponga de herramientas de soldadura y posicionado automático de componentes.

El no disponer de dichas herramientas ha condicionado el desarrollo del presente proyecto, lo que ha exigido desechar algunas tecnologías por otras debido a la imposibilidad de montar un prototipo “funcional” con los medios de los que se disponían.

2 Se puede obtener en: http://focus.ti.com/docs/toolsw/folders/print/iar-kickstart.html




6 ANÁLISIS DE LA SITUACIÓN ACTUAL.

Como se ha comentado anteriormente, el proyecto se basa en el desarrollo de los dispositivos y de una aplicación básica de supervisión y control que pueda servir como base para futuros desarrollos.

Para el diseño de dicha aplicación de supervisión y control de ejemplo se va a suponer que los dispositivos a desarrollar se van a instalar en una vivienda unifamiliar con el siguiente aspecto:

A)

B)

C)

D)

Figura 1: Casa a automatizar. A)Vista General. B)Planta baja. C)Planta primera. D)Ático.

Dicha vivienda posee tres plantas, considerándose que se va a realizar la instalación de los dispositivos medidores de energía en todos los enchufes de la vivienda, exceptuando la toma de potencia del horno de la cocina y climatización.

Con el fin de dejar el ejemplo lo más genérico posible no se va a utilizar un PLC como nodo central (aunque el hardware desarrollado también será compatible con esta




opción), sino que se va a utilizar directamente un PC con un software de SCADA genérico, con el fin de poder demostrar el correcto funcionamiento de las tarjetas de interconexión desarrolladas.

La ventaja clara, si se hubiera optado por la utilización de un PLC, es que estos suelen integrar puertos de comunicación, o en su defecto módulos de expansión que integran dichos puertos y permiten comunicación directa con diversos buses de campo.

Así y todo también se desarrollará una serie de tarjetas de interconexión de bajo costo para la comunicación con un PC o PLC, puesto que los módulos de interconexión comerciales suelen ser de un coste elevado.

7 ANÁLISIS DE LAS DISTINTAS SOLUCIONES HARDWARE.

A la hora de abordar el diseño hardware de este dispositivo se plantean diversas soluciones, cada una de las cuales con sus ventajas e inconvenientes desde el punto de vista económico, de rendimiento y de tamaño, pero siempre válidas desde el punto de vista funcional.

Debido a la complejidad del proyecto, este se ha dividido este en seis bloques independientes, pero interconectados entre si, tal y como se puede apreciar en la siguiente figura:

Red electrica 230Va.c. 50/60Hz

Carga

Bloque 5:Control sobre

la carga.

Bloque 3:Adquisición y

procesador de la información (µC).

Bloque 4:Comunicaciones.

Bloque 1:Transductores

de las medidas.

Bloque 6:Fuentes de

alimentación

Bloque 2:Acondicionamiento

de las señales.

Figura 2: Diagrama de bloques del hardware del proyecto.




Para cada uno de estos bloques se ha estudiado distintas alternativas para su implementación, obteniéndose una serie de conclusiones, las cuales han decantado la balanza a favor de uno de ellos para incluirlo en el diseño final.

7.1 Bloque 1: Transductores de las medidas.

Los transductores de un circuito de medida, son los dispositivos electrónicos encargados de traducir las magnitudes físicas a magnitudes eléctricas, las cuales serán posteriormente tratadas por el circuito de acondicionamiento de señal.

Si lo que se pretende medir en este proyecto es consumo energético, se hacen necesarios dos transductores, los cuales permitan medir la corriente que circula por la carga y la tensión aplicada sobre ella.

7.1.1 Medida de corriente.

Dependiendo de la aplicación del transductor, normalmente es muy recomendable aislar galvánicamente el circuito de medida del circuito de adquisición. Las ventajas e inconvenientes de las distintas posibilidades de transductores, se resumen la siguiente tabla:

Ventajas Inconvenientes

Sensor de Efecto HALL

• Añade aislamiento galvánico • Permite la medidas continuas

• Precio media-alto • Tamaño medio

Transformador de corriente • Añade aislamiento galvánico

• Precio alto • Tamaño grande • No permite la medidas continuas

Resistencia Shunt

• Precio bajo • Tamaño reducido • Permite la medidas continuas

• No añade aislamiento galvánico • Perdidas energéticas 2·I R

Tabla 1: Comparativa entre transductores de corriente.

7.1.1.1 Transductor de medida de corriente con aislamiento.

La ventaja de utilizar un transductor aislado, es que dota de aislamiento galvánico al sistema de mediada, lo cual permite que este circuito no tenga que tener la misma referencia que el circuito a medir. Esto en ocasiones es obligatorio por motivos de seguridad.




Para esta aplicación se puede utilizar dos tipos:

A B

Figura 3: Transductores de medida aislada de corriente. A: Transformador de corriente. B: Sensor

de efecto hall.

7.1.1.2 Transductor de medida de corriente sin aislamiento.

Como se ha expresado en la tabla, el uso de una resistencia shunt es la solución más económica y menos voluminosa. En contrapartida no se tiene aislamiento y se disipa potencia.

A) B)

Figura 4: Transductores de medida no aislada de corriente. A)Resistencia tipo through hole. B)Resistencia tipo SMD.

El circuito para esta configuración es el siguiente:

≡

Circuito de medida Equivalente Thevenin

Figura 5: Circuito de medida no aislada de corriente.




7.1.2 Medida de tensión.

Al igual que ocurría con el circuito de corriente, en este circuito, también podemos optar por el aislamiento de la medida.


Transformador • Añade aislamiento galvánico • Precio alto • Tamaño grande • No permite la medidas continuas

Divisor de Tensión Resistivo

• Precio bajo • Tamaño reducido • Permite la medidas continuas

• No añade aislamiento galvánico

• Perdidas energéticas ( )2 /V R

Tabla 2: Comparativa entre transductores de tensión.

7.1.2.1 Transductor de medida de tensión con aislamiento.

Si se opta por la medida aislada en la corriente, es obligatorio aislar también en la medida de tensión, para que el aislamiento se siga manteniendo. Para esta aplicación se propone la utilización de un transformador:

Figura 6: Transductor de medida aislada de tensión.

7.1.2.2 Transductor de medida de tensión sin aislamiento.

Como se ha expresado en la tabla, el uso de un divisor de tensión resistivo es la solución más económica y menos voluminosa. En contrapartida no se tiene aislamiento y se disipa potencia.

El circuito para esta configuración es el siguiente:

≡

Circuito de medida Equivalente Thevenin

Figura 7: Circuito de medida no aislada de tensión.




7.1.3 Conclusiones obtenidas referentes a la elección de los transductores de las

medidas del dispositivo.

Como conclusión referente a este bloque del proyecto, se puede extraer que lo ideal sería utilizar los transductores aislados. No obstante el problema que presentan estos transductores es su elevado precio, y en especial su elevado volumen, el cual lo hace inviable para este diseño.

Esta restricción espacial, junto con su reducido coste y teniendo en cuenta que para este diseño no es obligatorio el aislamiento por motivos de seguridad (al no existir contacto directo con el usuario), hacen que para el diseño final se opte por la utilización de los transductores sin aislamiento.

7.2 Bloque 2: Acondicionamiento de las señales.

Este bloque es el encargado de adaptar los rangos y características de las señales extraídas por los transductores, acondicionándolas a las especificadas por el CAD. Esta dependencia directa de los dos circuitos contiguos hace que su topología pueda variar radicalmente, en especial con las características del CAD.

7.2.1 Acondicionamiento de señal sin desplazamiento de nivel.

Este circuito está compuesto por la configuración más básica de amplificador, el inversor. Este circuito nos permite adaptar las amplitudes de las señales (escala) a las exigidas por el CAD.

Esta configuración presenta el siguiente esquema:

Respuesta del circuito:

2

1

·O I

RV V

R

−=

Impedancia de entrada:

1iX R=

Figura 8: Circuito de acondicionamiento de la señal sin desplazamiento de nivel.





• Número muy bajo de componentes

• Requiere alimentación simétrica • Impedancia de entrada del circuito

determinada por R1 • Medida no diferencial

Tabla 3: Características del circuito.

El problema de la inversión de la señal, no es importante, pues al conocerse esta característica, solo sería necesario multiplicar todos los valores muestreados por menos uno.

7.2.2 Acondicionamiento de la señal con desplazamiento de nivel.

Un problema a tener en cuenta, es que en la mayoría de los CAD presentes en los µC no permiten una entrada de tensión negativa. Esto implica que además de escalado de la señal de salida, se requiere un desplazamiento de nivel, que se consigue sumándole un nivel de continua (VREF/2 para centrar la señal en el rango del CAD).

Una implementación de este circuito sería la siguiente, que se corresponde con un circuito muy utilizado en amplificadores de audio:


11

·1 2

2· · ·

F REFO I

R VV V

R jf Cπ

−= +−

Impedancia de entrada:

11

1

2· · ·iX R jf Cπ

= −

Figura 9: Circuito de acondicionamiento de la señal con desplazamiento de nivel.


• No requiere alimentación simétrica

• Número muy bajo de componentes

• Impedancia de entrada del circuito determinada por R1

• No permite medidas de señales continuas, pues elimina dicha componente

• Medida no diferencial





En este circuito se comprobó experimentalmente que su funcionamiento se corresponde con el modelo teórico desarrollado en la memoria de cálculo.

Uno de los problemas más importantes que presenta este circuito, es la eliminación de las componentes de continua en las medidas. Esta característica del circuito impediría detectar este fenómeno, provocado por algunos tipos de cargas (ej: rectificadores de media onda).

Otro problema adicional, es que para obtener el comportamiento frecuencia deseado en esta aplicación, los componentes necesarios presentan un tamaño muy elevado. Además este circuito introduce un desfase en las medidas, esto no es ningún problema si se fuerza a que el desfase sea el mismo para las dos medidas.

7.2.3 Acondicionamiento de la señal con desplazamiento de nivel, filtro paso bajo y

medida diferencial.

Con el circuito del apartado anterior, garantizamos el carácter positivo de la señal de entrada del CAD. No obstante existe otro problema asociado a la digitalización de señales, denominado “aliasing”. Este problema consiste en la medida de señales inexistentes, cuando se muestrean señales de un frecuencia superior a la de captura. Para evitar este fenómeno indeseable, basta con filtrar dichas componentes de alta frecuencia antes de la captura.

El circuito que se muestra en este apartado, no solo incluye dicho filtro paso de bajo, sino que además permite desplazar el nivel de la señal y realizar medidas diferenciales.

Una implementación de este circuito, sería la siguiente:


( ) ( )22 1

1

/ /·

2C REF

O

R X VV V V

R= − +

Figura 10: Circuito de acondicionamiento de la señal con desplazamiento de nivel, filtro paso bajo

incorporado y medida diferencial.





• No requiere alimentación simétrica • Número muy bajo de componentes • Medidas diferencial

• Impedancia de entrada del circuito determinada por R1


De este circuito se ha realizado un prototipo3, en el que se ha verificado experimentalmente su comportamiento, siendo estos satisfactorio y acordes con los calculados teóricamente la memoria de cálculo.

En este prototipo se han incluido los dos circuitos de acondicionamiento de señal (V e I). También se ha añadido los transductores de media con valores adaptados para obtener los mismos resultados con señales de entrada más pequeñas.

Figura 11: Prototipo Acondicionamiento de Señal.

7.2.4 Acondicionamiento de la señal para CAD bipolar, diferencial y con filtro

incorporado en el µC.

Como se verá posteriormente en el apartado 7.3.3, existen algunos CAD que ya integran la electrónica necesaria para realizar dicho acondicionamiento de la señal. Esto permite minimizar considerablemente dicho circuito externo, quedando únicamente reducido a un filtro paso bajo RC, que recomienda el fabricante para minimizar el efecto de “aliasing”.

1

2· · ·cf C Rπ=

Figura 12: Filtro paso bajo RC.

3 Placa Nº3: Prototipo Acondicionamiento de Señal.




7.2.5 Conclusiones obtenidas referentes a la elección del circuito de

acondicionamiento de señal.

A pesar de la versatilidad de los circuitos estudiados en este bloque, los cuales nos permitirían utilizar cualquier tipo de CAD, finalmente se ha optado por la última de las alternativas mencionadas.

Principalmente se han tenido en cuenta las restricciones espaciales del diseño, no obstante, hay que destacar que esta elección no encarece excesivamente el precio del µC.

7.3 Bloque 3: Adquisición y procesado de la información (µC).

Existen multitud de microcontroladores diferentes en el mercado a precios muy variados, que van desde los microcontroladores simples de 8 bits (como las familias de los 8051) hasta microcontroladores avanzados de 32bits, tales como los que poseen un núcleo ARM.

Para esta aplicación particular es necesario el empleo de un procesador de prestaciones medias, pero que posea un precio económico tanto en las herramientas software como en el costo del mismo dispositivo, que permita diseñar un producto final cuyo costo sea asequible, tal que sea viable la integración de un dispositivo final por enchufe en una instalación.

Asimismo también es recomendable que el microcontrolador a elegir tenga unas dimensiones reducidas junto con un bajo consumo, puesto que ambas características influyen en tamaño del dispositivo final, que tal y como se ha comentado debe ser lo suficientemente pequeño como para integrarlo en un enchufe.

La familia de microcontroladores que se ha encontrado que mejor cumplen con todas esas características son los MSP430, producidos por Texas Instruments.

Figura 13: Familia MSP430 de Texas Instruments.




Están construidos con una CPU RISK de 16 bits muy eficiente (casi todas las instrucciones se ejecutan en 1 ciclo de instrucción), con arquitectura de Von Neumann y está diseñado especialmente para aplicaciones empotradas de bajo costo y bajo consumo de energía.

El MSP430 es muy útil para aplicaciones inalámbricas o para aplicaciones de bajo consumo, siendo incluso posible realizar con ellos aplicaciones de procesado digital de datos si la frecuencia de la señal no es muy elevada debido a los periféricos que puede integrar, tales como CAD y CDA, multiplicador (de 16 o 32 bits, según el modelo) e incluso el controlador de DMA de múltiples canales (hasta 3).

El número de periféricos integrados depende de la familia y el modelo concreto, pero suele ser habitual en todos ellos que posean oscilador interno, timer incluyendo control PWM directo de las salidas, watchdog, USART, SPI, I2C, 10/12/14/16-bit CADs y circuito brownout reset.

Algunos periféricos opcionales no tan usuales incluyen comparadores, amplificadores operacionales dentro del chip para el acondicionamiento de señales, CDA de 12 bits, controlador de LCD, etc.

La familia actual completa poseen memoria flash programable tanto externamente a través de JTAG o a través del bootstrap loader (BSL) como internamente desde el propio microcontrolador.

Como se ha comentado, la programación de estos dispositivo se hace por carga serie o, lo que resulta más cómodo para la depuración, mediante un interfaz JTAG propio y económico de 16 vías (el programador USB tiene un coste de unos 100€).

Algunos modelos de encapsulados con pocas E/S en vez del JTAG emplean un puerto de programación/depuración propietario denominado Spy-Bi-Wire, que es capaz de programar y depurar el código empleando tan solo 4 pines.

Como se ha comentado, dentro de la familia de los MSP430 existen varias subfamilias. A continuación se van a estudiar cada una de ellas por separado resaltando sus mejores y peores características de cara a la presente aplicación.

7.3.1 Utilización de un µC simple (MSP430F1xxx).

La familia 1 hace referencia a la familia de CPU de propósito general y coste reducido.

Suelen tener un encapsulado menor al de la familia 4, con 64 pines en formato LQFP y velocidad máximas de reloj de 8MHz.




De forma resumida, las ventajas en inconvenientes de esta familia son:


• Encapsulado relativamente pequeño.

• Micros de precio económico.

• CAD no bipolar que requiere de circuito de adaptación.

• Solo poseen un CAD (con varias entradas).

Tabla 6: Características de la familia MSP430F1xxx.

Como se ha comentado esta familia integra un solo CAD de 12bits, unipolar, de aproximaciones y con varios canales.

Este único conversor impide que se pueda realizar la captura de la tensión y corriente de forma simultánea, lo que origina un desfase entre estas medidas que ocasiona un error de cara a una media energética.

Además de esto, este CAD presenta la desventaja de ser unipolar y no flotante, debido a lo que requiere un circuito previo que introduzca un desplazamiento de la señal (además también es necesario un filtro para evitar el aliasing). Un circuito de acondicionamiento válido sería como el descrito en el apartado 7.2.3.

Una ventaja que presenta esta familia es que integra un multiplicador hardware de 16 bits, el cual acelera significativamente los cálculos realizados por el mismo.

7.3.2 Utilización de un µC simple (MSP430F2xxx).

La familia 2 es una nueva generación derivada de la familia 1 y que presenta un consumo aún menor, junto con velocidades de reloj más elevadas de hasta 16MHz.

Esta familia está diseñada especialmente para dispositivos portátiles, presentándose algunos modelos en encapsulados muy pequeños, lo que junto al hecho de programarse por Spy-Bi-Wire y de no necesitar de un reloj interno (vienen con un DCO interno calibrado de alta precisión capaz de generar un reloj de hasta 16MHz) origina que con él se puedan diseñar productos muy compactos, eso sí, acosta de tener pocos pines de E/S.

Al igual que la familia 1, esta familia tampoco integra controlador de LCD.




Para esta aplicación, sus principales ventajas e inconvenientes son:


• Encapsulado muy pequeño. • Requiere de muy pocos

componentes externos para funcionar.

• Precio muy económico (tanto micro como programador)

• Solo poseen un CAD (con varias entradas).

• El que posee un CAD de 16 bits no posee UART, necesaria para comunicaciones Modbus.


De cara al conversor CAD, en esta familia está presente el CAD16 sigma-delta, que permite entrada diferencial, no requiriendo, por tanto circuito de adaptación.

Además integra operacionales con los que se puede ajustar la ganancia de los canales de entrada, reduciendo aún más el tamaño del circuito final.

Al igual que pasaba con la familia 1, esta integra un multiplicador hardware de 16 bits, el cual acelera significativamente los cálculos realizados por el mismo.

En cuanto a sus inconvenientes más importantes, está el que solo posea un CAD, lo que exige una calibración en la medida de potencia para compensar el desfase entre la V y la I medida, junto con el hecho de que el micro de esta familia que integra el CAD sigma-delata de 16 bits, no posee UART de comunicaciones, por lo que queda rechazada al no permitir las comunicaciones Modbus.

7.3.3 Utilización de un µC complejo (MSP430F4xxx).

Esta familia está diseñada específicamente para la realización de aparatos de medidas portátiles, tales como vatímetros, presentando una frecuencia máxima de 16MHz mediante el empleo de un FLL y poseen controlador de LCD integrado.

Algunos modelos (como los F471xx) poseen una CPU nueva denominada MSP430X, que expande el bus de direcciones hasta 20 bits, lo que incrementa notablemente el espacio de direccionamiento.

Más concretamente, la familia F471xx está pensada específicamente para el diseño de medidores de potencia portátiles, por lo que resultan idóneos para esta aplicación.




Sus ventajas e inconvenientes más importantes son:


• Posee varios CAD que se pueden lanzar simultáneamente

• El CAD soporta señales bipolares. • Posee hasta un total de 4 puertos de

comunicaciones serie (según modelo).

• Encapsulado grande, debido fundamentalmente al controlador de LCD, que no se va a usar para esta aplicación.

• Ligeramente más caros que los de la familia 2 y 1.


Estos microcontroladores integran varios CAD sigma-delta de 16 bits bidireccionales, lo que le permiten la medida simultánea de la tensión y la corriente sin la necesidad de ningún circuito de adaptación ni calibración para compensar el desfase de medidas.

Además integran una etapa de amplificación analógica regulable con la que se puede ajustar la ganancia sin necesitar circuito externo.

La única pega importante a destacar es que este microcontrolador es el controlador de LCD, que ocasiona que el encapsulado del microcontrolador sea grande (LQFP de 100 pines).

Esta familia integra un multiplicador hardware de 16 / 32 bits.

7.3.4 Conclusiones obtenidas referentes a la elección del circuito de adquisición y

procesador de la información.

A la vista de esto, el microcontrolador escogido es de la familia 4, más concretamente el MSP40F47166, con una CPU con un espacio de direcciones de 20 bits.

La elección de éste frente a las otras familias está basada en el hecho de que aunque el encapsulado es mayor, el diseño final queda más reducido que con las otras familias, puesto que el circuito de acondicionamiento de señal que requiere es muy simple (ver apartado 7.2.4).

La elección de éste modelo en concreto frente a otros de la misma familia se bebe a razones de costo, es decir, es el microcontrolador más barato de la familia que integra más de 2 CAD bipolares de 16 bits (más concretamente integra 6).




7.4 Bloque 4: Comunicaciones.

En este apartado se van a desarrollar los distintos adaptadores necesarios para la comunicación del dispositivo con su entorno.

En los próximos apartados se van a clasificar en función de la capa 1 del modelo OSI, es decir, a partir de su capa física, separando también las comunicaciones por cable de las inalámbricas, al ser estos medios físicos distintos.

Figura 14: Modelo OSI.

7.4.1 Comunicaciones cableadas.

Las comunicaciones cableadas son aquellas que para poder enviar los mensajes entre los dispositivos requieren del empleo de 2 o más conductores conectando todos los nodos.

Las principales ventajas e inconvenientes de este tipo de comunicación son las siguientes:


• Comunicación más sencilla que la inalámbrica

• Requiere menos energía para transmitir los mensajes

• El costo del cableado encarece la instalación

• No siempre es posible añadir más conductores a las canalizaciones existentes

Tabla 9: Características de las comunicaciones cableadas.




En los próximos apartados se van a atender varios tipos de comunicación estándar, clasificados en función de su capa física de interconexión.

7.4.1.1 Comunicaciones RS232.

Este tipo de comunicaciones es un interfaz que define una norma para las comunicaciones entre dos elementos, un maestro (DTE) y una unidad esclava (DCE). Requiere del empleo 3 conductores para establecer las comunicaciones, TX, RX y GND, además en la norma se definen otros conductores adicionales relacionados con la sincronización de mensajes entre los elementos, así como algunos conductores adicionales de alimentación (hasta llegar a los 9 ó 25 conductores que define la norma), si bien en su forma más simple estos cables adicionales no son necesarios.

Figura 15: Conectores estándar RS-232C.

En este protocolo se utilizan tensiones entre +15 y -15V, correspondiendo la tensión positiva al nivel lógico 0 y el -15 al 1.

Es un tipo de comunicaciones muy extendido que está presente en muchos PLC y en PC domésticos e industriales.

Sus principales ventajas e inconvenientes se resumen en la siguiente tabla:


• Full duplex. • Económico. • Presente en muchos PC y

autómatas.

• No diferencial. • Longitud máxima del cable, 15m. • Comunicación solo entre 2 nodos, un

maestro y un esclavo.

Tabla 10: Características de las comunicaciones RS-232.




Tal y como se comenta en la tabla anterior este sistema tiene un problema, que resulta insalvable. Únicamente se permite 2 nodos de comunicación, motivo por el cual esta comunicación queda totalmente descartada para la presente aplicación.

Un implementación de este conversor, sería el uso del MAX3222, tal y como se muestra en el plano 5.x.

Para verificar su funcionamiento, se montó un prototipo4, el cual presenta el siguiente aspecto:

Figura 16: Interfaz Rs232toRs232C.

Teniendo en cuenta la limitación antes comentada, este prototipo solo permitiría comunicar con un único vatímetro.

7.4.1.2 Comunicaciones RS485.

Las comunicaciones 485 son un variación de las 232, que añaden una transmisión y recepción de datos diferencial, lo que las hace mucho más inmunes al ruido. Sus principales ventajas e inconvenientes son las siguientes:


• Económico • Presente en muchos autómatas. • Bus diferencial • Longitud máxima del cable

superior a 1000m

• No está presente en los PC, requiere el empleo de un adaptador

• Para una comunicación full duplex, es necesario 4 hilos

Tabla 11: Características de las comunicaciones RS-485.

Este bus sí permite la conexión de múltiples elementos, siempre y cuando se tenga la precaución de que solo uno esté transmitiendo, mientras todos los demás deben

4 Placa Nº5: Interfaz Rs232toRs232C.




permanecer en modo de escucha (esta funcionalidad tiene que estar implementada en el protocolo de transmisión específico que se use).

Dos posibles implementaciones de este interfaz serían los detallados en los planos 6.x5 y 7.x6, implementando uno de ellos una versión no aislada, mientras que el otro prototipo sí integra esta característica.

Para verificar su funcionamiento, se montaron estos prototipos, los cuales presentan el siguiente aspecto:

Tarjeta NO aislada Tarjeta aislada

Figura 17: Prototipos de los circuitos.

Basado en este método de comunicación existen muchos protocolos en la industria. De éstos se han estudiado dos de los más representativos a día de hoy los cuales se van a detallar a continuación.

7.4.1.2.1 Comunicaciones Modbus.

Modbus es un protocolo que cumple con el nivel 7 del Modelo OSI, diseñado en 1979 por Modicon (Telemecanique) para la interconexión de sus autómatas.

Actualmente en la industria se ha convertido en un protocolo de comunicaciones estándar para el que existen multitud de dispositivos diseñados para comunicarse mediante este bus, ya sean PLC, variadores de velocidad, etc.

5 Placa Nº6: Interfaz Rs232toRs485

6 Placa Nº7: Interfaz Rs232toRs485 (Aislado)




A continuación se resumen sus principales ventajas e inconvenientes:


• Es un estándar público que no exige el pago de royalties

• Su implementación es fácil • No impone demasiadas

restricciones en el manejo de los datos

• Basado en la jerarquía maestro-esclavo, por lo que no permite comunicaciones no solicitadas previamente (como podría ser una alarma)

• En el estándar solo se definen 254 nodos como máximo

Tabla 12: Características de las comunicaciones Modbus.

Existen tres variantes, con diferentes representaciones numéricas de los datos y detalles del protocolo ligeramente desiguales. Modbus RTU es una representación binaria compacta de los datos. Modbus ASCII es una representación legible del protocolo pero menos eficiente. Modbus/TCP es muy semejante al formato RTU, pero estableciendo la transmisión mediante paquetes TCP/IP.

Esta documentación se centra en Modbus RTU, puesto que es la más extendida. Este formato finaliza la trama con una suma de control de redundancia cíclica (CRC) con el fin de asegurar la integridad de los datos.

Cada dispositivo de la red Modbus posee una dirección única. Cualquier dispositivo puede enviar órdenes Modbus, aunque lo habitual es permitirlo sólo a un dispositivo maestro. Cada comando Modbus contiene la dirección del dispositivo destinatario de la orden. Todos los dispositivos reciben la trama pero sólo el destinatario la ejecuta (salvo un modo especial denominado "Broadcast", que se corresponde con la dirección 0). Los comandos básicos Modbus permiten controlar un dispositivo para modificar el valor de alguno de sus registros o bien solicitar el contenido de dichos registros.

7.4.1.2.2 Comunicaciones Profibus.

Profibus es un estándar de comunicaciones para bus de campo. Deriva de las palabras PROcess FIeld BUS.

Fue un proyecto desarrollado entre los años 1987-1990 por las empresas alemanas Bosch, Klöckner Möller y Siemens, y por otras como ABB, AEG, Honeywell, Landis & Gyr, Phoenix Contact, Rheinmetall, RMP, Sauter-cumulus y Schleicher. En 1989 la norma alemana DIN19245 adoptó el estándar Profibus, partes 1 y 2 (la parte 3, Profibus-DP no fue definida hasta 1993). Profibus fue confirmada como norma europea en 1996 como EN50170.




Sus principales ventajas e inconvenientes se resumen en la siguiente tabla:


• Es un estándar definido en normas internacionales (IEC61158 e IEC61784).

• Soporta conexiones con múltiples maestros.

• Su implementación es más compleja que en el caso de Modbus.

• En el estándar solo se definen 32 nodos como máximo si no se usan repetidores.

Tabla 13: Características de las comunicaciones Profibus.

Las comunicaciones con este protocolo son, en su forma más simple, con una jerarquía maestro-esclavo, aunque el protocolo en sí también permite que existan múltiples maestros y una comunicación por pasos de mensajes no solicitados,

En su variante RS-485 Utiliza un par de cobre trenzado apantallado, y permite velocidades entre 9,6 kbps y 12 Mbps. Hasta 32 estaciones, o más si se utilizan repetidores.

7.4.1.3 Comunicaciones EIB/KNX.

El protocolo estándar KNX es un desarrollo europeo en el que participan más de 100 fabricantes a nivel mundial y es un estándar específico para instalaciones domóticas desarrollado a partir de otros protocolos que llevan más de 15 años desarrollándose, como el EIB, batibus y EHS.

Las características más importantes de esta plataforma son:


• Es un estándar definido en normas europeas e internacionales, que puede desarrollar cualquier fabricante.

• Protocolo CSMA/CA que evita las colisiones y permite conectar más de 1000 dispositivos.

• Tramas relativamente sencillas de implementar.

• La velocidad es de solo 9600bps. • Las herramientas de programación la

desarrolla la asociación y resultan caras. • Para desarrollar productos certificados

KNX hay que ser un miembro de la asociación Konnex, lo que implica un pago anual elevado a dicha asociación.

Tabla 14: Características de las comunicaciones EIB/KNX.

El protocolo de comunicaciones que utiliza se basa en la transmisión de tramas con un protocolo basado en la pila OSI, siendo dichas tramas independientes del medio, que existen interfaces infrarrojos, por par trenzado, por las líneas de alimentación, etc




El medio físico más común es el empleo de un par trenzado, que permite velocidades de 9600bps y conexión de más de 1000 dispositivos.

Este protocolo es descentralizado, es decir, a diferencia de Modbus no hay definido un nodo central que actúa de maestro.

Aunque el protocolo de comunicaciones es un estándar abierto, para poder certificar una aplicación como compatible KNX es necesario ser miembro de la asociación Konnex (lo que implica un desembolso económico relativamente importante). Debido a esto se ha decidido desechar este protocolo para esta aplicación particular del proyecto.

7.4.1.4 Comunicaciones LonWorks.

LonWorks es una plataforma de control creada por la compañía norteamericana Echelon. Las características más importantes de esta plataforma son:


• Es un estándar definido en normas internacionales.

• Soporta conexiones con múltiples maestros, conexiones punto a punto, mensajes de difusión, transmisión de alarmas, detección de colisiones, etc…

• Su implementación es más compleja que en el caso de Modbus.

• El empleo del procesador de comunicaciones neuron chip encarece excesivamente el coste.

• Las herramientas de programación de una red LonWorks presentan un coste muy elevado.

Tabla 15: Características de las comunicaciones LonWorks.

El protocolo de comunicaciones que utiliza se denomina LonTalk, es un estándar abierto e implementa siete capas del modelo OSI.

Este protocolo incluye interesantes características como gestión acceso al medio, reconocimiento y gestión punto a punto, y servicios más avanzados tales como autentificación de remitente, detección de mensajes duplicados, colisión, reintentos automáticos, soporte de cliente-servidor, transmisión de tramas no estándar, normalización y identificación de tipo de dato, difusión unicast/multicast, soporte de medios mixtos y detección de errores.

Existen varias capas físicas posibles paras las comunicaciones con este protocolo, que van desde inalámbricas a cableadas por cables dedicados e incluso transmitiendo la información a través de las líneas de alimentación. Así y todo, el más extendido consiste en un cableado dedicado de 4 hilos, donde se usan dos hilos para la




alimentación de los dispositivos y el otro par trenzado para establecer el bus de comunicaciones diferencial.

Como se ha comprobado anteriormente, este protocolo presenta buenas características de cara a la aplicación que se pretende desarrollar en este proyecto, pero tal y como se ha comentado presenta un problema consistente el muy elevado costo que implica el desarrollo de este bus.

Aunque el protocolo de comunicaciones es un estándar abierto, para poder certificar una aplicación como LonWorks y poder comercializarla, necesariamente hay que usar el procesador de comunicaciones de Echelon, denominado neuron chip.

Pero no solo eso, una vez diseñado el dispositivo para poder usarlo en una red hay que dar de alta a cada uno de los dispositivos en dicha red, para lo que hay que usar también de forma casi exclusiva un software desarrollado por Echelon, por el que añaden un cose fijo, más un coste variable en función del número de dispositivos presentes en la instalación (una filosofía similar a los software de SCADA genéricos usados en aplicaciones industriales).

Todo esto ha hecho rechazar el empleo de este bus, puesto que su costo es excesivo para el desarrollo del prototipo de coste económico que se pretende realizar.

7.4.2 Comunicaciones inalámbricas.

Las comunicaciones inalámbricas son aquellas que la información se envía en forma de onda electromagnética sin necesidad de hilos conductores.

Las principales ventajas e inconvenientes de este tipo de comunicación son las siguientes:


• No requiere de cableado • Tiene un menor costo de instalación

de infraestructura

• Protocolos de comunicación más complejos que los cableados

• Requiere mucha energía para transmitir un mensaje

Tabla 16: Características de las comunicaciones inalámbricas.

En los próximos apartados se va a hacer un resumen de varias tecnologías de comunicación inalámbricas enfocadas a la domótica.

7.4.2.1 Z-wave.

Z-wave es un protocolo inalámbrico por ondas de radio destinado para la comunicación entre dispositivos domésticos eléctricos. Sirve para crear una red única




entre los equipos de iluminación, termostatos, alarmas, ordenadores, teléfonos, aire acondicionado, ventanas eléctricas y persianas.

A la red se pueden conectar todos los dispositivos eléctricos que tengan el módulo del sistema Z-wave.

A este sistema están asociados más de 200 fabricantes en todo el mundo, estando a día de hoy disponible muchos dispositivos con esta tecnología.

El protocolo Z-wave opera en la frecuencia de 868,42MHz y se caracteriza por tener un bajo consumo de energía si no hay transmisión (siendo típico un consumo de 2,5µA).

El alcance en campos abiertos es de 150 metros, en campo cerrado se reduce a 5 metros, admitiéndose una topología de red de tipo malla.

De cara a implementar esta tecnología nos encontramos con una escasa disponibilidad de transmisores que empleen esta tecnología.

Prácticamente el único que se ha encontrado con disponibilidad es el módulo ZM3102N de fabricante Sigma Designs Inc.

Características:

• 10 General Purpose I/O’s • Two Interrupt Inputs • Serial UART • SPI Interface • Triac Control Interface • PWM Output • Four multiplexed 12/8 bit • CAD inputs

Figura 18: Módulo z-wave ZM3102N.

7.4.2.2 ZigBee.

ZigBee es el nombre de la especificación de un conjunto de protocolos de alto nivel de comunicación inalámbrica para su utilización con radio digital de bajo consumo, basada en el estándar IEEE 802.15.4 de WPAN (wireless personal area network). Su objetivo son las aplicaciones que requieren comunicaciones seguras con baja tasa de envío de datos y maximización de la vida útil de sus baterías.

En principio, el ámbito donde se prevé que esta tecnología cobre más fuerza es en domótica debido a diversas características que lo diferencian de otras tecnologías:




• Su bajo consumo

• Su topología de red en malla

Figura 19: Red ZigBee con topología de malla.

• Su fácil integración (se pueden fabricar nodos con muy poca electrónica).

La especificación 1.0 de ZigBee se aprobó el 14 de diciembre de 2004 y está disponible a miembros del grupo de desarrollo (ZigBee Alliance).

ZigBee utiliza la banda ISM para usos industriales, científicos y médicos; en concreto, 868 MHz en Europa, 915 en Estados Unidos y 2,4 GHz en todo el mundo. Sin embargo, a la hora de diseñar dispositivos, las empresas optarán prácticamente siempre por la banda de 2,4 GHz, por ser libre en todo el mundo. El desarrollo de la tecnología se centra en la sencillez y el bajo coste más que otras redes inalámbricas semejantes de la familia WPAN, como por ejemplo Bluetooth. El nodo ZigBee más completo requiere en teoría cerca del 10% del hardware de un nodo Bluetooth o Wi-Fi típico; esta cifra baja al 2% para los nodos más sencillos.

En 2006 el precio de mercado de un transceptor compatible con ZigBee se acerca al dólar y el precio de un conjunto de radio, procesador y memoria ronda los tres dólares.

Existen multitud de fabricantes que distribuyen soluciones para esta tecnología. De este catálogo este apartado se va a centrar en las soluciones ofrecidas por Texas Instruments, especialmente por la alta disponibilidad existente en los productos de este fabricante, así como la gran cantidad de documentación que ofrece.




CC2530 CC2480

• Dispositivo System-on-Chip que integra tanto el transceiver ZigBee como una CPU básica

• Transceiver ZigBee de comunicación serie SPI o RS-232

Tabla 17: Algunas alternativas ZigBee de Texas Instruments.

Como se puede observar, este fabricante ofrece muchas soluciones óptimas para el desarrollo de prototipos y diseños de producción, todo ello muy documentado y por un coste reducido.

Para este proyecto, en el cual ya se contaba con el microcontrolador, se ha optado por el uso del transceiver (CC2480), el cual responde a la tarjeta especificada en el plano 2.x.

Para comprobar su funcionamiento se ha diseñado el siguiente prototipo7, el cual presenta este aspecto:

1er circuito

2º circuito

Figura 20: Prototipo del circuito.

El principal problema que presenta este dispositivo su encapsulado (48QFN), cuyos terminales se encuentran debajo del encapsulado. Esta característica ha hecho inviable su montaje con los medios disponibles, en los cuales se sobrecalentaba el dispositivo en exceso, presentando este un funcionamiento anómalo posteriormente.

7 Placa Nº2: Prototipo Interfaz ZigBee




7.4.3 Conclusiones obtenidas referentes a las comunicaciones.

En vista a lo anteriormente comentado, parece que la solución más optima, de cara a la aplicación son las comunicaciones inalámbricas por ZigBee.

Ahora bien, tal y como se ha comentado anteriormente, ha resultado imposible conseguir un prototipo funcional de dicho transceiver, debido a que su encapsulado no permite un montaje manual, resultando en todos los prototipos realizados (unos 10) que en la soldadura el componente se sobrecalentaba y no funcionaba adecuadamente (de hecho, ninguno de ellos llegó siquiera a arrancar).

Debido a esto se ha tenido que rechazar la solución ZigBee, teniéndose que usar para el desarrollo del presente proyecto la segunda mejor medida encontrada: las comunicaciones cableadas mediante bus diferencial RS-485 con protocolo Modbus.

Todos los demás protocolos de redes cableadas estudiados presentaban un coste excesivo para el prototipo que se pretende realizar.

Si bien Modbus no está excesivamente extendido pera un uso domótico, si está muy extendido en un uso industrial, por lo que es un bus muy estudiado para el que existen muchas soluciones hardware económicas ya desarrolladas (incluso presente de forma nativa en muchos PLCs), por lo que su instalación en una industria resulta sencilla, aunque en una vivienda el uso de requerir un cableado adicional pueda presentar algunos problemas.

7.5 Bloque 5: Control sobre la carga.

Tal y como se desarrolla en el apartado 1.5 de la memoria de cálculo, las características que debe cumplir el control de la carga es ser capaz de conmutar una carga de 16A a 230VAC, ocupando además el menor espacio posible.

Para resolver esto se plantean fundamentalmente dos soluciones, una basada en un control por triac y otra en relé. Ambas soluciones se van a estudiar por separado en los próximos apartados.

7.5.1 Control por relé.

El relé es un dispositivo electromecánico que fuerza el cierre o la apertura de unos contactos al excitar una bobina.




Figura 21: Ejemplo de relé electromagnético.

Las ventajas e inconvenientes principales de este dispositivo son:


• Precio reducido

• Alta fiabilidad • Consumo reducido de energía para la

excitación

• No permiten conmutaciones muy rápidas

• Están sometidos a desgaste mecánico, teniendo un número de conmutaciones máximas en su vida útil

• El consumo de energía por parte de la excitación es constante.

Tabla 18: Características del circuito de control de carga con relé.

Existen relés con bobinas de excitación tanto en alterna como en continua, pero las bobinas de continua son de un tamaño mayor, además de ser menos eficientes energéticamente.

Esto hace que para este proyecto el uso de relés a 12Vdc o 24Vdc quede rechazado, puesto que su tamaño resulta excesivo.

En el caso de los relés de 230Vac existen modelos capaces de cortar 230Vac y hasta 16A con unas dimensiones lo suficientemente reducidas como para poder emplearlos en el presente proyecto (como por ejemplo el modelo RX314730C de Tyco Electronics que se propone), pero presentan el inconveniente que no se pueden excitar directamente con la salida del microcontrolador.

Para solventar esto se propone el siguiente circuito, cuyos cálculos se desarrollan en el apartado 1.5.1 de la memoria de cálculo:




Figura 22: Esquema del circuito de control de carga con relé.

Con el fin de conseguir la mayor eficiencia energética, el opto-triac obtenido es de alta ganancia, asegurando el fabricante que con solo 5mA es capaz de dispararse. Existen algunos triac comerciales de mayor ganancia (capaces de excitar la carga con 3mA) pero al ser componentes de aplicación específica su precio es más elevado, lo que junto a su limitada disponibilidad ha hecho que se rechacen para la presente aplicación.

De cara a controlar la carga se ha optado por usar el contacto normalmente cerrado del relé, de manera que durante el uso normal no consume energía la bobina, solo consumiendo durante el tiempo que el circuito de control decida cortar la carga, lo que resulta más eficiente.

(Relé en reposo)

(Relé excitado)

Figura 23: Comportamiento del relé en reposo y excitado.

Debido al limitado número de conmutaciones que puede hacer el relé por unidad de tiempo, este tipo de actuación solamente es válida para control todo-nada, es decir, no se puede hacer con él regulación de potencia.

7.5.2 Control por triac.

El relé es un dispositivo electrónico que se suele emplear como interruptor, ya que al provocar un determinado pulso en su terminar de control (Gate) hace que se comporte en sus terminales de actuación como un cortocircuito, pudiendo además soportar tanto tensiones positivas como negativas.




A) B)

Figura 24: A) Símbolo del triac. B) Curva característica de un triac.

Sus características fundamentales se resumen en la siguiente tabla:


• No tienen desgaste mecánico. • Alta fiabilidad • Presenta unas pérdidas reducidas • Las pérdidas que introducen dependen

de la carga que controlan • Con el circuito de control adecuado, se

pueden usar en regulación de la carga

• Necesitan incorporarle un disipador para poder manejar corrientes elevadas

• Aunque el tamaño del componente es muy reducido, el conjunto triac + disipador es voluminoso

Tabla 19: Características del circuito de control de carga con triac.

Tal y como se detalla en el apartado 1.5.2 de la memoria de cálculo, este dispositivo presenta unas pérdidas en conducción de aproximadamente el 1% de la potencia a controlar, lo que hace que en caso de que la potencia sean pequeñas pueda resultar muy eficientes, a diferencia del relé que cuando se excita su bobina su consumo es constante e independiente de la carga que se esté controlando.

Su principal inconveniente se expone en el apartado 1.5.2.1.1 de la memoria de cálculo y consiste en que presenta una caída de tensión en conducción de 2V aproximadamente, lo que al pasar 16A obliga a usar un disipador. El tamaño del conjunto triac+disipador resulta excesivo para poderlo integrar el diseño dentro de un enchufe.




La única solución para evitar esto es reducir considerablemente la corriente máxima de salida a un valor tal que el triac no necesite disipador o éste sea uno de dimensiones muy reducidas.

Al igual que para el relé el triac necesita un driver para poder excitarse a partir de la salida que da el microcontrolador.

Como circuito de control se propone el mismo desarrollado para el relé:

Figura 25: Esquema del circuito de control de carga con triac.

El opto-triac usado dispone de un control por cruce por cero, lo que reduce la derivada de tensión que se produce en el momento de entrar a conducir el triac, permitiendo un funcionamiento seguro de éste sin necesidad de usar redes snubber.

Debido al circuito detector de cruce por cero, es imposible emplear este circuito de control para hacer una regulación de potencia, solo permite actuación todo-nada.

7.5.3 Conclusiones obtenidas referentes al diseño del circuito de control de carga.

A la vista de estos resultados y especialmente debido a las limitaciones que impone el poco espacio del que se dispone, tanto para el prototipo como para el diseño final se propone usar el relé con bobina de excitación a 230VAC.

De todas formas el circuito de control utilizado sirve tanto para controlar un triac como para el relé, por lo que las modificaciones de cara al diseño que hay que hacer para sustituir uno por otro son mínimas.

Tal y como ya se ha comentado, con el fin de reducir el consumo se ha optado por usar el contacto normalmente cerrado del relé, gracias a lo cual durante el uso normal del circuito el consumo del circuito de actuación es nulo, solo consumiendo una potencia de 520mW durante el tiempo que se tenga deshabilitada la carga.




7.6 Bloque 6: Fuentes de alimentación.

Los parámetros fundamentales para el desarrollo de la fuente de alimentación para el vatímetro, pasa por criterios de eficiencia energética y espacio físico ocupado, puesto que como ya se ha comentado el dispositivo debe ser de dimensiones muy reducidas.

Tal cual se desarrolla en el apartado 1.6.1 de la memoria de cálculo, los requisitos básicos de la fuente de alimentación, son que sea capaz de generar una tensión de salida de +3,3V y entregar una corriente de máxima de 55mA.

En función de la fuente de alimentación utilizada puede ser necesario un circuito auxiliar para generar una alimentación flotante con el fin de poder alimentar las comunicaciones.

De cara a implementar este bloque de fuente de alimentación se plantean varias alternativas, que se van a desarrollar a continuación:

7.6.1 Fuente de alimentación capacitiva sin transformador.

Este tipo de fuentes de alimentación consiste básicamente en un divisor de tensión, empleando para ello una impedancia capacitiva a la frecuencia de red. La ventaja de este tipo de divisor de tensión, es que no disipa potencia activa, a diferencia de los puramente resistivos. Como desventaja crece la potencia reactiva, no obstante este aumento no es importante, debido a las potencias tan pequeñas que se manejan en la fuente de alimentación de este proyecto.

Las características de este tipo de fuentes se pueden resumir en la siguiente tabla:


• Tamaño reducido.

• Costes muy reducidos.

• Sin aislamiento galvánico.

• Corrientes reducidas de salida.

Tabla 20: Características de las fuentes de alimentación capacitivas.

En base a las necesidades del proyecto se ha propuesto el siguiente diseño:




230Va.c.

Alimentación simple Alimentación simétrica

Figura 26: Esquema de la fuente de alimentación capacitiva.

De estos circuitos se puede destacar, la necesidad de referir un punto de la línea de red como 0V del circuito.

Los cálculos de esta fuente se desarrollan en el apartado 1.6.2 de la memoria de cálculo, del presente proyecto.

De esta fuente se montó un prototipo que funcionó correctamente, pero presenta el inconveniente del enorme tamaño requerido por el condensador, para poder suministrar la potencia requerida.

Figura 27: Prototipo de la fuente de alimentación capacitiva.

Este elevado tamaño del condensador hace inviable el cumplimiento de las restricciones espaciales.

La posibilidad de comunicar inalámbricamente el dispositivo tampoco es viable con esta fuente, debido al alto consumo energético que hace este tipo de comunicaciones durante las transmisiones de datos (aproximadamente unos 35mA, como se describe en el apartado 1.6.1 de la memoria de cálculo).

7.6.2 Fuente de alimentación con transformador a 50Hz.

El funcionamiento de este tipo de fuentes es muy básico, consisten en transformar la tensión de la red eléctrica a un valor más bajo, para luego rectificarla y filtrarla consiguiéndose así la tensión continua deseada. Esto hace que podamos dividir este tipo de fuente en los siguientes bloques:




Figura 28: Diagrama de una fuente de alimentación convencional.

Las características de este tipo de fuentes se pueden resumir en la siguiente tabla:


• Aislamiento galvánico • Corrientes medias de salida.

• Tamaño elevado. • Costes elevados. • Rendimientos reducidos para

fuentes pequeñas.

Tabla 21: Características de las fuentes de alimentación convencionales.

Uno de los principales problemas que presenta este tipo de fuentes, es la utilización de transformadores muy voluminosos, pues el número de espiras del devanado primario ha de ser forzosamente muy elevado (debido a las frecuencia utilizada 50/60Hz).

Otro problema que presentan los transformadores de este tipo, son las pérdidas en vacío (perdidas en el hierro+perdidas en el cobre). Estas pérdidas son fijas independientemente de la carga conectada, haciendo bajar considerablemente el rendimiento en fuentes pequeñas (del orden del 30%).

En base a las necesidades del proyecto se han propuesto las siguientes topologías:

Doble fuente de alimentación flotante independiente

una de la otra. Alimentación simétrica

Figura 29: Esquema de la fuente de alimentación convencional.




De esta fuente se montó un prototipo, observándose que los resultados prácticos se corresponden con los teóricos calculados.

Figura 30: Prototipo de la fuente de alimentación convencional.

Con esta fuente su puede obtener una salida flotante, lo se podría alimentar directamente el módulo de comunicaciones RS-485 Aislado.

Las comunicaciones inalámbricas tampoco son posibles con esta fuente, pues debido a las restricciones espaciales planteadas en el proyecto, se hace imposible la utilización de un transformador con la potencia suficiente para poder alimentar al módulo de comunicaciones en trasmisión.

7.6.3 Fuente de alimentación conmutada.

El funcionamiento de este tipo de fuente de alimentación es más complejo que las de apartado anterior. Básicamente consiste en añadir una serie de bloques al principio, uno para rectificar obteniendo una tensión continua, para luego “trocearla” generando una señal con una elevada frecuencia. La ventaja de utilizar una frecuencia elevada, es que nos permite utilizar transformadores mucho más pequeños y ligeros.

Figura 31: Diagrama de una fuente de alimentación conmutada.

El empleo de este tipo de fuentes está muy generalizado hoy en día, presentando las siguientes ventajas e inconvenientes:





• Alto rendimiento, superior al 75%.

• Poco peso y tamaño compacto, al reducirse considerablemente el tamaño del transformador.

• Costo relativamente alto para potencias pequeñas

• Para obtener un rendimiento óptimo, se requiere un cálculo complejo del transformador a usar.

• Dificultad de encontrar un transformador para poder montar prototipos

Tabla 22: Características de las fuentes de alimentación conmutada.

Tal y como se resume en el cuadro, las ventajas fundamentales son el alto rendimiento, debido a que no se emplean componentes que disipen potencia (según el modelo ideal de dichos componentes), debiéndose las pérdidas a las no linealidades de los mismos.

En cuanto a los inconvenientes descritos es importante destacar que resulta complicado montar prototipos, fundamentalmente debido a que los transformadores se suelen hacer a medida para la aplicación concreta, o se necesitan usar transformadores que el fabricante tenga para aplicaciones de fuerte demanda (como los cargadores de móvil o portátiles), pero en ambos casos el fabricante suele exigir un pedido mínimo de unidades.

Tal y como se demuestra en la memoria de cálculo, la fuente de alimentación conmutada óptima para esta aplicación consiste en un convertidor flyback, debido al mínimo número de componentes que necesita, empleándose en este caso un esquema equivalente al que ofrece el fabricante del integrado encargado de la generación de la señal PWM para un cargador de móvil, que suministra una tensión de salida de 12V y una potencia de 6W.

Esta fuente de alimentación entrega una alimentación flotante.

Con esta fuente sí es posible utilizar un módulo de comunicaciones inalámbrico, puesto es capaz de entregar corriente más que suficiente para ello.

El rendimiento teórico previsto es mejor del 80%, lo que unido al bajo consumo de la electrónica desarrollada ofrece como resultado un dispositivo energéticamente muy eficiente.

La única limitación importante encontrada a esta fuente es la imposibilidad de encontrar el transformador para montar un prototipo, puesto que el fabricante no distribuye unidades individuales.




7.6.4 Fuente de alimentación flotante para las comunicaciones aisladas.

Para aquellos casos en los que la fuente de alimentación solo genera una tensión de salida, o la que genera no está asilada, se hace necesario la inclusión de una segunda fuente de alimentación, que permita genera dicha tensión.

Para esta aplicación se propone el dispositivo MAX845, el cual requiere una transformador, tal y como se ve en el siguiente esquema:

Figura 32: F.A. flotante para las comunicaciones aisladas.

Para el transformador se propone el uso del modelo HALO TGM-040P3, el cual presenta las siguientes dimensiones:

Figura 33: Dimensiones del transformador HALO TGM-040P3.

La ventaja fundamental de este diseño es que presenta un rendimiento muy elevado, ocupando un espacio muy reducido, lo que la hace ideal teniendo en cuenta las restricciones espaciales que se presentas en el proyecto.

7.6.5 Conclusiones obtenidas referentes al diseño de la fuente de alimentación.

En vista de estos datos, en el proyecto se ha optado para el montaje del prototipo por utilizar una fuente convencional con transformador a 50Hz, a pesar de su bajo




rendimiento, aunque se llega a la conclusión de que la fuente conmutada es la solución óptima y como tal se propone para el diseño definitivo.

El no montar la fuente conmutada en el prototipo se debe fundamentalmente a la imposibilidad de obtener el transformador, puesto que el fabricante del mismo no suministra unidades individuales. De todas formas esta restricción no es importante de cara a la producción de una pequeña serie de unidades, debido a lo cual para el prototipo de explotación si se utilizará dicha fuente de alimentación conmutada, usando además la fuente de alimentación flotante secundaria para las comunicaciones aisladas.

8 SOLUCIÓN HARDWARE ADOPTADA.

En vista de las conclusiones comentadas anteriormente, la solución adoptada consistirá en un vatímetro comunicado por RS-485 aislado, siguiendo las especificaciones impuestas por el protocolo de comunicaciones Modbus, con una fuente de alimentación conmutada, usando el microcontrolador complejo MSP430F47166 con su circuito de adaptación correspondiente y un control de carga mediante el empleo de un relé a 230V.

Esta elección, unida a la imposibilidad de encontrar algunos componentes (como por ejemplo el transformador de la fuente de alimentación conmutada), ha dado lugar a dos prototipos diferentes; el prototipo de validación del diseño y el prototipo industrial.

Además como solución hardware adoptada en el vatímetro, también se incluye el adaptador USB-RS485, para el PC del SCADA y la tarjeta de prototipo microcontrolada, solicitada para futuros proyectos finales de carrera.

8.1 Prototipo de validación del diseño.

Este prototipo se ha realizado con componentes through hole en su mayoría y se corresponde con la unión de los bloques comentados en el apartado anterior.

Este prototipo está basado principalmente en una tarjeta con el µC8, añadiéndole todas las partes comentadas anteriormente. Una vez ensambladas presenta el siguiente aspecto:

8 Placa Nº4: Prototipo Tarjeta uC MSP430F47166




Figura 34: Prototipo de validación del diseño.

Como se puede ver, la fuente de alimentación no es conmutada, por lo que posee un tamaño considerable, no pudiéndose integrar este prototipo en un enchufe.

Este prototipo es el que se usará para la validación tanto del software como del diseño hardware.

8.2 Prototipo de diseño industrial.

Este prototipo es una ligera variación del anterior, en el cual se ha integrado una fuente de alimentación conmutada. Además también se han modificado las encapsulado de los componentes, utilizándose ahora encapsulados en formato SMD, con un tamaño mucho menor. Estas dos modificaciones permiten reducir considerablemente el tamaño del prototipo, haciendo esto posible la integración del dispositivo dentro de un cajillo de enchufe estándar.

El esquema completo y las placas de este prototipo9 se encuentran en el documento de planos 9.x del presente proyecto. Presentando el siguiente layout:

9 Placa Nº9: Prototipo de Explotación




Figura 35: Layout del prototipo de explotación.

Además este prototipo incorpora la fuente de alimentación conmutada, que como se puede observar ocupa muy poco espacio.

El motivo de no fabricar físicamente este prototipo es debido a la dificultad que presenta la soldadura de componentes SMD por procedimientos manuales. Otro problema que presenta este formato de componentes es, que a pesar de que su costo es considerablemente menor, son más difíciles de encontrar en lotes de pequeñas unidades en el mercado (series no inferiores a 50 ó 100 unidades).

De todas formas, debido a que las variaciones entre ambos prototipos solamente consisten en un cambio de encapsulado de los componentes, al validar el diseño en el otro prototipo se puede asegurar que el diseño del prototipo industriales completamente funcional.

8.3 Interfaz USB-RS485.

Como se ha comentado anteriormente, en el presente proyecto se ha exigido la realización de un software de control para los dispositivos medidores. Como se explicará más adelante en el apartado 9.2, se ha optado por utilizar un PC con el software de SCADA comercial Vijeo Citect 7.0

El problema de utilizar un PC como elemento de control, es que a diferencia del los PLC, estos no presentan un interfaz de comunicación RS-485 de forma nativa. Debido a esto, se ha tenido que implementar algún tipo de adaptador, que permita convertir este protocolo a uno más presente en los PCs.




Finalmente se ha optado por diseñar un interfaz USB a RS-485. Este diseño10 se detalla en los planos 8.x, y presenta el siguiente aspecto:

Figura 36: Interfaz USBtoRs485.

8.4 Tarjeta µC de propósito general.

Como se comento al comienzo de la presente documentación, en este proyecto también se abarcaba el diseño de una tarjeta de propósito general con un µC, que sirva como punto de partida para futuros proyectos.

Para este fin se propone la tarjeta11 detallada en los planos 1.x, y la cual presenta el siguiente aspecto:

Figura 37: Prototipo Tarjeta uC MSP430F2274

10 Placa Nº8: Interfaz USBtoRs485

11 Placa Nº1: Prototipo Tarjeta uC MSP430F2274




Esta tarjeta cuenta con el microcontrolador MSP430F2274 perteneciente a la familia 2, la cual presenta las características detalladas en el apartado 7.3.2.

Para la programación de esta tarjeta basta con utilizar un programador compatible con Spy-Bi-Wire (programador del kit Z-Accel EZ430-RF248012) y el software de programación IAR Embedded Workbench KickStart, propuesto en el apartado 9.1.2.

9 ANÁLISIS DE LAS DISTINTAS SOLUCIONES SOFTWARE

En cuanto al software existen varias alternativas a estudiar y que se van a desarrollar los próximos apartados.

9.1 Determinación de la herramienta de programación a utilizar para el

microcontrolador.

Existen muchos compiladores para esta familia de microcontroladores.

Este apartado se va a centrar en un estudio comparativo entre los IDE más importantes que existen para estos µCs de desarrollo en C.

9.1.1 CrossStudio.

Este es un compilador muy eficiente en C para los micros MSP430 desarrollada por Rowley Associates, aunque también hay versiones para otros micros, como los ARM. Sus principales características son:


• Genera código muy eficiente. • Versión completamente funcional

de 30 días. • Precio económico de las licencias

educacional y personal.

• Aún no tiene soporte para el MSP430F47166.

Tabla 23: Características del CrossStudio.

Ese compilador genera un código muy eficiente, presenta un entorno de trabajo muy cómodo y existe una versión de prueba totalmente funcional con un periodo de validez de 30 días.

12 http://focus.ti.com/docs/toolsw/folders/print/ez430-rf2480.html




Figura 38: CrossStudio de Rowley Associates.

Se ha desechado del presente proyecto debido a que el microcontrolador escogido, es excesivamente nuevo y este entorno aún no tiene soporte para él.

9.1.2 IAR Embedded Workbench KickStart.

Es un entorno de desarrollo gratuito desarrollado por IAR y facilitado por Texas Instruments en su propia web13.

Figura 39: IAR Embedded Workbench KickStart.

13 http://focus.ti.com/docs/toolsw/folders/print/iar-kickstart.html




Sus principales ventajas e inconvenientes son:


• Versión gratuita. • Soporta todos los micros de la

familia, incluso los más nuevos. • Genera código muy eficiente.

• Código limitado a unos 9K. • Entorno de trabajo más incómodo que el

de Rowley Associates.

Tabla 24: Características del IAR Embedded Workbench KickStart.

Como se ha comenta, este compilador es el que recomienda Texas Instruments en su propia web como herramienta de partida, presentando un entorno amigable, pero estando restringido a que el código que se desarrolle tiene que ser menor de 9K.

9.1.3 IAR Embedded Workbench.

Es la herramienta completa desarrollado por IAR. Su entorno es idéntico a la versión kickstart y no presenta la limitación de tamaño de código, pero curiosamente la versión de prueba que se puede descargar de la web aún no tiene soporte para el microcontrolador seleccionado.

Figura 40: IAR Embedded Workbench.




Presenta las siguientes características principales:


• Existe una versión gratuita completamente funcional por 30 días.

• Genera código muy eficiente.

• La versión demo de 30 días no soporta todos los micros de la familia

• Entorno de trabajo más incómodo que el de Rowley Associates.

Tabla 25: Características del IAR Embedded Workbench.

Si se mira la información de la página, si se actualiza la herramienta sí se tiene dicho soporte, pero con la licencia de pruebas no hay acceso al área de descarga de las actualizaciones.

9.1.4 Code composer.

Figura 41: Code Composer de Texas Instruments.

Code composer es la herramienta de programación creada por el fabricante Texas Instruments. Sus principales características son:





• Supera todos los micros de la familia, incluso los más nuevos.

• La versión demo descargable desde la web solo permite programar en ensamblador.

Tabla 26: Características del Code Composer.

A pesar de generar un código muy optimizado, tener soporte para todos los microcontroladores de la familia, la versión de prueba de este software está limitada a solo permitir en desarrollo de código en ensamblador, por lo que se ha desechado para la presente aplicación.

9.1.5 GNU C compiler for MSP430.

Figura 42: GCC para MSP430.

Este entorno es una versión del compilador opensource GCC para esta familia de microcontroladores y presenta las siguientes características principales.


• Totalmente gratuito.

• Sin limitación en el tamaño máximo del código.

• Aún no soporta todos los micros de la familia.

• Genera un código no tan eficiente como los anteriores.

• Entorno en desarrollo, aún presenta algunos “bug” importantes.

Tabla 27: Características del GCC para MSP430.

Además del entorno de programación también se están desarrollando herramientas para la depuración y carga de código en el microcontrolador.




Figura 43: Herramienta de depuración gratuita para MSP430.

Si bien con ese compilador no se tiene limitación en el tamaño del código, genera un código no tan optimizado como los otros compiladores, además de no soportar aún todos los dispositivos de TI, ni microcontroladores ni programadores, debido a que el proyecto está aún en fase beta.

Debido a esto, se ha descartado esta opción, aunque apunta ser una opción muy interesante cuando el desarrollo esté lo bastante maduro.

9.1.6 Conclusiones referentes al software de programación.

Debido a las limitaciones comentadas anteriormente, la herramienta software adoptada para el desarrollo del presente proyecto ha sido el IAR Embedded Workbench KickStart, teniendo en mente su limitación de 9K en memoria de programa, a la hora del desarrollo del software.

9.2 Determinación del software de SCADA.

Para el desarrollo del SCADA se valoraron las alternativas que se exponen a continuación:




9.2.1 WinCC.

Figura 44: WinCC de Siemens.

Este es el software de SCADA desarrollado por Siemens. Sus principales características son:


• Permite programar Scripts escritos en C.

• No incorpora driver de soporte Modbus.

Tabla 28: Características del WinCC.

Su principal ventaja es que en este SCADA la programación de Script se puede hacer en C.

Todas las herramientas de SCADA resultan muy similares entre sí. El motivo por el que se ha rechazado este SCADA es por no poseer directamente integrado driver de comunicaciones Modbus.




9.2.2 Vijeo Citect.

Figura 45: Vijeo Citect

Es el SCADA de Schneider y presentando las siguientes características:


• La Escuela Superior de Ingeniero tiene licencia de este software.

• Tiene incluidos driver de comunicación Modbus.

• No soporta Scripts en C, solo en Visual Basic y en un lenguaje propio.

Tabla 29: Características del Vijeo Citect.

Puesto que el desarrollo del SCADA pretende ser una demostración de que es posible comunicar los dispositivos realizados con un entorno genérico, este SCADA es una buena alternativa al poseer directamente un driver de comunicaciones Modbus, junto con el hecho de que la Escuela Superior de Ingenieros posee licencia de dicho software.




9.2.3 LabView.

Figura 46: LabView de National Instruments.

LabView es un entorno de desarrollo de interfaces hombre máquina y control realizado por National Instruments. Sus principales características son:


• La Universidad de Sevilla tiene licencia para el empleo de este software.

• No tiene driver de soporte para Modbus. • Programación visual laboriosa para

realizar tareas complejas.

Tabla 30: Características del LabView.

El motivo de rechazar este software se centra en que con su lenguaje de programación visual y no estándar, el desarrollo que se pretende realizar no sería fácilmente portable a otro SCADA genérico, a demás de que dicha programación resulta muy laboriosa.




9.2.4 Programa para PC hecho en Borland C.

Figura 47: Entorno de desarrollo integrado Borland C.

Esta solución consiste en el empleo de un lenguaje genérico de programación de PC para el desarrollo del SCADA, en concreto C++. Sus principales características son:


• Alto rendimiento del Interfaz desarrollado.

• Código ejecutable sin necesidad de disponer de la herramienta de desarrollo ni de ningún runtime.

• No tiene soporte directo para comunicaciones Modbus.

• El desarrollo es más laborioso y exige mucho más tiempo que el necesario para realizar las interfaces que con un software de SCADA.

Tabla 31: Características de un programa para PC hecho en Borland C.

Si bien en cuanto a costo esta podría ser una de las opciones más económicas, puesto que el software se compra una vez y no hay que pagar por instalación como pasa con los software de SCADA, se ha rechazado fundamentalmente debido al alto costo de desarrollo que plantea, puesto que hay que partir desde cero para la realización del interfaz, es decir, no solo hay que implementar la pila de comunicaciones Modbus, sino todos los demás recursos que en un software de SCADA ya están resueltos, mientras que en un lenguaje de programación general hay que programarlos desde cero.




9.2.5 Conclusiones referentes en cuanto al software de SCADA a utilizar.

Fundamentalmente debido a que la Escuela Superior de Ingenieros ya tiene una licencia de dicho software, se ha decidido usar el SCADA usando el Vijeo Citect 7.0.

No se han valorados aspectos como el costo de la herramienta, puesto que el desarrollo del SCADA solo aspira a ser un ejemplo de demostración del correcto funcionamiento del sistema. Así pues, todo el desarrollo realizado puede servir como punto de partida para la aplicación de una instalación concreta, se realice con dicho software de SCADA o con cualquier otro.

Debido a que este SCADA implementa directamente un driver de comunicaciones Modbus, no se va a usar un servidor OCP.

9.3 Determinación del método de comunicación entre el SCADA y los

módulos.

Una vez fijado que el protocolo va a ser Modbus, existen varias maneras de plantear las comunicaciones entre el SCADA y el PC.

Para este proyecto se han valorado las siguientes:

9.3.1 Comunicación mediante programación del protocolo (ActiveX).

Todos los software de SCADA y software de programación de propósito general actuales tienen soporte para el uso de módulos ActiveX.

Estos módulos añaden una vez instalados una interfaz de acceso a ciertos recursos, de manera transparente y mediante programación orientada a objetos.

Por ejemplo para el presente proyecto se puede usar el módulo gratuito NetComOCX que permite un acceso cómodo a los puertos series presentes en el PC.

Las principales ventajas e inconvenientes de este sistema son las siguientes:


• Solución general válida para cualquier SCADA del mercado.

• Desarrollo laborioso, ya que hay que implementar la pila de comunicaciones Modbus.

Tabla 32: Características del uso de ActiveX.

Como se ha comentado antes, si bien es una solución barata y general de cara a aplicarla en cualquier software, implica un coste de desarrollo elevado, puesto que sería




necesario montar toda la pila del protocolo mediante programación, puesto que estos módulos solo permiten la redirección de datos a la capa física, siendo la implementación del protocolo determinado trabajo del programador.

A esto hay que sumar que casi todos los SCADA del mercado se programan en Visual Basic y no en C, por lo que la pila Modbus desarrollada para el microcontrolador no sería reutilizable en el SCADA.

9.3.2 Comunicación mediante servidor de variables (módulo OPC).

Esta alternativa consiste en la inclusión de un tercer programa a modo de buffer intermedio, que se encarga de realizar las comunicaciones con los dispositivos Modbus de forma periódica, almacenando dicha información a la espera de que el SCADA se la solicite.

Figura 48: Servidor OPC.

Un ejemplo de este tipo de servidor podría ser el comercializado por OPC System, otra opción sería el comercializado por MatrikonOPC.

Las principales ventajas e inconvenientes de este sistema son las siguientes:


• Solución general válida para cualquier SCADA del mercado.

• Precios de licencias muy elevados.

Tabla 33: Características del uso de un servidor OPC.




El elevado precio de estas herramientas hace inviable su utilización en el proyecto.

9.3.3 Comunicación directa mediante driver embebidos en el SCADA.

Esta es la solución más cómoda y directa, pero no está permitida en todas las herramientas de SCADA. Consiste básicamente en que el SCADA implemente internamente la pila Modbus, por lo que su uso pasa a ser transparente.

Sus principales características son:


• Manejo directo del protocolo desde el SCADA de una manera Transparente.

• Costo relativamente alto para potencias pequeñas

Tabla 34: Características del driver embebidos en el SCADA.

Siempre y cuando el SCADA escogido permita esta posibilidad, parece claro que es la opción que más ventajas presenta.

9.3.4 Conclusiones referentes al método de comunicación.

Como conclusión, siempre que el SCADA permita comunicación directa con Modbus se escogerá esta opción.

Para aquellos SCADA que no lo permitan, la mejor opción pasa a ser el empleo de un módulo OPC.

9.4 Determinación de las alternativas referentes al diseño del software del

µC.

Las distinciones fundamentales se dan de cara a la elección de la forma de planificación.

Las distintas alternativas valoradas son las siguientes:

9.4.1 Implementación del programa del µC con un planificador cíclico.

Consiste en la solución más sencilla, pero también resulta la más complicada de modificar.






• Es el planificador más sencillo de implementar.

• No se pueden atender tareas esporádicas.

Tabla 35: Características del uso de un planificador cíclico.

Esta manera de enfocar el desarrollo del software queda rechazada debido a que no se pueden controlar tareas esporádicas, tales como son las comunicaciones por Modbus.

9.4.2 Implementación del programa del µC con varios niveles de ejecución, sin

Sistema Operativo.

Esta opción consiste básicamente en dividir el programa en dos grandes bloques, las tareas no prioritarias de segundo plano (background) y las prioritarias, de primer plano (foreground) que se lanzan mediante rutinas de atención a las interrupciones.



• Más flexible que el planificador cíclico.

• Permite atender tareas esporádicas. • El gasto de recursos hardware es

mínimo.

• El número de niveles de prioridad existente es muy limitado.

Tabla 36: Características del uso de un planificador con varios niveles de ejecución, sin Sistema

Operativo.

Esta opción sí permite tratar tareas esporádicas y es una buena solución para códigos relativamente simples, como el que se pretende desarrollar.

Además, hay que tener en cuenta que en este µC se puede hacer que tras saltar una interrupción, se borre su flag de interrupción y se vuelva a activar las interrupciones. Con esto se consigue algo parecido a tener tres niveles de prioridad, el proceso de segundo plano (background), los procesos de interrupciones interrumpibles (con prioridad mayor al background) y las interrupciones no interrumpibles, que poseen la máxima prioridad (foreground).




9.4.3 Implementación del programa del µC mediante el uso de un sistema

operativo.

Figura 49: Logotipo de Tiny Os, un sistema operativo desarrollado para microconroladores.

Es la opción más general y más eficiente de cara a desarrollos complejos. Sus principales características son:


• Se pueden definir múltiples niveles de prioridad.

• Los códigos generados son más simples y fácilmente portables.

• Consume recursos del sistema.

Tabla 37: Características del uso de un sistema operativo para el µC.

Para esta aplicación particular se ha rechazado esta opción debido a que no se considera necesario que para el proceso a controlar se necesite más de tres niveles de ejecución, unido esto a la limitación máxima de 9K del compilador, hace más aconsejable no cargar en núcleo de un SO, que reduciría aun más la cantidad de memoria disponible.

9.4.4 Conclusiones referentes a las alternativas del diseño software.

En vista a esto y para el software relativamente simple que se pretende desarrollar, se ha escogido la opción de la implementación de varios niveles de ejecución sin sistema operativo, a partir de mecanismo hardware de atención a las interrupciones.

9.5 Determinación de las alternativas referentes al método de la medida de

potencia activa.

Si se atiende a la fórmula general de la potencia, se puede observar que para calcularla es necesario la integración en un intervalo de tiempo de la potencia instantánea, definida como:




0

1( )· ( )·

TP v t i t dt

T= ∫

Ahora bien, para realizar esta operación hay que medir V e I en el mismo instante, lo cual no es posible si solo se posee un CAD o si no se puede realizar el lanzamiento de manera instantánea.

A partir de esto se plantean varias posibles maneras de estimar la potencia, las cuales se plantean a continuación:

9.5.1 Medida de la tensión y la corriente de manera simultánea.

Esta es la solución más fácil, pero dependiendo del microcontrolador elegido puede estar disponible o no. Sus características son:


• Es la solución más natural y sencilla.

• Para el cálculo de potencia solo es necesaria una multiplicación por pares de medida.

• No es posible realizarla con todos los microcontroladores.

• El circuito de adaptación puede introducir desfases que afecten a la precisión.

Tabla 38: Características del método de medida de la tensión y la corriente de manera simultánea.

Para poder realizar esto, es necesario que el microcontrolador disponga de varios CAD independientes que se puedan agrupar para conseguir que el lanzamiento sea simultáneo.

Si todos los conversores son iguales y configurados a la misma velocidad y se garantiza que comienzan todos de manera sincronizada, también se puede garantizar que todos ellos acaban a la vez, por lo que las medidas realizadas corresponderán al mismo instante de tiempo.

Para hacer esto hay que tener especial cuidado de que el circuito de acondicionamiento no introduzca un desfase diferente entre los distintos canales, ya que si no la multiplicación instantánea de v · i dará un resultado erróneo.

En el caso de que no se pueda garantizar que las medidas son simultáneas, hay que pasar a realizar un cálculo del desfase, a partir del cual se puede estimar el valor de la magnitud que habría en el instante dado si no hubiera desfase, multiplicando por tanto una de las medidas por la estimación de la otra.

Esto es costoso computacionalmente, puesto que requiere la realización de varias multiplicaciones, siendo por tanto una medida que se tratará de evitar.




9.5.2 Medida de la potencia con el principio del tiempo reducido de muestreo.

Esta técnica es un método, patentado por Texas Instruments14 y que se puede usar libremente15 para el cálculo de potencia con un solo conversor de múltiples canales.

Sus características más importantes son:


• Se requiere un número de multiplicaciones reducido.

• Solo requiere el uso de un CAD. • El principio de funcionamiento es

independiente al tiempo de atención a la interrupción del micro.

• El sistema tiene un error inherente por la técnica de medida utilizada, aunque se puede calibrar.

• Aparecen errores en la medida se la frecuencia de la tensión de entrada varía de la de calibración del sistema.

Tabla 39: Características del método de medida de la potencia con el principio del tiempo reducido de muestreo.

Esta técnica consiste en, dado un periodo de muestreo dado, que vamos a suponer que vale el periodo genérico Tsample, desfasar las medidas de tensión y corriente

un tiempo igual a 2sampleT

.

Figura 50: Timing de la técnica del principio de muestro reducido.

Esta técnica es correcta siempre y cuando se pueda suponer que en el sistema a medir, las dos señales varían poco entre dos intervalos de medidas consecutivos.

En el caso de la medida de potencia en red eléctrica esa suposición es aproximadamente correcta y equivalente a suponer una red rígida, es decir, la tensión es siempre senoidal con frecuencia constante y sin armónicos.

14 Esta técnica se describe con detalle en la nota de aplicación SAA024 de Texas Instruments.

15 Siempre y cuando se implemente en un microcontrolador de Texas Instruments.




Si bien esto no es del todo cierto, si es verdad que a lo largo del tiempo las variaciones de tensión y frecuencia que se producen en la red son limitadas.

Figura 51: Formas de onda de la tensión, corriente y potencia instantánea.

Como el desfase de las señales es justo la mitad de la frecuencia de muestreo, la estimación de la tensión a multiplicar por la corriente para el cálculo de la potencia instantánea se reduce al cálculo de la media entre dos medidas consecutivas de tensión.

Esto es especialmente útil para reducir el número de multiplicaciones a realizar, ya que si la media se calcula como:

1

2n nv v− +

Al aplicar esto a la expresión del cálculo de potencia, teniendo en cuenta que la integral discreta es un sumatorio, queda:

( ) ( )1 10 0

1 1· · · ·

2· 2·

k N k N

n n n n n nk k

P v v i dt v v i dtN N

= =

− −= =

= + = +∑ ∑




Es decir, quitando el factor de escala que es una única multiplicación a realizar al final del sumatorio (y que independientemente del método de medida a utilizar siempre habrá que realizar) con tan solo tomar la suma de dos instantes consecutivos de la tensión, solo hay que realizar una multiplicación por ciclo, es decir, exactamente lo mismo que pasaría si se tomasen las medidas de tensión y corriente de manera sincronizada.

Se puede comprobar fácilmente que esta técnica tiene un error implícito y que el fabricante en la nota de aplicación anteriormente citada estima y demuestra que dicho error es constante siempre y cuando la frecuencia de la tensión sea siempre la misma, por lo que con tan solo aplicar un factor de corrección se puede eliminar dicho error inherente al sistema.

Si se incluye este factor de corrección el fabricante mediante pruebas experimentales afirma que se obtienen errores del orden del 0,2%, siendo el error teórico con una variación de frecuencia del 5% (que es mayor que el límite que impone la normativa) menor al 0,53%.

9.5.3 Conclusiones referentes al método de la medida de la potencia activa.

Ambas técnicas son buenas alternativas, al menos según el análisis de errores que realiza Texas Instruments de su técnica del tiempo reducido de muestreo.

De todas formas teniendo en cuenta que el microcontrolador elegido garantiza que se pueden realizar medidas simultaneas desde varios canales, implementando incluso un mecanismo interno para calibrar los desfases introducidos16 por el circuito de adaptación de la señal, se va a utilizar la técnica del cálculo de potencia por la medida de tensión y corriente simultanea.

10 SOLUCIÓN SOFTWARE ADOPTADA.

En vista de lo anterior y a modo de resumen, para el microcontrolador se va a diseñar un software en C con la herramienta gratuita IAR Embedded Workbench KickStart, que limita el tamaño del código a unos 9K. Dicha programación se realizará con varias tareas y varios niveles de prioridad sin sistema operativo, midiendo simultáneamente V e I para el cálculo de la potencia.

A partir de esto se ha diseñado un software con las siguientes características:

16 Para ello el µC permite introducir un pequeño desfase entre las medidas de varios canales,

totalmente configurable, mediante la carga de un valor numérico en un registro del ADC denominado pre.




• Programa dividido en varias tareas simultáneas, una de baja prioridad (bakground) y varias de prioridad superior (foreground).

• Las tareas de que no se consideren críticas podrán ser interrumpidas por otras tareas cuya prioridad sea igual o superior.

• Las funciones de comunicaciones Modbus se han programado aparte como una librería, con la finalidad de poderlas usar en otros proyectos donde se requiera este tipo de comunicaciones.

• Las funciones de cálculos de magnitudes eléctricas se han programado aparte en forma de librería, con el fin de hacer lo más general posible el software desarrollado.

• Las funciones de control de flash se han desarrollado aparte como una librería, con la finalidad de generar código reaprovechable para futuros desarrollos.

• El CAD sigma-delta se utiliza con un sobremuestreo de 256, una precisión de 16 bits, usando la referencia interna y con todos los canales configurados para una captura simultánea de forma continua.

• La rutina de interrupción del CAD tiene una periodicidad de 256µS, y se encarga de guardar los valores acumulados de las magnitudes.

• El programa main es un bucle infinito con la menor prioridad posible y se encargará del cálculo de las magnitudes eléctricas en función de los valores acumulados.

• Con el fin de reducir el consumo y el calentamiento, la CPU permanecerá dormida el mayor tiempo posible, despertándose cada vez que haya una nueva rutina de interrupción o cuando haya nuevos datos por procesar.

El programa completo del microcontrolador se desarrolla de una manera detallada en los próximos apartados. Así pues de adjunta una copia impresa de dicho código al final del presente documento.

Por otro lado referente al SCADA, se ha utilizado un software genérico para diseño de SCADA, en concreto el Vijeo Citect 7.1, usando para las comunicaciones los driver embebidos de esta utilidad.




10.1 Explicación detallada de los módulos del programa del microcontrolador.

Debido a la complejidad y extensión del programa, este se ha dividido en varios archivos o módulos, cada uno de los cuales está encargado de realizar un cometido concreto.

10.1.1 Módulo main.

En este módulo se corresponde con el programa principal. Se encarga de inicializar todos los demás módulos y de ejecutar la tarea del proceso de menor prioridad.

10.1.1.1 Definición de la cabecera (Vatimetro.h).

En esta cabecera se incluyen todas las variables y encabezados de todos los módulos necesarios para el correcto funcionamiento del programa.

10.1.1.2 Definición de las funciones (main.c).

En este bloque se definen todas las funciones que componen el programa principal.

Básicamente está formado por las rutinas de inicialización, la rutina main y la de atención al conversor analógico digital.

Estas funciones presentan la siguiente estructura:




10.1.1.2.1 Función main.




Es la función del programa principal, se encarga de inicializar todos los periféricos y del tratamiento de los datos capturados. Se corresponde con el proceso de menor prioridad.

10.1.1.2.1.1 Prototipo de la función.

int main(void)

10.1.1.2.1.2 Tabla de variables globales.

Nombre Tipo Descripción

TablaDatos unsigned int Tabla de datos compartidos por Modbus donde se almacenan los resultados medidos.

FlagCalcula unsigned

char Flag que indica si hay nuevos datos de medida pendiente de procesar.

DatosCap long long * Tabla donde se almacenan los acumulados de las variables a medir

VRAW int * Tabla de datos de tensión en bruto, usados para dibujar la gráfica.

IRAW int * Tabla de datos de corriente en bruto, usados para dibujar la gráfica.

DatosFrec unsigned int

* Tabla de datos que almacena la cuenta de semiciclos.

escalaV float Factor de escala para las medidas de tensión. escalaI float Factor de escala para las medidas de corriente.

escalaPActiva float Factor de escala para el cálculo de la potencia activa. IMax long int Corriente instantánea máxima permitida.

10.1.1.2.1.3 Tabla de variables locales.


ValorMedido float Variable temporal que almacena algunos datos medidos antes de transferirlos a la tabla de variables compartidas.

Vrms float Variable temporal que almacena la tensión eficaz medida.

Irms float Variable temporal que almacena la corriente eficaz medida.

Pactiva float Variable temporal que almacena la potencia activa medida.

Paparente float Variable temporal que almacena la potencia aparente medida.

Energia long float Variable temporal que almacena la energía medida.

Arranque int Cuenta en segundos del tiempo de arranque. Cuando finalice dicho estado valdrá 0.

Etemp unsigned

int *

Tabla que almacena el valor de la energía, para usada para comprobar si ha llegado un nuevo valor por Modbus.




10.1.1.2.1.4 Tabla de constantes.


NSegFrec char Número de segundos almacenados para el cálculo de la frecuencia.

TiempoMuestreo float Indica el tiempo existente entre cálculos de medidas.

MBOK char Resultado que indica que la lectura de datos se ha realizado.

TarrranqueDef int Tiempo de arranque, expresado en segundos.

NCAP char Número de capturas del CAD que se da en el tiempo de muestreo.




10.1.1.2.2 Función Inicia.




El objetivo de esta función consiste en inicializar todos los puertos de E/S y periféricos necesarios para el correcto funcionamiento de la aplicación.

Esta función también se encarga también de inicializar el módulo encargado del control de las comunicaciones Modbus.


void Inicia (void)



TablaDatos unsigned

int Tabla de datos compartidos por Modbus donde se almacenan los resultados medidos.


Nombre Tipo Descripción i int Variable auxiliar para recorrer los bucles for.



TamTabla unisgned

int Número de registros que hay en la tabla de datos compartidos.

TamEscritura unsigned

int Número de registros con permisos de escritura que hay en la tabla de datos compartidos.

Direccion unsigned

cahr Dirección de esclavo Modbus que se le ha fijado al módulo.




10.1.1.2.3 Función Inicia_cad.

Función auxiliar encargada de configurar el CAD de 16 bits, así como inicializar todas las variables asociadas al mismo.





void inicia_cad(void)



i unsigned

char Variable auxiliar para recorrer los bucles for.


Nombre Tipo Descripción OSR_FILTRO #define Tasa de sobremuestreo del ADC16.




10.1.1.2.4 Función IniFlash.

Se encarga de leer valores de los parámetros almacenados en flash y cargándolos en las variables de escala y ajuste de offset. También se encarga de inicializar la memoria flash en caso de que se encuentre vacía.


void IniFlash(void)





Nombre Tipo Descripción escalaV float Factor de escala para las medidas de tensión. escalaRI float Factor de escala para las medidas de alta corriente. escalaI float Factor de escala para las medidas de baja corriente.

escalaTemp float Factor de escala para la temperatura. escalaPActiva float Escala de escala para la potencia activa.

OffsetCAD int * Tabla que almacena el offset de cada uno de las entradas usadas del ADC16.



I unsigned

int Variable auxiliar usada para recorrer los bucles for.

Resul unsigned

int Resultado de hacer la OR a todo el bloque de flash. Se utiliza para saber si la flash está inicializada o no.

PunteroFLASH unsigned

char * Puntero que señala al bloque de flash donde están almacenados los datos de calibración.

ID_Defecto unsigned

char

Variable que almacena la dirección Modbus por defecto. Se usa para almacenar en caso de que la flash o esté inicializada para almacenar

Tdatos float * Tabla que almacena una copia del contenido de la flash, para poder modificar los valores y escribir el resultado en la flash.


Nombre Tipo Descripción DIRECCION char Dirección Modbus por defecto del módulo.

Flash1 unsigned

char * Puntero que señala al primer bloque de flash, donde se almacenan las constantes.

Flash2 unsigned

char * Puntero que señala al segundo bloque de flash, donde se almacena la dirección Modbus.




10.1.1.2.5 Función SeccionCriticaINT.

Rutina que se encarga de deshabilitar todas las interrupciones mientras que se almacena un dato de tipo entero en la tabla de variables compartidas, con el fin de asegurar el acceso exclusivo a dicha tabla.

SeccionCriticaInt

Se deshabilitan las

interrupciones

globales

Se habilitan las

interrupciones

globales

Fin

Se copia el entero a la

tabla de variables

compartidas


void SeccionCriticaINT(unsigned int dato,unsigned int *Tabla)

10.1.1.2.5.2 Tabla de variables de entrada.


dato unsigned int Dato que se desea almacenar en la tabla.

Tabla unsigned

int * Puntero que señala a la posición de la tabla donde hay que empezar a almacenar el dato.




10.1.1.2.6 Función SeccionCriticaLINT.

Rutina que se encarga de deshabilitar todas las interrupciones mientras que se almacena un dato de tipo long int en la tabla de variables compartidas, con el fin de asegurar el acceso exclusivo a dicha tabla.


void SeccionCriticaLINT(unsigned long int dato,unsigned int *Tabla)






Dato unsigned long int

Dato que se desea almacenar en la tabla.

Tabla Unsigned

int * Puntero que señala a la posición de la tabla donde hay que empezar a almacenar el dato.



Pdato unsigned

int * Puntero usado para recorrer el dato entero largo de entrada como si fuera una tabla de 2 enteros.




10.1.1.2.7 Función SeccionCriticaTablaINT.

Rutina que se encarga de deshabilitar todas las interrupciones mientras que se almacena una tabla de datos de tipo entero en la tabla de variables compartidas, con el fin de asegurar el acceso exclusivo a dicha tabla.


void SeccionCriticaTablaINT(int *dato, unsigned char longitud, unsigned int *Tabla)



dato unsigned

int * Tabla de dato que se desea almacenar en la tabla.

longitud unsigned

char Número de datos que hay que almacenar en la tabla de variables compartidas

Tabla unisgned

int * Puntero que señala a la posición de la tabla donde hay que empezar a almacenar los datos.



i unisgned

char Variable auxiliar para recorrer la tabla de datos de entrada para copiarla a la tabla de variables compartidas.




10.1.1.2.8 Función ControlFlash.

Esta función se ejecuta cuando llega un nuevo dato por Modbus y se encarga de decodificar la orden para averiguar si se corresponde con algunas de las que implican el




uso de flash. En caso afirmativo ejecutará la escritura en flash correspondiente y reseteará el microcontrolador.


void ControlFlash(void)



TablaDatos unsigned int Tabla de datos compartidos por Modbus donde se almacenan los resultados medidos y los datos recibidos.

escalaV float Factor de escala para las medidas de tensión. escalaRI float Factor de escala para las medidas de alta corriente. escalaI float Factor de escala para las medidas de baja corriente.

escalaTemp float Factor de escala para la temperatura.

OffsetCAD int * Tabla que almacena el offset de cada uno de las entradas usadas del ADC16.



Indice unsigned int Variable auxiliar usada para decodificar la orden que llega.

NuevaEscala float Variable auxiliar donde se calcula el nuevo offset o la nueva ganancia de la medida.

Tdatos float * Tabla que mantiene una copia en RAM de los datos grabados en flash, para poder modificarla y volverla a grabar en la flash

Nuevo_ID unsigned

char Variable que almacena el nuevo Identificador Modbus. Solo se usa en la orden de modificar el Identificador.



Flash1 unsigned char*

Dirección de comienzo del primer bloque de flash, donde se guardan los datos calibrados.

Flash2 unsigned char*

Dirección de comienzo del segundo bloque de flash, donde se guarda el identificador Modbus.

MBOK char Resultado que devuelve la función TestModBusFree()

en caso de que el Modbus no tenga más operaciones pendientes.

ReleOff #define Macro para desactivar el relé de salida.

Flash1 unsigned char *

Puntero que señala al primer bloque de flash, donde se almacenan las constantes.

Flash2 unsigned char *

Puntero que señala al segundo bloque de flash, donde se almacena la dirección Modbus.




10.1.1.2.9 Función ControlEnergia.

Esta función se encarga de comprobar si por Modbus ha llegado un nuevo dato de energía. En caso afirmativo, actualiza la variable que almacena la energía acumulada en función del nuevo dato recibido.


char ControlEnergia (unsigned int *TablaD, unsigned int *TablaE,long float *Eant);






TablaD unsigned

int * Tabla que almacena el nuevo valor de energía que ha llegado por Modbus, almacenado como tabla de enteros.

TablaD unsigned

int * Tabla que almacena el antiguo valor de energía, almacenado como tabla de enteros.

Eant long float * Puntero que señala a la variable donde se almacena la energía calculada.



Presul unsigned

int * Puntero usado para direccional el long float que contiene la energía como una tabla de enteros.

Resultado unsigned long int

Variable que almacena el dato leído como entero, antes de pasarlo como flotante a la variable compartida.



OK char Resultado que devuelve la función en caso de que haya llegado un nuevo dato de energía por Modbus.

ERROR char Resultado que devuelve la función en caso de que no haya llegado un nuevo dato de energía por Modbus.

10.1.1.2.9.5 Tabla de variables de salida.


resultado char Resultado que devuelve la función en función de si hay un nuevo dato de energía o no. Devuelve OK si hay nuevo dato y ERROR si no lo hay.




10.1.1.2.10 Función SD16AISR.




Esta rutina es la función de atención a la interrupción al CAD de 16 bits, que se activa cada 256µs.


__interrupt void SD16AISR(void)



OffsetCAD int Tabla que almacena el offset medido de cada uno de los canales del ADC16.

IMax long int Corriente instantánea máxima permitida.

DatosCap long long * Tabla donde se almacenan los acumulados de las variables a medir

DatosFrec unsigned

int * Tabla de datos que almacena la cuenta de semiciclos.

FlagCalcula unsigned char Flag que indica si hay nuevos datos de medida pendiente de procesar.

TablaDatos unsigned int Tabla de datos compartidos por Modbus donde se almacenan los resultados medidos.

VRAW int * Tabla de datos de tensión en bruto, usados para dibujar la gráfica.

IRAW int * Tabla de datos de corriente en bruto, usados para dibujar la gráfica.



FlagFrec static

unsigned char Flag usados para la detección de semiciclos en la medida de frecuencia.

Ftmp static

unsigned int Variable auxiliar que almacena la cuenta de semiciclos en la medida actual.

Nseg static

unsigned char Variable auxiliar que se usa para apuntar a la tabla de medidas de frecuencia.

i unsigned char Variable auxiliar usada para los bucles for.

segurlectura Int Variable auxiliar ara comprobar si se ha producido un error en el ciclo de lectura del ADC16.

NCiclos static

unsigned in Variable que cuenta el número actual de ciclos del ADC16.

medCAD static long

long * Variable que va almacenando el valor actual de los acumulados de las medidas.

Itmp static long int Variable que almacena el valor instan. de la corriente. Vtmp static long int Variable que almacena el valor instan. de la tensión.

ComienzaCap static

unsigned int Variable que indica el instante el que empiezan a capturarse las tablas de datos en bruto para la gráfica.






NCAP char Número de capturas del CAD que se da en el tiempo de muestreo.

NSegFrec char Número de segundos almacenados para el cálculo de frecuencia.




10.1.2 Módulo Medidas.

En este módulo es donde están definidas las funciones de cálculo necesarias para obtener las medidas eléctricas deseadas.

10.1.2.1 Definición de la cabecera (Medidas.h).

En esta cabecera se definen las funciones y parámetros accesibles de manera externa al módulo, es decir, aquellas a las que se puede acceder desde los otros módulos que conforman el programa.

10.1.2.2 Definición de las funciones (Medidas.c).

En este bloque se definen todas las funciones, ya sean de ámbito local como global.

Se entiende por funciones de ámbito local aquellas que son privadas al módulo y no resultan accesibles desde fuera de éste, mientras que las globales son accesibles desde cualquier otro módulo

Cada una de las estas funciones, presentan la siguiente estructura:




10.1.2.2.1 Función CalculaRMS.

Esta función es la encargada de implementar el cálculo del valor RMS de una suma acumulada de datos. Esta funcionalidad, permitirá utilizarla tanto para el cálculo de la tensión como para el cálculo de la corriente eficaz. El funcionamiento básico de la función consiste en aplicar la definición de valor RMS, desarrollada en el apartado 4.4.1 de la memoria de cálculo:

( )2

1·

muestrasN

kk

RMSmuestras

medmed escala

N==∑

( )*·

datoresultado escala

Nmuestras=


float CalculaRMS (long long *dato,float escala, unsigned int Nmuestras)



dato long long *

Puntero al sumatorio acumulado del cuadrado de los datos a los que se les quiere calcular el valor RMS.

( )2

1

muestrasN

kk

med=∑

escala float Factor de escala que permite realizar una compensación del error de ganancia.

Nmuestras unsigned int Número de elementos acumulados en *dato.






resultado float Resultado del cálculo del valor RMS del parámetro introducido a la función (tensión o corriente).




10.1.2.2.2 Función CalculaMedia.

Esta función es la encargada de implementar el cálculo del valor medio de una suma acumulada de datos. Esta funcionalidad, permitirá utilizarla tanto para el cálculo de la tensión como para el cálculo de la corriente media. El funcionamiento básico de la función consiste en aplicar la definición de valor medio:

:

( )1·

muestrasN

kk

muestras

medmedia escala

N==∑

( )*·

datoresultado escala

Nmuestras=


float CalculaMedia (long long *dato,float escala, unsigned int Nmuestras)



dato long long *

Puntero al sumatorio acumulado del cuadrado de los datos a los que se les quiere calcular el valor medio.

( )1

muestrasN

kk

med=∑








resultado float Resultado del cálculo del valor medio del parámetro introducido a la función (tensión o corriente).




10.1.2.2.3 Función CalculaPact.

Esta función es la encargada de implementar el cálculo del valor de la potencia activa consumida. El funcionamiento básico de la función consiste en aplicar la definición de la potencia activa, desarrollada en el apartado 4.4.2 de la memoria de cálculo:

( )1

· ·muestrasN

k kk

activamuestras

escala i vP

N==∑

( )· *escala datoresultado

Nmuestras=


float CalculaPact (long long *dato,float escala,unsigned int Nmuestras)



dato long long *

Puntero al sumatorio acumulado del producto de tensión y corriente.

( )1

·muestrasN

k kk

i v=∑







Nombre Tipo Descripción resultado float Resultado del cálculo de la potencia activa.




10.1.2.2.4 Función CalculaPapar.

Esta función es la encargada de implementar el cálculo del valor de la potencia aparente. El funcionamiento básico de la función consiste en aplicar la definición de la potencia aparente, desarrollada en el apartado 4.4.3 de la memoria de cálculo:

·aparente RMS RMSP I V=

·resultado IRMS VRMS=


float CalculaPapar (float VRMS, float IRMS)


Nombre Tipo Descripción VRMS float Valor eficaz de la tensión calculada anteriormente. IRMS float Valor eficaz de la corriente calculada anteriormente.


Nombre Tipo Descripción resultado float Resultado del cálculo de la potencia aparente.




10.1.2.2.5 Función CalculaPreact.

Esta función es la encargada de implementar el cálculo del valor de la potencia reactiva. El funcionamiento básico de la función consiste en aplicar la definición de la potencia reactiva, desarrollada en el apartado 4.4.4 de la memoria de cálculo:

( ) ( )2 2

reactiva aparente activaP P P= −

resultado resultado=

2 2resultado Papar Pact= −

0resultado=


float CalculaPreact (float Pact, float Papar)


Nombre Tipo Descripción Pact float Valor de la potencia activa calculada anteriormente.

Papar float Valor de la potencia aparente calculada anteriormente.


Nombre Tipo Descripción resultado float Resultado del cálculo de la potencia reactiva.




10.1.2.2.6 Función CalculaFDP.

Esta función es la encargada de implementar el cálculo del factor de potencia. El funcionamiento básico de la función consiste en aplicar la definición del factor de potencia, desarrollada en el apartado 4.4.5 de la memoria de cálculo:

. . . activa

aparente

Pf d p

P=

0resultado=Pactresultado

Papar=


float CalculaFDP (float Pact, float Papar)


Nombre Tipo Descripción Pact float Valor de la potencia activa calculada anteriormente.

Papar float Valor de la potencia aparente calculada anteriormente.


Nombre Tipo Descripción resultado float Resultado del cálculo del factor de potencia.




10.1.2.2.7 Función CalculaEnergia.

Esta función es la encargada de implementar el cálculo de la energía consumida. El funcionamiento básico de la función consiste en aplicar la definición de energía, desarrollada en el apartado 4.4.6 de la memoria de cálculo:

( )1

activa kk k

PEnrgía Enrgía

tiempo−= +

Pactresultado Eant

tiempo= +


Long float CalculaEnergia (long float Eant, float Pact, float tiempo)


Nombre Tipo Descripción Eant long float Valor acumulado de la energía en el cálculo anterior. Pact float Valor de la potencia activa calculada anteriormente.

tiempo float Duración del intervalo entre operaciones de cálculo.


Nombre Tipo Descripción resultado long float Resultado del cálculo de energía.




10.1.2.2.8 Función CalculaFrec.

Esta función se encarga de calcular la frecuencia de la señal de entrada. Para ello suma una tabla que contiene el número de semiciclos que se han producido en cada segundo.

Se almacena más de un segundo con el fin de mejorar la precisión, pero el algoritmo programado asegura que se devuelvan datos desde el primer momento, así como asegurar una respuesta rápida del resultado ante variaciones bruscas de la frecuencia de la señal.

CalculaFrec

Se recorre toda la tabla calculando el

número de datos distinto de 0, el valor

máximo, el mínimo y el acumulado de

la cuenta de semiciclos.

Nº Semiciclos =0

No se han producido

semicliclos, por tanto

frec =0

Se calcula la frecuencia mediante la

fórmula:

0 1

º

2· º ·semiciclos

muestras muestra

Nfrec

N T≠

=

¿Máx - mín > 10%

del valor medido?

Se borra la tabla de cuenta de

semiciclos en una sección

crítica

Se retorna el valor de

frecuencia calculado

Fin

Si

No

Si

No





float CaclulaFrec(unsigned int *Datos,unsigned char NSeg,float Tiempo1Muestra)



Datos unsigned

int* Puntero a la tabla con los valores acumulados de semiciclos.

Nseg unsigned

char Tamaño de la tabla que almacena la cuenta de semiciclos.

Tiempo1Muestra float Duración del intervalo entre operaciones de cálculo.



Acumulado unsigned

int Almacena el acumulado de semiciclos que se han producido en la tabla.

NDatosReal unsgined

char Variable que almacena el Número de elementos distintos de 0 que aparecen en la tabla.

i unsigned

char Variable auxiliar utilizada para recorrer la tabla.

Max unisgned

int Máxima cuenta de semiciclos que se ha producido en la tabla.

Min unisgned

int Mínima cuenta de semiciclos, distintos de 0, que se ha producido en la tabla.


Nombre Tipo Descripción Freq float Resultado del cálculo de la frecuencia




10.1.2.2.9 Función CaclulaTemp.

Esta función es la encargada de implementar el cálculo del valor de la temperatura media durante el intervalo de cálculo. Esta relación se ha desarrollado en el apartado 4.4.8 de la memoria de cálculo:

( )

3

15

* 0,6·10·

2º 273

datooffsetSensor

NmuestrasTemperatura C

TCSensor

− = −

**

datodato

Nmuestras=

( ) 2* ·1,831110569·10VSensor dato −=

· 273temperatura escalaVSensor= −


float CaclulaTemp(long long *dato,unsigned int Nmuestras)






dato long long *

Puntero al sumatorio acumulado las lecturas del sensor interno de temperatura.

( )1

muestrasN

kk

temperatura=∑



Nombre Tipo Descripción VSensor float Almacena la lectura de sensor (mV).

offsetSensor float Contiene el valor de offset que presenta el sensor interno de temperatura. Según el fabricante, este valor ha de estar comprendió entre -100 y 100mV

TCSensor float Relación entre la lectura del sensor en mV y la temperatura en kelvin. Según el fabricante, este valor ha de estar comprendió entre -1,18 y 1,46.


Nombre Tipo Descripción temperatura float Resultado del cálculo del valor de la temperatura en ºC.




10.1.2.2.10 Función round.

Función que se encarga de convertir un número flotante en un entero largo, redondeando el resultado de la conversión.

( )0.5resultado Enero dato= +


long int round(float dato)


Nombre Tipo Descripción dato float Dato que se desea convertir a entero y redondear.


Nombre Tipo Descripción resultado long int Resultado del redondeo del dato flotante.




10.1.3 Módulo Modbus.

Este módulo se encarga de la definición e inicialización de todos los elementos necesarios para el correcto funcionamiento de las comunicaciones existentes entre el módulo y el maestro.

El protocolo escogido se corresponde con el estándar industrial abierto Modbus, desarrollado inicialmente por Schneider Electric para su gamas de PLC Modicon (Modbus = Modicon Bus).

Una descripción de este protocolo se puede encontrar en el apartado 7.4.1.2.1 de la presente documentación, existiendo otra más detallada en el anexo de este proyecto.

10.1.3.1 Definición de la cabecera (modbus.h).


10.1.3.2 Definición de las funciones (modbus.c).

En este bloque se definen todas las funciones, ya sean de ámbito local como global.

Se entiende por funciones de ámbito local aquellas que son privadas al módulo y no resultan accesibles desde fuera de éste, mientras que las globales son accesibles desde cualquier otro módulo





10.1.3.2.1 Función IniModbus.

Esta función se encarga de inicializar todos los componentes (tanto variables como periféricos) necesarios para el correcto funcionamiento del protocolo Modbus.





char IniModBus(unsigned int *DirTabla, unsigned int TamTabla, unsigned int NDatosEscrit,unsigned char DirEsc, unsigned char modo)



DirTabla unsigned int

* Puntero que señala a la tabla de datos compartidos.

TamTabla unsigned Int Tamaño de la tabla de lectura.

NDatosEscrit unsigned int Nº de registros que se desea que tengan permisos de escritura.

DirEsc unsigned char Dirección de esclavo que se desea tener en las comunicaciones Modbus.

modo unsigned char Variable que indica el modo de inicialización de la tabla de datos.



PunteroTablaRX static

unsigned char Puntero que señala a la tabla de recepción de datos.

PunteroTablaTX static

unsigned char Puntero que señala a la tabla de transmisión de datos.

PunteroTablaDatos static

unsigned char Puntero que señala a la tabla de variables compartidas.

PosComienzo Escritura

static unsigned int

Indica el punto de comienzo de los datos con permiso de escritura.

DirEsclavo static

unsigned char Indica la dirección de esclavo Modbus que posee el módulo.

NRxLecMax static

unsigned int Indica el número máximo registros de lectura que hay en la tabla de datos.

NRxEscMax static

unsigned int Indica el número máximo registros de escritura que hay en la tabla de datos.



MBOK char Resultado que devuelve la función con inicialización correcta.

MBErrorDirTabla char Resultado que devuelve la función si la dirección de la tabla es ilegal.

MBerrorTamTabla char Resultado que devuelve la función si el tamaño de la tabla es imposible.

ErrorMemLlena char Resultado que devuelve la función si no tiene espacio en el Heap para crear las tablas.






resultado char Devuelve un char que indica el resultado de la inicialización.




10.1.3.2.2 Función NuevosDatos.

Función encargada de comprobar si hay datos de escritura pendientes de actualizar en la tabla de variables. En caso afirmativo, actualiza los valores de la tabla de variables compartidas.





char NuevosDatos(unsigned int *Tabla);



Tabla unsigned int* Puntero que señala a la tabla donde almacenar los nuevos datos.



PunteroTablaRX static

unsigned char Puntero que señala a la tabla de recepción de datos.

FlagNuevosDatos static

unsigned char Flag que pone a 1 su último bit cuando hay datos de escritura pendientes de procesar.


Nombre Tipo Descripción i unsigned int Variable de índice usada en los bucles for.

DirTabla unsigned

char * Puntero que se usa para recorrer todos los bytes de la tabla.

DirTemp unsigned int Variable auxiliar que indica la posición del primer dato a almacenar.

NDatoTemp unsigned int Variable auxiliar que indica el número de elementos a almacenar.



MBOK char Resultado que devuelve la función si han llegado nuevos datos.

MBError char Resultado que devuelve la función si no han llegado nuevos datos.



resultado char Devuelve MBOK si han llegado nuevos datos y MBError si no es así.




10.1.3.2.3 Función Sobretiempo.

Función que programa un Timeout de un tiempo expresado en microsegundos. Cuando se produzca el sobretiempo se produce una interrupción del timer.


static void Sobretiempo (unsigned int tiempo)



tiempo unsigned int Tiempo de timeout que se desea programar, expresado en microsegundos.




10.1.3.2.4 Función CRC16.

Función que calcula el CRC de una tabla mediante el algoritmo CRC16-CITT (que es el usado por Modbus), almacenando el resultado en una variable de 16 bits, con la parte alta y baja intercambiadas.


static unsigned int CRC16( unsigned char * pucFrame, unsigned int Longitud)






pucFrame unsigned

char * Puntero que señala al primer elemento de la tabla a la que hay que calcularle el CRC.

Longitud unsigned int Longitud de la tabla a la que hay que calcularle el CRC.



ucCRCHi unsigned

char Variable que almacena la parte baja del CRC que se está calculando.

ucCRCLo unsigned

char Variable que almacena la parte alta del CRC que se está calculando.

iIndex int Variable de índice para recorrer la tabla.



aucCRCHi static const

unsigned char Tabla de constantes con resultados intermedios necesarios para el algoritmo rápido del cálculo de CRC.

aucCRCLo static const

unsigned char Tabla de constantes con resultados intermedios necesarios para el algoritmo rápido del cálculo de CRC.



resultado static

unsigned int CRC calculado de la tabla, con la parte alta y baja intercambiadas.




10.1.3.2.5 Función IniTimerA.

Esta función inicializa el timer A en modo de cuenta ascendente con un reloj de 1µs.


static void IniTIMERA(void);




10.1.3.2.6 Función IniUART.

Inicializa el periférico de comunicaciones serie a una velocidad de 38400 bps, con paridad par y un bit de stop.


static void IniUART(void);




10.1.3.2.7 Función AnalizarDatos.

Se encarga de interpretar el mensaje que acaba de llegar, preparando también la respuesta.

AnalizarDatos

Fin

¿CRC

correcto?

¿Orden = 3?

¿Orden = 6?

¿Orden = 16?

Transmitir

mensaje orden

incorrecta

¿Formato

trama

Correcta?

¿Dir dentro de

rango?

Transmitir

mensaje de

lectura con los

datos

Tranmitir mensaje

dirección

incorrecta

¿Formato

trama

Correcta?

¿Dir dentro de

rango?

Transmitir

mensaje de

Escritura OK

Tranmitir mensaje

dirección

incorrecta

¿Formato

trama

Correcta?

¿Dir dentro de

rango?

Transmitir

mensaje de

Escritura OK

Tranmitir mensaje

dirección

incorrecta

Si

No

Si

No

Si

No

Si

No

Si

No

Si

No

Si

No

Si

No

Si

No

Si

No

¿Orden = 2?

¿Formato

trama

Correcta?

¿Dir dentro de

rango?

Transmitir

mensaje con los

bits solicitados

Tranmitir mensaje

dirección

incorrecta

Si

No

Si

No

Si

No

UART en Modo

recepción de

direccón

Se señala que no

hay datos

pendienes en

ModBus





static void AnalizarDatos(void)



PunteroTablaRX static unsigned

char Puntero que señala a la tabla de recepción de datos.

PunteroTablaTX static unsigned

char Puntero que señala a la tabla de transmisión de datos.

DirEsclavo static unsigned

char Indica la dirección de esclavo Modbus que posee el módulo.

NRx static unsigned

int Variable que indica el número de bytes recibidos.

NTx static unsigned

int Variable que indica el número de bytes que quedan por transmitir

PunteroTablaDatos static unsigned

char Puntero que señala a la tabla de variables compartidas.

PosComienzoEscritura static unsigned

int Indica el punto de comienzo de los datos con permiso de escritura.

NRxLecMax static unsigned

int Indica el número máximo registros de lectura que hay en la tabla de datos.

NRxEscMax static unsigned

int Indica el número máximo registros de escritura que hay en la tabla de datos.

BusyModBus static unsigned

char

Variable usada para señalar cuando hay datos Modbus pendientes de enviar o recibir. Si vale 0 indica que no hay datos pendientes.



IndiceTemp unsigned int Variable usada para recorrer la tabla de datos en la lectura de bits

j unsigned char Variable usada para apuntar a los distintos bits de la tabla en la orden tipo 2.

CRCDato unsigned int Resultado auxiliar que almacena el CRC calculado.

DirTemp unsigned int Variable auxiliar que indica la posición del primer dato.

NDatoTemp unsigned int Variable auxiliar que indica el número de elementos a tratar.

i unsigned int Variable auxiliar usada para recorrer los bucles for.




10.1.3.2.8 Función Error.

Esta función es auxiliar de AnalizarDatos y se encarga de poner el mensaje de error que solicite dicha función en la tabla de transmisión.


static void Error(unsigned char tipo)


Nombre Tipo Descripción tipo unsigned char Código que indica el tipo de error Modbus.








10.1.3.2.9 Función AddCRC.

Función auxiliar de AnalizarDatos y Error. Se encarga de poner el nuevo CRC calculado al final de la tabla de transmisión.


void AddCRC(unsigned int pos)



pos unsigned int Variable que indica la posición en la que comenzar a escribir el CRC.






Nombre Tipo Descripción CRCDato unsigned int Resultado auxiliar que almacena el CRC calculado.




10.1.3.2.10 Función TestModBusFree.

Esta función se encarga de comprobar si hay operaciones pendientes de procesar por Modbus o no. En caso de que haya funciones pendientes devuelve un código de error, en caso de no haberlas devuelve el código MBOK.

Se puede programar con acceso bloqueante, es decir, se quedará esta tarea dormida hasta que no haya operaciones Modbus pendientes de procesar.


char TestModBusFree(unsigned char modo)






modo unsigned

char

Indica el modo de acceso a la función. Con 0 el acceso es bloqueante mientras que con distinto de 0 es no bloqueante.



BusyModBus unsigned

char

Flag de estado de Modbus que indica si hay operaciones Modbus pendientes. Si es 0 indica que no hay operaciones pendientes.



MBOK char Resultado que devuelve la función si no hay operaciones pendientes.

MBERROR char Resultado que devuelve la función si hay operaciones pendientes.



Resultado char Código que devuelve la función. Devuelve MBERROR si hay operaciones Modbus pendientes y MBOK si no hay operaciones pendientes.




10.1.3.2.11 Función IntTimer.




Es el manejador de la función de interrupción del timer. Cuando salta es porque se ha cumplido los sobretiempos exigidos entre las distintas tramas Modbus a transmitir o recibir.


__interrupt void IntTimer( void )



NRx static unsigned


NTx static unsigned

int Variable que indica el número de bytes que quedan por transmitir.




char





10.1.3.2.12 Función IntUARTRx.

Es el manejador de la función de interrupción de la UART en recepción. Inicialmente está pendiente a que llegue una nueva dirección válida, tras lo cual almacena todos los bytes que le lleguen en la tabla de recepción.

IntUARTRx

¿NRx=0?¿Dirección

correcta?

UART modo

Recep datos

Inic sobretiempo

en 3,5*Twake

NRx=1

Reiniciar

sobretiempo

Dato recibido

TablaRx[0]

¿NRx>RxMax?

Dato recibido

TablaRx[NRx]

Incrementar NRx

Fin

Si

No Si

No

Si

No

Se señala que hay

datos ModBus

pendientes


__interrupt void IntUARTRx (void)






PunteroTablaRX static unsigned

char Puntero que señala a la tabla de recepción de datos.

NRx static unsigned


NRxLecMax static unsigned

int Indica el número máximo registros de lectura que hay en la tabla de datos.


char





10.1.3.2.13 Función IntUARTTx.

Es el manejador de la función de interrupción de la UART en Transmisión y se encarga de enviar la trama completa de respuesta.


__interrupt void IntUARTTx (void)





NTx static unsigned

int Variable que indica el número de bytes que quedan por transmitir




10.1.4 Módulo Flash.

En este módulo es donde están definidas las funciones de acceso a la memoria flash del µC.

10.1.4.1 Definición de la cabecera (Flash.h).


10.1.4.2 Definición de las funciones (Flash.c).

En este bloque se define el código de todas las funciones que forman el módulo de control de flash que se ha diseñado.





10.1.4.2.1 Función Flash2float.

Esta función accede a la dirección de flash que se le pase como parámetro y lee los bytes siguientes hasta completar el float que devuelve como respuesta

Flash2Float

Fin

¿Quedan

bytes por leer del

float?

Si

No

Se copia byte señalado

de la flash al float del

resultado

Se apunta al siguente

byte de la tabla


float Flash2float(unsigned char *direccion);



direccion unsigned

char * Puntero que señala a la posición de flash donde comienza el float que se desea leer.



i unisgned

char Variable auxiliar usada como índice en los bucles for.

dirResultado unisgned

char * Puntero que señala a la variable resultado y permite leer uno a uno los bytes que componen dicha variable.



Resultado float Variable que almacena el float leído de flash y que devolverá como resultado la función.




10.1.4.2.2 Función Flash2TablaFloat.

Esta función accede a la dirección de flash que se le pase como parámetro y lee los bytes siguientes hasta completar la tabla de float del tamaño solicitado. El resultado lo almacena en la tabla a la que apunta el puntero que se le pasa como dato.


void Flash2TablaFloat(float *Datos, unsigned char Ndatos, unsigned char *direccion)



Datos float * Puntero que señala a la tabla donde se desea almacenar el resultado.

Ndatos unsigned

char Número de bytes que contiene una tabla de float que se desea leer.

direccion unisgned

char * Puntero que señala a la posición de flash donde comienza la tabla de float que se desea leer.



i unisgned

char Variable auxiliar usada como índice en los bucles for.




10.1.4.2.3 Función EraseFlash.

Esta función borra el segmento de la memoria flash cuya dirección se le pasa como parámetro.


void EraseFlash(unsigned char* direccion)



direccion unisgned

char * Dirección que apunta al segmento de flash que se desea borrar.




10.1.4.2.4 Función WriteFlash.

Esta función escribe la tabla de variables que se le pasa como parámetro en el bloque de flash cuya dirección se le indique con el puntero pasado como parámetro. Devuelve Ok o un código de anomalía si la operación es ilegal.


char WriteFlash(void *datos, unsigned char tamdato, unsigned char Ndatos, unsigned char *PunteroFLASH)






datos void * Puntero que señala a la tabla con los datos a escribir en flash.

tamdato unisgned

char Tamaño de cada uno de los datos de la tabla.

Ndatos unisgned

char Número de elementos que compone la tabla a escribir en flash.

PunteroFLASH unisgned

char * Puntero que señala a la tabla de datos y permite recorrerla byte a byte.



i unsigned

char Variable auxiliar utilizada para recorrer los bucles for.

PunteroDatos unsigned

char * Puntero que apunta a la tabla de datos y permite leer la información byte a byte.

NBytes unsigned

char Variable que almacena el número total de bytes que hay en la tabla a escribir en flash.



FlashOK char Resultado que devuelve la función tras completar con éxito la escritura.

FlashERROR char Resultado que devuelve la función si se ha tratado de escribir más bytes de los que caben en un segmento.



resultado char

Variable que almacena un código indicando si se ha realizado la escritura. Devuelve FlashOK en caso satisfactorio y FlashERROR si no se ha realizado la escritura.




10.2 Explicación del software de SCADA.

En el documento 4 del presente proyecto se documenta una explicación del software SCADA de monitorización desarrollado.

11 ESPECIFICACIONES BÁSICAS DEL PROYECTO.

Resumiendo todo lo anterior y a partir de las pruebas realizadas por el prototipo, se puede concluir que se ha desarrollado un dispositivo que cumple con las siguientes especificaciones:

11.1 Características mecánicas.

El dispositivo presenta unas dimensiones finales de 61,6x55,6x14,6mm, lo que teniendo en cuenta que el hueco que queda en el cajillo de un enchufe es 63x63x16mm, se demuestra que se puede empotrar en dicho receptáculo, quedando totalmente disimulado en la instalación final.

11.2 Características eléctricas.

El sistema está diseñado para un funcionamiento a una tensión de 110 a 240VRMS y una frecuencia de 50 o 60Hz.

Presenta una capacidad de corte de una corriente eficaz máxima de 16ARMS y una corriente de pico de 25ARMS, pudiendo realizar mediciones de hasta 21,213ARMS, si se prescinde de la actuación sobre la carga.

11.3 Indicadores de Funcionamiento.

El sistema desarrollado posee un led que indica el funcionamiento, pudiendo mostrar uno de los siguientes estados.

Estado del Led Descripción

Led apagado El sistema o no está alimentado o no ha inicializado correctamente.

Led parpadeando 2 vez por segundo

El dispositivo se encuentra en un modo de funcionamiento normal.

Led encendido de manera constante

El sistema ha iniciado y se encuentra en funcionamiento, pero se ha producido un error. El error concreto se puede leer y borrar mediante la lectura por Modbus de la palabra de estado del dispositivo.




11.4 Características funcionales.

El sistema es capaz de realizar las medidas que se describen en la siguiente tabla:

Magnitud Precisión

Energía Desde 0.00 hasta 42949672,96 kWh con una precisión de ±0,01kWh.

Temperatura Desde -40,00ºC hasta 80,00ºC con una precisión de ±0,01ºC. Vrms Desde 10,00V hasta 288,92V con una precisión de ±10mV. Irms Desde 0,010A hasta 21,213A con una precisión de ±1mA. V media Desde 0,00V hasta 327,68V con una precisión de ±10mV. I media Desde 0,000A hasta 30,000A con una precisión de ±1mA. Potencia Activa Desde 2,0W hasta 4879,0W con una precisión de ±0,1W. Potencia Reactiva Desde 0,0VAr hasta 4879,0VAr con una precisión de ±0,1VAr. Potencia Aparente Desde 0,0VA hasta 4879,0VA con una precisión de ±0,1VA. Factor de potencia Desde 0,0000 hasta 1,0000 con una precisión de ±0,0001. Frecuencia Desde 0,50Hz hasta 655,36Hz con una precisión de ±0,01Hz.

El sistema tiene implementado dos límites de corriente programables desde 0,000 hasta 32,000A referentes a la corriente máxima admisible rms y instantánea. Ambas medidas de protección son configurables y se pueden desactivar de manera independiente.

En cuanto a comunicaciones el sistema cumple con el estándar de comunicaciones Modbus RTU a dos hilos, con paridad par y una velocidad de 38400bps.

El sistema permite el control de la carga, de manera on-off de forma remota a través de su bus de comunicaciones, pudiendo cortar una corriente máxima de 16ARMS, con una vida útil estimada de 50000 maniobras.

12 OTRAS OPCIONES DE FUTURO.

Como se ha comentado, este proyecto se ha desarrollado teniendo en cuenta una serie de impedimentos tecnológicos presentados a la hora de realizar el prototipo con los medios disponibles.

Si en un futuro se planteara mandar a fabricar la tarjeta a una empresa especializada, esos impedimentos tecnológicos desaparecen y se abren las posibilidades de mejora que se van a exponer a continuación.




12.1 Mejoras económicas y energéticas.

En cuanto a reducción de costes y de uso energético se plantean varias alternativas.

La más inmediata consiste en la eliminación de la fuente de alimentación de los dispositivos que componen la red distribuida, poniendo en su lugar una sola fuente de alimentación de cabecera que alimentara todos los dispositivos.

La principal ventaja económica de esto es que no hay que comprar un transformador de alta frecuencia por dispositivo, con lo que además se gana espacio físico en la tarjeta de circuito impreso.

Para poder realizar esto, hay que sustituir el par de 2 hilos que actualmente se traza para las comunicaciones, por una manguera con dos pares de hilos, uno para el bus y otro para la alimentación. Debido a que el precio de este cable es económico y la sección del hilo puede ser muy reducida, resulta más económica esta opción que el tener una fuente por dispositivo.

Esta solución, por ejemplo, es la que plantea LonWorks o EIB para sus redes de sensores.

En cuanto al rendimiento mejora, debido que se reducen las pérdidas en el núcleo del transformador, que pasaría a ser solo uno, además de que ya no se tienen tantas limitaciones de espacio para la fuente. Esto unido con que el rendimiento de los transformadores mejora al aumentar la corriente, puede ocasionar que esta opción presente una mejora energética y económica importante a medida que crezca el número de dispositivos que formen la red.

Otra posible mejora económica y energética consiste en la sustitución del relé por un triac, mediante el cual se podría por software no solo controlar el encendido y apagado, sino incluso una regulación de potencia de la carga, gracias a la cual se pueda conseguir un ahorro energético importante.

Esto es especialmente útil si la carga es un motor y para el control de la iluminación. Ahora bien, la sustitución por un relé implica que o se baja considerablemente la potencia máxima admisible en la carga (a unos 100W aproximadamente, potencia habitual de los dimmer para iluminación en el hogar) o es necesario colocar un disipador al triac, lo que implicaría que el diseño final tendría unas dimensiones mayores.




12.2 Mejoras aplicadas al ámbito de la domótica.

Como mejora aplicada al ámbito de la domótica se destaca el sustituir las comunicaciones cableadas por comunicaciones mediante un estándar inalámbrico.

Para el ámbito de aplicación del dispositivo, se considera que la mejor solución, se puede plantear mediante el uso de comunicaciones ZigBee, empleando los transceiver comentados anteriormente, ahora bien, como ya se ha recalcado, no es viable soldar dicho componente a mano, debido a su fragilidad térmica, lo que obliga a mandar a fabricar y soldar el PCB a una empresa especializada.

De cara a realizar una serie de prototipos industriales, el costo de mandar a fabricar la tarjeta es asumible, no siéndolo para la fabricación de un solo dispositivo de prueba como el que se planteaba en el presente proyecto.

Aunque debido a las limitaciones técnicas no se ha podido fabricar un módulo con comunicaciones inalámbricas funcional, en el anexo se incluye una serie de capítulos que resume la información recopilada sobre dicho protocolo, tanto a nivel de comunicaciones como reglas de diseño para la fabricación de las distintas antenas. Todo esto con el objetivo de servir de base en caso de que se quiera desarrollar dicha posibilidad.

El diseño actual se centra en la monitorización de la carga en un enchufe, pero el diseño desarrollado, con muy ligeras modificaciones, es válido para la monitorización y control de cualquier tipo de carga, como pueda ser una lámpara (incluyendo la posibilidad de regulación, como se comentó en el apartado anterior), una línea completa de una casa (tan solo habría que añadir un transformador de corriente, para permitir potencias mayores), etc.

12.3 Mejoras aplicadas a otros ámbitos.

Con ligeras variaciones al proyecto actual, y sobre todo teniendo en cuenta el auge que están tomando a día de hoy las energías renovables, este proyecto es válido para el diseño de una red de sensores útiles para comprobar el funcionamiento de una central fotovoltaica pequeña, como pudiera ser la presente en una vivienda aislada del suministro eléctrico general.

Las modificaciones básicas consistirían en un cambio en las ganancias de los circuitos de adaptación para ajustarlas a dichas aplicaciones, así como prescindir de la fuente de alimentación, puesto que el equipo se podría alimentar directamente a la tensión que suministran estas baterías.




El bajo consumo, pequeño tamaño y bajo coste de los dispositivos desarrollados hacen preveer que su uso para esta aplicación podría resultar idóneo.

13 BIBLIOGRAFÍA.

• “Demystifying Switching Power Supplies” - Raymond A. Mack, Jr - Newnes

• “Power supply cookbook (2º edition) “ - Marty Brown - Newnes

• “Citect SCADA versión 7.0” - User guide

• “Electrónica de Potencia: Circuitos, Dispositivos y Aplicaciones “ - Muhammad H. Rashid – Prentice Hall.

• “Electrónica de potencia 1 y 2” - Transparencias de la asignatura impartida por Leopoldo García Franquelo - Escuela Superior de ingenieros.

• “Sistemas informáticos en tiempo real” - Transparencias de la asignatura impartida por Joaquín ferruz Melero - Escuela Superior de ingenieros.

• “6 W single-output VIPer17 demonstration board” - SGS Thomson application report - AN2753.

• “Demonstration board on 7 W single output based on the VIPer17” - SGS Thomson application report - EVALVIPER17L-7W.

• “Transformerless Power Supply” - Microchip application report - TB008.

• “Transformerless Power Supplies: Resistive and Capacitive” - microchip application report - AN954.

• “MSP430x4xx family” - Texas Instrument user guide - SLAU056H.

• “MSP430 Family Mixed-Signal Microcontroller “ - Texas instrument application report - SLAA024.

• “Low cost Triac Control with MSP430 16-bit microcontroller” - Texas instrument application report - SLAA043A.

• “A Low-Cost Single-Phase Electricity Meter Using theMSP430C11x” - Texas instrument application report - SLAA075.

• “Three-Phase Electronic Watt-Hour Meter Design Using MSP430” - Texas instrument application report - SLAA391




• “Implementing An Electronic Watt-Hour Meter With The MSP430FE42x Devices” - Texas instrument application report - SLAA203B.

• “CRC Implementation With MSP430” - Texas instrument application report - SLAA221.

• “MSP430 Software Coding Techniques” - Texas instrument application report - SLAA294A

• “MSP430 Competitive Benchmarking” - Texas instrument application report - SLAA205B.

• “eZ430-RF2480 Demonstration Kit” - Texas instrument application report - SWRU151A.

• “CC2480 Developer’s Guide” - Texas instrument application report - SWRA176.

• “Folded dipole antenna for CC2400, CC2420, CC2430, CC2431, and CC2480” - Texas instrument application report - SWRA093D.

• “Small Size 2.4 GHz PCB antenna” - Texas instrument application report - SWRA117D.

• “Antenna Selection Guide” - Texas instrument application report - SWRA161.

• “Modbus Protocol Reference Guide” - Modicon application note - PI-MBUS-300.

• “Demystifying Sigma-Delta ADCs” - maxim Application note -1870.

14 ENLACES DE INTERÉS

• Web de Texas Instrument: http://www.ti.com/

• Web de SGS Thomson: http://www.st.com/

• Enciclopedia online wikipedia: http://es.wikipedia.org

• Página oficial de la asociación KNX: http://www.knx.org/

• Página de la asociación lonmarks española: http://www.lonmark.es/

• Página de la organización para la normalización de Lonkworks: http://www.lonmark.org/




• Explicación del protocolo ZigBee: http://www.monografias.com/trabajos61/zigbee-estandar-domotico-inmotica/zigbee-estandar-domotico-inmotica.shtml

• Explicación del protocolo Modbus: http://www.simplymodbus.ca/index.html

• Explicación del funcionamiento de los ADC sigma- delta: http://www.analog.com/Analog_Root/static/techSupport/designTools/interactiveTools/sdtutorial/sdtutorial.html

• Información de Texas sobre ZigBee; http://www.ti.com/corp/docs/landing/cc2480/index.htm, http://focus.ti.com/docs/prod/folders/print/cc2480a1.html, http://focus.ti.com/analog/docs/rfifcomponentshome.tsp?familyId=367&contentType=4&DCMP=RF/IFCOMPONENTS+Other&HQS=Other+OT+lpw

• Fuentes de alimentación sin transformador: http://www.zen22142.zen.co.uk/

15 SOFTWARE UTILIZADO.

o Sistema Operativo: Microsoft Windows XP Profesional.

o Suite de ofimática: Microsoft Office 2007.

o Diagramas de flujo: Microsoft Visio 2007.

o Editor de ecuaciones: Mathtype 6.2.

o Editor de imágenes: Paint.NET 3.36.

o Creador de PDF: PDF creator 0.9.8.

o Paquete de cálculo matemático: MatLab 6.5.

o Software de SCADA: Vijeo Citect 7.0.

o Simulador de Modbus: MOD_RSSIM 7.6

o Programación y depuración del software: IAR Embedded Workbench KickStart 5.20.

o Editor de texto plano: Notepad ++ 5.4.4

o Diseño electrónico: P-CAD 2002 Trial Version.



Código Fuente del

software de µC.

vatimetro.h

1 /*================================================= ===========================*

2 * *

3 * FICHERO....: vatimetro.h *

4 * PROYECTO...: Red de sensores de medida de consumo eléctrico *

5 * AUTORES....: Diego Francisco Larios Marín / Enri que Personal Vázquez *

6 * FECHA......: 18 de Agosto de 2008 *

7 * VERSIÓN:.... 3.110 *

8 * ESTADO.....: Testeado, sin errores detectados *

9 * *

10 * DESCRIPCION: Fichero de cabezera del programa pr incipal *

11 * *

12 *================================================= ===========================*/

13

14 #ifndef _vatimetro_H_

15 #define _vatimetro_H_

16

17

18 /*------------------------------------------------- ---------------------------*

19 * DEFINICIÓN DE LAS CABECERAS A INCLUIR *

20 *------------------------------------------------- ---------------------------*/

21

22 #include <msp430x471x6.h> //Cabecera general del mC

23 #include "Medidas.h" //Cabecera del módulo de medidas

24 #include "ModBus.h" //Cabecera del módulo com. modbus

25 #include "Flash.h" //Cabecera del módulo com. modbus

26

27

28 /*------------------------------------------------- ---------------------------*

29 * DEFINICIÓN DE ETIQUETAS Y MACROS GLOBALE S DEL MÓDULO *

30 *------------------------------------------------- ---------------------------*/

31

32 // ETIQUETAS GENERALES

33 #define OK (1) //Resultado correcto

34 #define ERROR (-1) //Resultado erroneo

35

36 // ETIQUETAS DEL ADC16

37 #define NCAP (3906) //Número de capturas en un ciclo

38 #define OSR_FILTRO (SD16OSR_256) //Sobremuestreo del ADC16

39 #define TiempoMuestreo (999.936e-3) //Tiempo de muestreo del ADC16

40

41 //ETIQUETAS DE LAS MEDIDAS

42 #define NSegFrec (60) //Nº seg uados para medida de Frec

43

44 //ETIQUETAS DE LA CONFIGURACIÓN DE MODBUS

45 #define DIRECCION (254) //Dirección esclavo Modbus por defecto

46 #define TAMTABLA (117) //Tamaño de la tabla de var. compartidas

47 #define TAMESCRITURA (6) //Nº registros con permisos de escritura

48 #define TarrranqueDef (15) //Tiempo de arranque por defecto

49

50 //MACROS PARA EL CONTROL DEL RELÉ DE SALIDA

51 #define ReleOn (P1OUT&=(~BIT0)) //Macro para activar el relé de salida

52 #define ReleOff (P1OUT|=BIT0) //Macro para desactiver el relé de salida

53

54

55 /*------------------------------------------------- ---------------------------*

56 * DEFINICIÓN DE VARIABLES GLOBALES DEL MÓD ULO *

57 *------------------------------------------------- ---------------------------*/

-1-

vatimetro.h

58

59 // VARIABLES GENERALES COMPARTIDAS ENTRE FUNCIONES

60 unsigned char FlagCalcula =0; //Flag que avisa cuando hay nuevos datos

a procesar

61 long long DatosCAP[6]={0,0,0,0,0,0}; //Datos capturados a procesar

62 unsigned int DatosFrec [NSegFrec ]={0}; //Tabla que almacena los acumulados de

la medida de frecuencia

63 int VRAW[50]={0}; //Tabla puntos de tensión del ADC

64 int IRAW[50]={0}; //Tabla puntos de corriente del ADC

65 long int IMax =0x7fffffff ; //Máxima corriente instantánea permitida

66 int OffsetCAD [4]; //Tabla que almacena los Offset de los ADC

67

68 //VARIABLES COMPARTIDAS POR MODBUS

69 unsigned int TablaDatos [TAMTABLA]={0}; //Tabla de variables compartidas por

modbus

70

71 //FACTORES DE ESCALA DE LAS MEDIDAS

72 float escalaV =1.246986297e -2; //(0.6*69)/(2^15-1)

73 float escalaI =2.288888211e -4; //(0.6)/(16*10*2^15-1)

74 float escalaRI =3.896373057 ;

75 float escalaTemp =(1.0 /1.32 );

76 float escalaPActiva ; //(escalaV)*(escalaI)

77

78

79 /*------------------------------------------------- ---------------------------*

80 * PROTOTIPOS DE LAS FUNCIONES GLOBALES DEL MÓDULO *

81 *------------------------------------------------- ---------------------------*/

82

83 //FUNCIONES DE INICIALIZACIÓN DE PERIFÉRICOS

84 void Inicia (void ); //Función de inicialización de los

periféricos

85 void inicia_cad (void ); //Función auxiliar de inicialización del

ADC16

86 void IniFlash (void ); //Función auxliar que inicia los

parámetros almacenados en Flash

87

88 //FUNCIONES DE ACCESO A SECCIONES CRÍTICAS

89 void SeccionCriticaINT (unsigned int dato ,unsigned int *Tabla );

90 void SeccionCriticaLINT (unsigned long int dato ,unsigned int *Tabla );

91 void SeccionCriticaTablaINT (int *dato ,unsigned char longitud ,unsigned int *Tabla );

92

93 //OTRAS FUNCIONES DEL MÓDULO

94 void ControlFlash (void ); //Función que mira si ha llegdo una

nueva orden que implica escribir en Flash

95 char ControlEnergia (unsigned int *TablaD , unsigned int *TablaE , long float *Eant );

//Funcion que mira si hay nuevo dato de energia

96

97 //Fin de la cabecera vatimetro

98 #endif

99

-2-

main.c

1 /*================================================= ===========================*

2 * *

3 * FICHERO....: main.h *




7 * VERSIÓN:.... 3.110 *


9 * *

10 * DESCRIPCION: Programa principal, en él se define n las rutinas de captura *

11 * del ADC y el proceso de más bajo nivel que es el encargado de *

12 * procesar las medidas. *

13 * *

14 *================================================= ===========================*/

15

16

17 /*------------------------------------------------- ---------------------------*


19 *------------------------------------------------- ---------------------------*/

20

21 #include "vatimetro.h" //Cabecera del módulo principal

22

23

24 /*------------------------------------------------- ---------------------------*

25 * CÓDIGO DE LAS FUNCIONES GLOBALES DEL MÓD ULO *

26 *------------------------------------------------- ---------------------------*/

27

28

29 /*================================================= ===========================*

30 * Comienzo de la función main() *

31 * *

32 * Programa principal, se encarga de inicializar to dos los periféricos y del *

33 * tratamiento de los datos capturados. es un bucle que se está siempre *

34 * ejecutándose y se corresponde con el proceso de menor prioridad. *

35 *================================================= ===========================*/

36

37 int main (void )

38 {

39 //Variables locales de la función

40 float ValorMedido = 0; //Almacenna el resultado calculado de

las medidas

41 float Vrms = 0; //Almacena la tensión eficaz calculada

42 float Irms = 0; //Almacena la corriente eficaz calculada

43 float PActiva = 0; //Almacena la Potencia activa calculada

44 float PAparente = 0; //Almacena la Potencia aparente

calculada

45 long float Energia = 0; //Almacena la energía calculada

46 int Arranque = TarrranqueDef ;//Tiempo de arranque

47 unsigned int Etemp[2]; //Dato temporal de energía, para ver si

hay dato nuevo

48

49 //Código de la función

50 Inicia (); //iniciar perifricos del uP

51 _EINT(); //Habilitar las int.

globales

52

53 ReleOff ; //Se desactiva el relé de salida

-1-

main.c

54 TablaDatos [0]=0x000E ; //Se fija el estado a arrancando

55 TablaDatos [4]=16000 ; //Se fija el unblal de 16A

56 TablaDatos [5]=32000 ;

57 IMax =(long int )((TablaDatos [5]/(1000.0 *escalaI ))+0.5 ); //Calculo la nueva I maxima

instantánea

58

59 //Bucle infinito del programa principal

60 while(1) //Ejecutar siempre

61 {

62 if(FlagCalcula ==1) //Si hay nuevos datos

63 {

64 if ((TablaDatos [0]&0x00C0)==0) //Si no ha habido errores

65 P3OUT̂ =BIT0 ; //El led parpadea

66

67 ValorMedido =(CaclulaTemp (&DatosCAP[3],escalaTemp ,NCAP)*100.0 )+0.5 ;//Cálculo

temperatura

68 SeccionCriticaINT ((unsigned int )ValorMedido ,&TablaDatos [6]);

69

70 Vrms=CalculaRMS (&DatosCAP[0],escalaV ,NCAP);//Cálculo Vrms

71 if(Vrms<10.0 ) //Si la tensión es muy baja

72 Vrms=0.0 ; //Se fuerza a 0

73 ValorMedido =((Vrms*100.0 )+0.5 );


75

76 ValorMedido =((CalculaMedia (&DatosCAP[4],escalaV ,NCAP)*100.0 )+0.5 );//Cálculo

Vmedia

77 SeccionCriticaINT ((int )ValorMedido ,&TablaDatos [9]);

78

79 Irms =CalculaRMS (&DatosCAP[1],escalaI ,NCAP);//Cálculo Irms

80 if(Irms <0.01 ) //Si la corriente es muy baja

81 Irms =0.0 ; //Se fuerza a 0

82 ValorMedido =((Irms *1000.0 )+0.5 );


84

85 ValorMedido =((CalculaMedia (&DatosCAP[5],escalaI ,NCAP)*1000.0 )+0.5 );//Cálculo

Imedia

86 SeccionCriticaINT ((int )ValorMedido ,&TablaDatos [10]);

87

88 PActiva =CalculaPact (&DatosCAP[2],escalaPActiva ,NCAP);//Cálculo Pactiva

89 if(PActiva <2.0 ) //Si la potencia activa es muy baja

90 PActiva =0.0 ; //Se fuerza a 0

91 ValorMedido =((PActiva *10.0 )+0.5 );


93

94 PAparente =CalculaPapar (Vrms,Irms ); //Cálculo Paparente

95 ValorMedido =((PAparente *10.0 )+0.5 );


97

98 ValorMedido =((CalculaPreact (PActiva ,PAparente )*10.0 )+0.5 );//Cálculo Preactiva


100

101 ValorMedido =((CalculaFDP (PActiva ,PAparente )*1000.0 )+0.5 );//Cálculo Factor de

potencia


103

104 ValorMedido =((CaclulaFrec (DatosFrec ,NSegFrec ,TiempoMuestreo )*100.0 )+0.5 );

//Cálculo Frecuencia

-2-

main.c


106

107 Energia =CalculaEnergia (Energia ,PActiva ,TiempoMuestreo );//Cálculo Energia en kWh

108 ValorMedido =(Energia *100.0 /3600000.0 )+0.5 ;

109 SeccionCriticaLINT ((unsigned long int )ValorMedido ,&TablaDatos [2]);

110

111 SeccionCriticaTablaINT (VRAW,50,&TablaDatos [16]);//Almacenar puntos de V en

tabla compartida

112 SeccionCriticaTablaINT (IRAW,50,&TablaDatos [66]);//Almacenar puntos de I en

tabla compartida

113

114 FlagCalcula =0; //Todos los datos han sido procesados,

borro el flag

115

116 if(Arranque >0) //Si el sistema está arrancando

117 Arranque --; //Decremento cuenta de segundos

118 else if(Arranque ==0) //Si ha terminado el arranque

119 {

120 if((TablaDatos [0]&0x0002 )!=0) //Si el bit de arranque aún está a 1

121 {

122 ReleOn ; //Activo el relé

123 TablaDatos [0]&=(~0x0002 ); //Borro el bit de arranque

124 TablaDatos [0]|=0x0001 ; //Activo el bit de relé On

125 }

126 Arranque =(char )-1; //Pongo arranque a un valor inválido de

cuenta

127 }

128 }

129

130 if ((TablaDatos [0]&0x00C0)!=0) //Si se ha producido algun error

131 P3OUT|=BIT0 ; //Enciendo el Led de forma permanente

132

133 Etemp[0]=TablaDatos [2];

134 Etemp[1]=TablaDatos [3];

135 if(NuevosDatos (TablaDatos )==MBOK) //Si han llegado nuevos datos por modbus

136 {

137 IMax =(long int )(((float )TablaDatos [5]/(1000.0 *escalaI ))+0.5 ); //Calculo la

nueva I maxima instantánea

138

139 if((TablaDatos [0]&0x0001 )!=0) //Si el mensaje indica relé activado

140 {

141 TablaDatos [0]&=0xFFCF; //Borro Flags de sobrecorriente

142 ReleOn ; //Activo el relé

143 }

144 else //En caso contrario

145 ReleOff ; //Lo desactivo

146 ControlFlash (); //Comprobación de si hay orden de

control de Flash

147 ControlEnergia (&TablaDatos [2], Etemp, &Energia );//Comprobacion de si hay que

actualizar la energia

148 }

149

150 if(((TablaDatos [0]&0x0004 )!=0)&&(TablaDatos [8]>TablaDatos [4]))//Si Irms es mayor

que el umbral

151 {

152 ReleOff ; //Desconecto el rele

153 TablaDatos [0]|=0x0010 ; //pongo el Flat de superada Irms

-3-

main.c

154 TablaDatos [0]&=(~0x0001 ); //Y borro el bit de Rele On

155 }

156 LPM3; //Al no tener nada que hacer, duermo el uC

157 }

158 }

159 //Fin de la función main()

160

161

162 /*================================================= ===========================*

163 * Comienzo de la función Inicia() *

164 * *

165 * Se encarga de inicializar los periféricos, los p uertos de E/S y de *

166 * arrancar las comunicaciones modbus. *

167 *================================================= ===========================*/

168

169 void Inicia (void )

170 {


172 int i =0; //Variable auxiliar para recorrer las

tablas

173 unsigned char *Pdireccion =Flash2 ; //puntero para acceder al ID Modbus de

Flash

174


176 P1DIR|=1; //Se configuran los puertos de salida

177 P3DIR|=1;

178 P1OUT&=(~BIT0 ); //y se fuerzan las salidas a 0

179 P3OUT&=(~BIT0 );

180

181 P2DIR=0; //Se conigura el puerto XX como de entrada

182 P4DIR=P5DIR=P7DIR=P8DIR=P9DIR=P10DIR=0xFF;//Todos los demás se ponen como salidas

para bajar consumo

183

184 WDTCTL= WDTPW+WDTCNTCL+WDTSSEL; //Refresco el perro guardián

185

186 //Inicialización de los relojes de forma segura, ta l y como recomienda TI

187 SCFQCTL=1; //Registros de configuración de los

relojes

188 FLL_CTL0=XTS_FLL;

189 FLL_CTL1=XT2OFF+FLL_DIV_8 ; //ACLK = MCLK = 8MHz

190 SCFI0=FN_3;

191 SCFI1=0;

192 do

193 {

194 IFG1 &= ~OFIFG; //Borra OSCFault flag

195 for (i = 0xFF; i > 0; i --); //Esperamos un ratito

196 }

197 while ((IFG1 & OFIFG) == OFIFG); //OSCFault flag esta a 1

?

198 FLL_CTL1|=SELM_A; //cofiguro el MCL para el XTAL1 de

Forma segura

199


201 inicia_cad (); //Se inica en conversor ADC16

202


204 IniFlash (); //Se inician las escalas calibradas y el

-4-

main.c

ID Modbus

205


207 IniModBus (TablaDatos ,TAMTABLA,TAMESCRITURA,*Pdireccion ,0);//Se inicia el protocolo

Modbus

208

209 //SD16CCTL3 |= SD16SC; //Se inic ia la captura


211

212 }

213 //Fin de la función Inicia()

214

215

216 /*================================================= ===========================*

217 * Comienzo de la función inicia_cad() *

218 * *

219 * Función auxiliar encargada de configurar el conv ersor ADC de 16 Bits, así *

220 * como inicializar todas las variables asociadas. *

221 *================================================= ===========================*/

222

223 void inicia_cad (void )

224 {


226 unsigned int i ; //Variable auxiliar para recorrer las

tablas

227


229 SD16CTL = SD16REFON+SD16DIV_3+SD16SSEL_2+SD16IE;//Se pone un reloj de 1MHz para el

ADC y se activa la referencia

230

231 SD16INCTL0 = SD16GAIN_1+SD16INCH_0; //Se configuran las entradas y

232 SD16INCTL1 = SD16GAIN_4+SD16INCH_0; //la ganancia de los canales

233 SD16INCTL2 = SD16GAIN_16+SD16INCH_0;

234 SD16INCTL3 = SD16GAIN_1+SD16INCH_6;

235

236 SD16CCTL0 = OSR_FILTRO+SD16DF+SD16GRP; //Se configuran los canales para las

medidas

237 SD16CCTL1 = OSR_FILTRO+SD16DF+SD16GRP; //Configuradas en modo contínuo

238 SD16CCTL2 = OSR_FILTRO+SD16DF+SD16GRP; //Se agrupan los canales de medida hasta

el 3.

239 SD16CCTL3 = OSR_FILTRO+SD16DF+SD16IE;

240

241 for(i =1;i <1000;i ++) //Se espera a que se estabilize Vref

242 WDTCTL= WDTPW+WDTCNTCL+WDTSSEL; //Se refresca el watchdog

243

244 SD16CCTL3 |= SD16SC; //Se inicia la captura

245 }

246 //Fin de la función Inicia_CAD()

247

248

249 /*================================================= ===========================*

250 * Comienzo de la función IniFlash() *

251 * *

252 * Se encarda de cargar en memoria e inicializar la flash con los *

253 * correspondientes valores necesarios para calibra r los resultados de las *

254 * medidas y para definir el ID de ModBus. *

255 *================================================= ===========================*/

-5-

main.c

256

257 void IniFlash (void )

258 {


260 unsigned int i ; //Variable auxiliar para recorrer los

bucles

261 unsigned int resul =0xFF; //Dato para comprobar si la Flash está

vacía

262 unsigned char *PunteroFLASH = Flash1 ; //Señala al primer bloque de Flash

263 unsigned char ID_Defecto =DIRECCION; //Dirección por defecto de modbus

264 float Tdatos [8]; //Tabla para contener los datos de inic.

de Flash

265


267 for(i =0;i <64;i ++) //Se recorre todo el bloque de Flash

268 resul &=PunteroFLASH [i ]; //para comprobar si está vacía

269

270 if((resul ==0xFF)||((P2IN&BIT0 )!=0)) //Si Flash vacía o pulsado botón ajustes

por defecto

271 {

272 _DINT(); //Se quitan las interrupciones

273 WDTCTL= WDTPW+ WDTHOLD; //Se para el Watchdog

274

275 for(i =0;i <0xFFFF;i ++); //Se espera un ratito

276 while((P2IN&BIT0 )!=0); //Se espera a que se suelte el bótón

ajustes def.

277

278 Tdatos [0]=escalaV ; //Se prepara la tabla de valores por

defecto

279 Tdatos [2]=escalaRI ;

280 Tdatos [4]=escalaI ;

281 Tdatos [6]=escalaTemp ;

282 Tdatos [1]=Tdatos [3]=Tdatos [5]=Tdatos [7]=0;

283

284 WriteFlash (Tdatos , sizeof(float ), 8, Flash1 );//Se programan estos valores en Flash

285 WriteFlash (&ID_Defecto , 1, 1, Flash2 ); //Se programa el ID ModBus por defecto

286 WDTCTL=0x00 ; //Reseteo el micro

287 }

288 else //Si la flash tiene datos y no se pulsa

boton ajustes por defecto

289 {

290 escalaV =Flash2float (&PunteroFLASH [0]); //Se cargan los valores calibrados de

las escalas y offset

291 escalaRI =Flash2float (&PunteroFLASH [8]);

292 escalaI =Flash2float (&PunteroFLASH [16]);

293 escalaTemp =Flash2float (&PunteroFLASH [24]);

294 for(i =0;i <4;i ++)

295 OffsetCAD [i ]=(int )(Flash2float (&PunteroFLASH [(i *8)+4]));

296 escalaPActiva =escalaV *escalaI ; //La escala de potencia es el producto

de la de V por la de I

297 }

298 }

299 //Fin de la función IniFlash()

300

301

302 /*================================================= ===========================*

303 * Comienzo de la función SeccionCriticaINT() *

-6-

main.c

304 * *

305 * Rutina que se encarga de deshabilitar las interr upciones globales mientras *

306 * que almacena el dato entero en la tabla comparti da *

307 *================================================= ===========================*/

308

309 void SeccionCriticaINT (unsigned int dato ,unsigned int *Tabla )

310 {


312 _DINT(); //Se deshabilitan las interrupciones

313 *Tabla = dato ; //Se alacena el dato

314 _EINT(); //Se habilitan las interrupciones

315 }

316 //Fin de la función SeccionCriticaINT()

317

318

319 /*================================================= ===========================*

320 * Comienzo de la función SeccionCriticaLINT() *

321 * *


323 * que almacena el dato Long int en la tabla compar tida *

324 *================================================= ===========================*/

325

326 void SeccionCriticaLINT (unsigned long int dato ,unsigned int *Tabla )

327 {


329 unsigned int *Pdato ; //Puntero para leer el dato en forma de

2 enteros

330


332 Pdato = (unsigned int *) &dato ; //Asignación de la dirección del dato al

punero

333


335 Tabla [0] = Pdato [1]; //Se almacena el dato en la tabla

compartida

336 Tabla [1] = Pdato [0];


338 }

339 //Fin de la función SeccionCriticaLINT()

340

341

342 /*================================================= ===========================*

343 * Comienzo de la función SeccionCriticaTablaINT() *

344 * *


346 * que almacena la tabla de enteros en la tabla com partida *

347 *================================================= ===========================*/

348

349 void SeccionCriticaTablaINT (int *dato ,unsigned char longitud ,unsigned int *Tabla )

350 {


352 unsigned char i ; //Variable auxiliar apra recorrer las

tablas

353



356 for(i =0;i <longitud ;i ++) //Se almacenan todos los datos

-7-

main.c

357 Tabla [i ]=dato [i ]; //en la tabla de variables compartidas


359 }

360 //Fin de la función SeccionCriticaTablaINT()

361

362

363 /*================================================= ===========================*

364 * Comienzo de la función ControlFlash() *

365 * *

366 * Esta funciuón se encarga de calibrar las escalas y los offset de los *

367 * canales de medida cuando le llegue la correspond iente orden por modbus. *

368 * También programa el nuevo ID Modbus si llega la orden correspondiente. *

369 *================================================= ===========================*/

370

371 void ControlFlash (void )

372 {


374 unsigned int indice ; //Variable que almacena el código de la

orden

375 float NuevaEscala ; //Variable para calcular la nueva

calibración

376 float Tdatos [8]; //Tabla que almacena los datos antiguos

de Flash

377 unsigned char Nuevo_ID ; //Almacena el nuevo ID de ModBus

378


380 if((TablaDatos [0]&0xFF00 )!=0) //Si hay nueva orden de calibración

381 {

382 while(TestModBusFree (0)!=MBOK); //Espero a que el ModBus acabe de

transmitir


384 ReleOff ; //Se desconecta la carga

385

386 Flash2TablaFloat (Tdatos ,sizeof(Tdatos ),Flash1 );//Se guarda la tabla de Flash en

RAM

387 indice =(unsigned int )((TablaDatos [0]&0xFF00 )>>8);//Se calcula el Numero de orden

recibida

388

389 if(indice ==0x01 ) //Si la orden es calibrar Offset de V

390 {

391 NuevaEscala =((int )TablaDatos [9]-(int )TablaDatos [1])/(escalaV *100.0 );//Se

calcula el nuevo offset

392 Tdatos [1]+=NuevaEscala ; //Y se almacena en la tabla

393 }

394 else if(indice ==0x02 ) //Si la orden es calibrar ganancia de V

395 {

396 NuevaEscala =(float )TablaDatos [1]/(float )TablaDatos [7];//Se calcula la nueva

ganancia

397 Tdatos [0]*=NuevaEscala ; //Y se almacena en la tabla

398 }

399 else if(indice ==0x04 ) //Si la orden es calibrar Offset de I alta

400 {

401 NuevaEscala =((int )TablaDatos [10]-(int )TablaDatos [1])/(escalaRI *escalaI *1000.0 );

//Se calcula el nuevo offset


403 }

404 else if(indice ==0x08 ) //Si la orden es calibrar ganancia de I

-8-

main.c

alta

405 {


ganancia

407 Tdatos [2]*=(NuevaEscala /escalaI ); //Y se almacena en la tabla

408 }

409 else if(indice ==0x10 ) //Si la orden es calibrar Offset de I baja

410 {

411 NuevaEscala =((int )TablaDatos [10]-(int )TablaDatos [1])/(escalaI *1000.0 );//Se



413 }

414 else if(indice ==0x20 ) //Si la orden es calibrar ganancia de I

baja

415 {


ganancia


418 }

419 else if(indice ==0x40 ) //Si la orden es calibrar Offset de

Temperatura

420 {

421 NuevaEscala =((int )TablaDatos [6]-(int )TablaDatos [1])/(escalaTemp *100.0 );//Se



423 }

424 else if(indice ==0x80 ) //Si la orden es calibrar ganancia de

Temperatura

425 {


ganancia


428 }

429 else if(indice ==0xFF) //Si la orden es para cambiar el ID ModBus

430 {

431 if((TablaDatos [1]>0) &&(TablaDatos [1]<255))//Si el ID está dentro de rango

432 {

433 Nuevo_ID =(unsigned char )TablaDatos [1];//Se graba el nuevo ID en FLASH

434 WriteFlash (&Nuevo_ID , 1, 1, Flash2 );

435 }

436 }

437 else //Si la orden no es ninguna de las

permitidas

438 WDTCTL=0x00 ; //no se hacen cambios y se resetea el

micro

439

440 WriteFlash (Tdatos , sizeof(float ), 8, Flash1 );//Si ha habido cambios, se

almacenan los datos en Flash

441 WDTCTL=0x00 ; //Se Resetea el micro

442 }

443 }

444 //Fin de la función ControlFlash()

445

446

447 /*================================================= ===========================*

448 * Comienzo de la función ControlEnergia() *

449 * *

-9-

main.c

450 * Esta funciuón se encarga de comprobar si ha lleg ado un nuevo dato de *

451 * Energía, actualizando en caso afirmativo el regi stro interno. *

452 *================================================= ===========================*/

453

454 char ControlEnergia (unsigned int *TablaD , unsigned int *TablaE ,long float *Eant )

455 {

456 unsigned long int Resultado ;

457 unsigned int *Presul ;

458

459 if((TablaD [0]!=TablaE [0])||(TablaD [1]!=TablaE [1]))//Si hay un nuevo dato de energia;

460 {

461 Presul =(unsigned int *)&Resultado ; //Leo los datos recibidos como enteros

462 Presul [0]=TablaD [1];

463 Presul [1]=TablaD [0];

464 *Eant =(long float )Resultado ;

465 (*Eant )=((*Eant )*3600000.0 )/100.0 ; //Lo escalo de centésimas de kWh a julios.

466 return (char )OK; //Devuelvo modificacion OK

467 }

468 else //Si no hay nuevo dato de energia

469 return (char )ERROR; //Devuelvo modificacion Error

470 }

471 //Fin de la función ControlEnergia()

472

473

474 /*------------------------------------------------- ---------------------------*

475 * CÓDIGO DE LAS RUTINAS DE INTERRUPCIÓN *

476 *------------------------------------------------- ---------------------------*/

477

478

479 /*================================================= ===========================*

480 * Comienzo de la rutina de interrupción del ADC16 *

481 * *

482 * Esta rutina se encarrga de actualizar los valore s acumulados usados para *

483 * el cálculo de las medidas, así como la detección de la máxima corriente *

484 * instantánea. *

485 *================================================= ===========================*/

486

487 #pragma vector=SD16A_VECTOR

488 __interrupt void SD16AISR(void )

489 {


491 static unsigned char FlagFrec =0; //Flag usados para la medida de frecuencia

492 static unsigned int Ftmp=0; //Conteo actual de semiciclos

493 static unsigned char Nseg=0; //Cuenta de segundos para medida de Frec

494 unsigned char i =0; //Variable auxiliar para recorrer las

tablas

495 int segurlectura =0; //Variable para la comprobación de

seguridad

496 static unsigned int Nciclos =0; //Cuenta de ciclos de captura

497 static long long medCAD[6]={0,0,0,0,0,0}; //Acumulado de los valores medidos

498 long int itmp =0, vtmp =0; //Datos auxiliares de medidas

499 static unsigned int ComienzaCap =3800; //Variable para la sincronización de las

gráficas

500


502 WDTCTL= WDTPW+WDTCNTCL+WDTSSEL; //Refresco cíclico del perro guardián

503

-10-

main.c

504 vtmp =(int )(SD16MEM0-OffsetCAD [0]); //Se lee la V instantánea

505 segurlectura =SD16MEM0; //Se almacena el valor medido para la

func de seguridad

506 medCAD[0]+=Cuadrado (vtmp ); //Acumulado del cuadrado de V

instantánea al cuadrado

507

508 if(vtmp >200) //Si se está en semiciclo positivo

509 FlagFrec |=0x01 ; //Se pone un bit de FlagFrec a 1

510 else if(vtmp <-200) //Si se está en semiciclo negativo

511 FlagFrec |=0x02 ; //Se pone otro glag de FlagFrec a 1

512 if((FlagFrec &0x03 )==0x03 ) //Si los 2 flag de FlagFrec están a 1

513 {

514 Ftmp++; //se incrementa la fuenta de semiciclos

515 FlagFrec &=(~0x03 ); //Y se borran los flag

516 if ((Nciclos >3300)&&(vtmp >0)&&(ComienzaCap ==3800))//Si el semiciclo es positivo

y han pasado más de 3300 ciclos

517 ComienzaCap =Nciclos ; //Se comienza la captura de las gráficas

518 }

519

520 if((SD16MEM2==(0x7FFF))||(SD16MEM2==(0x8000 )))//Si el canal 2 está desbordado

521 {

522 itmp =(int )(SD16MEM1-OffsetCAD [1]); //leo la i instantánea del canal de alta

corriente

523 itmp =(long int )(((float )itmp *escalaRI )+0.5 );//Relacion entre ganacias tipicas

15.05/3.86

524 }

525 else //Si el canal 2 no está desbordado

526 itmp =(int )(SD16MEM2-OffsetCAD [2]); //leo I instantánea del canal de baja

corriente

527

528 medCAD[1]+=Cuadrado ((long long )itmp ); //Acumulado del cuadrado de I

instantánea al cuadrado

529

530 if(((TablaDatos [0]&0x0008 )!=0)&&((itmp >IMax )||(itmp <(-1*IMax ))))//Si I instantánea

es mayor que el umbral

531 {

532 ReleOff ; //Se desconecta el relé de la carga

533 TablaDatos [0]|=0x0020 ; //Se activa la alarma de Iinst superada

534 TablaDatos [0]&=(~0x0001 ); //De desactiba bit estado relé

535 }

536

537 medCAD[2]+=(long int )(itmp *vtmp ); //Se calcula la potencia instantánea

538 medCAD[3]+=(int )(SD16MEM3-OffsetCAD [3]); //Acumulado de la temperatura

539 medCAD[4]+=vtmp ; //Acumulado de la V instantánes

540 medCAD[5]+=itmp ; //Acumulado de la I instantánea

541

542 if ((Nciclos >=ComienzaCap )&&(Nciclos <(ComienzaCap +100))&&(Nciclos %2==0))

543 { //Se almacenan los datos para la gráfica

544 VRAW[(Nciclos -ComienzaCap )/2]=SD16MEM0-OffsetCAD [0];

545 IRAW[(Nciclos -ComienzaCap )/2]=SD16MEM1-OffsetCAD [1];

546 }

547

548 Nciclos ++; //Se incrementa NCiclos

549 if (Nciclos >= NCAP) //Si ha pasado 1 segundo

550 {

551 for (i =0;i <6;i ++)

552 {

-11-

main.c

553 DatosCAP[i ]=medCAD[i ]; //Se almacenan los valores acumulados

554 medCAD[i ]=0; //En la tabla compartida con main

555 }

556 Nciclos =0; //Se borra la cuente de Nciclos

557

558 DatosFrec [Nseg]=Ftmp; //Se almacena la cuenta de Frecuencia

559 Ftmp=0;

560 Nseg++; //Se incrementa Nº de segundos

561 if(Nseg>=NSegFrec ) //Si ha pasado 1 minuto

562 Nseg=0; //SE borrra la cuenta de segundos

563

564 if (FlagCalcula !=0) //Si el main aún no ha procesado los

datos

565 TablaDatos [0]|=0x0040 ; //Activo un flag de error

566

567 ComienzaCap =3800; //Se inicializa la variable ComienzaCap

568

569 FlagCalcula =1; //Activo el flag para avisar al main de

que hay nuevos datos

570 LPM3_EXIT; //Salgo del modo de ahorro de energia

571 }

572

573 if (segurlectura !=SD16MEM0) //Si el dato de seguridad no coincide

574 TablaDatos [0]|=0x0080 ; //con la medida del canal, activo un

flag de error

575 }

576 //Fin de la rutina de interrupción ADC16

577

578 //Fin del módulo main

-12-

Medidas.h

1 /*================================================= ===========================*

2 * *

3 * FICHERO....: medidas.h *




7 * VERSIÓN:.... 3.110 *


9 * *

10 * DESCRIPCION: Fichero de cabezera del módulo de m edidas *

11 * *

12 *================================================= ===========================*/

13

14 #ifndef _Medidas_H_

15 #define _Medidas_H_

16

17

18 /*------------------------------------------------- ---------------------------*

19 * DEFINICIÓN DE CABECERAS A INCLUIR *

20 *------------------------------------------------- ---------------------------*/

21

22

23 /*------------------------------------------------- ---------------------------*


25 *------------------------------------------------- ---------------------------*/

26

27 #define Cuadrado(x) ((x)*(x)) //Macro para el cálculo de X^2

28

29

30 /*------------------------------------------------- ---------------------------*


32 *------------------------------------------------- ---------------------------*/

33

34

35 /*------------------------------------------------- ---------------------------*


37 *------------------------------------------------- ---------------------------*/

38

39 //Funciones para el cálculo de las medidas

40 float CalculaRMS (long long *dato ,float escala , unsigned int Nmuestras );

41 float CalculaMedia (long long *dato ,float escala , unsigned int Nmuestras );

42

43 float CalculaPact (long long *dato ,float escala ,unsigned int Nmuestras );

44 float CalculaPapar (float VRMS, float IRMS);

45 float CalculaPreact (float Pact , float Papar );

46 float CalculaFDP (float Pact , float Papar );

47

48 long float CalculaEnergia (long float Eant , float Pact , float tiempo );

49 float CaclulaFrec (unsigned int *Datos ,unsigned char NSeg,float Tiempo1Muestra );

50 float CaclulaTemp (long long *dato ,float escala ,unsigned int Nmuestras );

51

52 //Funciones auxiliares

53 long int round (float dato ); //Función auxiliar de redondeo

54

55 //Fin de la cabecera medidas

56 #endif

-1-

Medidas.c

1 /*================================================= ===========================*

2 * *

3 * FICHERO....: medidas.c *




7 * VERSIÓN:.... 3.110 *


9 * *

10 * DESCRIPCION: Módulo de funciones auxiliares util izadas para el cálculo de *

11 * las medidas a partir de los valores capturados po r el ADC. *

12 * *

13 *================================================= ===========================*/

14

15

16 /*------------------------------------------------- ---------------------------*


18 *------------------------------------------------- ---------------------------*/

19

20 #include "Medidas.h" //Cabecera del módulo de medidas

21 #include <math.h> //Cabecera de funciones matemáticas

22 #include <msp430x471x6.h> //Cabecera genérica del mC

23

24

25 /*------------------------------------------------- ---------------------------*


27 *------------------------------------------------- ---------------------------*/

28

29

30 /*================================================= ===========================*

31 * Comienzo de la función CalculaRMS() *

32 * *

33 * Función que calcula en valor RMS a partir del ac umulado del cuadrado *

34 * de las medidas que se le pasa como parámetro. *

35 *================================================= ===========================*/

36

37 float CalculaRMS (long long *dato ,float escala , unsigned int Nmuestras )

38 {


40 float resultado =0; //Variable que almacena el resultado

41


43 resultado =escala *sqrt ((*dato )/Nmuestras ); //Se aplica la fórmula descrita en la

memoria

44

45 return resultado ; //Se devuelve el resultado

46 }

47 //Fin de la función CalculaRMS()

48

49

50 /*================================================= ===========================*

51 * Comienzo de la función CalculaPact() *

52 * *

53 * Función que calcula la potencia activa a partir de los datos acumulados. *

54 *================================================= ===========================*/

55

56 float CalculaPact (long long *dato ,float escala ,unsigned int Nmuestras )

-1-

Medidas.c

57 {



60


62 resultado =(((*dato )*escala )/Nmuestras ); //Se aplica la fórmula descrita en la

memoria

63


65 }

66 //Fin de la función CalculaPact()

67

68

69 /*================================================= ===========================*

70 * Comienzo de la función CalculaPapar() *

71 * *

72 * Función que calcula la potencia aparente a parti r del valor calculado de *

73 * Vrms y Irms. *

74 *================================================= ===========================*/

75

76 float CalculaPapar (float VRMS, float IRMS)

77 {



80


82 resultado =(VRMS*IRMS); //Se aplica la fórmula descrita en la

memoria

83


85 }

86 //Fin de la función CalculaPapar()

87

88

89 /*================================================= ===========================*

90 * Comienzo de la función CalculaPreact() *

91 * *

92 * Función que calcula la potencia reactiva a parti r del valor calculado de *

93 * Potencia activa y aparente. *

94 *================================================= ===========================*/

95

96 float CalculaPreact (float Pact , float Papar )

97 {



100


102 resultado =Cuadrado (Papar )-Cuadrado (Pact );//Se calcula la resta cuadrática

103 if(resultado <=0.05 ) //Si es resultado es 0 ó menor que 0

104 return 0; //Se sale da la funcion con Pact=0

105

106 resultado =sqrt (resultado ); //Se aplica la fórmula descrita en la

memoria


108 }

109 //Fin de la función CalculaPreact()

110

-2-

Medidas.c

111

112 /*================================================= ===========================*

113 * Comienzo de la función CalculaFDP() *

114 * *

115 * Función que calcula el factor de potencia a part ir de los valores *

116 * calculados de potencia activa y aparente. *

117 *================================================= ===========================*/

118

119 float CalculaFDP (float Pact , float Papar )

120 {



123


125 if(Papar <=0.05 ) //si es 0 o menor que 0 Papar

126 return 0; //Se devuelve 0 como FDP

127

128 resultado =Pact /Papar ; //Se aplica la fórmula descrita en la

memoria


130 }

131 //Fin de la función CalculaFDP()

132

133

134 /*================================================= ===========================*

135 * Comienzo de la función CalculaEnergia() *

136 * *

137 * Función que calcula la energía a partir de la po tencia calculada. *

138 *================================================= ===========================*/

139

140 long float CalculaEnergia (long float Eant , float Pact , float tiempo )

141 {


143 long float resultado =0; //Variable que almacena el resultado

144


146 resultado =Eant +(Pact *tiempo ); //Se aplica la fórmula descrita en la

memoria

147


149 }

150 //Fin de la función CalculaEnergia()

151

152

153 /*================================================= ===========================*

154 * Comienzo de la función CaclulaTemp() *

155 * *

156 * Función que calcula la temperatura a partir del acumulado de las medidas *

157 * capturadas del ADC. *

158 *================================================= ===========================*/

159

160 float CaclulaTemp (long long *dato ,float escala ,unsigned int Nmuestras )

161 {


163 float temperatura = 0; //Variable que almacena el resultado

164 float VSensor = 0; //Variable que almacena V en el sensor

165

-3-

Medidas.c


167 (*dato )/=Nmuestras ; //Se lee el dato

168 VSensor =((*dato )*1.831110569e -2); //Se calcula la V del sensor

169 temperatura =(escala *VSensor )-273.0 ; //Se calcula la temperatura

170

171 return temperatura ; //Se devuelve el resultado

172 }

173 //Fin de la función CaclulaTemp()

174

175

176 /*================================================= ===========================*

177 * Comienzo de la función CaclulaFrec() *

178 * *



181 *================================================= ===========================*/

182

183 float CaclulaFrec (unsigned int *Datos ,unsigned char NSeg,float Tiempo1Muestra )

184 {


186 unsigned int Acumulado = 0; //Suma todos los semiciclos calculados

187 unsigned char NDatosReal = 0; //Cuenta de datos de Frec distintos de 0

188 unsigned char i = 0; //Variable auxiliar para recorrer las

tablas

189 float Freq = 0; //Almacena la frecuencia calculada

190 unsigned int Max = 0; //Almacena el máximo Nº de simiciclos

191 unsigned int min = 0xFFFF; //Almacena el mínimo Nº de simiciclos

192


194 for(i =0;i <NSeg;i ++)

195 {

196 if (Datos [i ]!=0) //Se calcula el máximo, mínimo

197 { //Acumulado de semiciclos y Nº de datos

198 if(Datos [i ]>Max)

199 Max=Datos [i ];

200 if(Datos [i ]<min )

201 min =Datos [i ];

202

203 Acumulado +=Datos [i ];

204 NDatosReal ++;

205 }

206 }

207

208 if (NDatosReal ==0) //Si todos los datos son 0

209 Freq =0.0 ; //La frecuencia es 0

210 else //Si hay datos distintos de 0

211 Freq =((float )Acumulado )/(2.0 *NDatosReal *Tiempo1Muestra );//Se calcula al frecuencia

212

213 if((Max-min )>(0.1 *2.0 *Freq )) //Si la diferencia entre el máximo el

mínimo es

214 { //mayor del 10%


globales

216 for(i =0;i <NSeg;i ++)

217 Datos [i ]=0; //Se ponen a 0 los datos de frecuencia

almacenados

218 _EINT(); //Se habilitan las interrupciones globales

-4-

Medidas.c

219 }

220

221 return Freq ; //Se devuelve el resultado

222 }

223 //Fin de la función CaclulaFrec()

224

225

226 /*================================================= ===========================*

227 * Comienzo de la función CalculaMedia() *

228 * *



231 *================================================= ===========================*/

232

233 float CalculaMedia (long long *dato ,float escala , unsigned int Nmuestras )

234 {



237


239 resultado =((*dato )*escala )/Nmuestras ; //Se aplica la fórmula descrita en la

memoria

240


242 }

243 //Fin de la función CalculaMedia()

244

245

246 /*================================================= ===========================*

247 * Comienzo de la función round() *

248 * *

249 * Función auxiliar usada para redondear los result ados *

250 *================================================= ===========================*/

251

252 long int round (float dato )

253 {


255 long int resultado =0; //Variable que almacena el resultado

256


258 resultado =(int )(dato +0.5 ); //Se redondea el resultado

259


261 }

262 //Fin de la función round()

263

264

265 //Fin del módulo medidas

266

-5-

ModBus.h

1 /*================================================= ===========================*

2 * *

3 * FICHERO....: modbus.h *




7 * VERSIÓN:.... 3.110 *


9 * *

10 * DESCRIPCION: Fichero de cabezera del módulo de c omunicaciones modbus *

11 * *

12 *================================================= ===========================*/

13

14 #ifndef _ModBus_H_

15 #define _ModBus_H_

16

17 /*------------------------------------------------- ---------------------------*


19 *------------------------------------------------- ---------------------------*/

20

21

22 /*------------------------------------------------- ---------------------------*


24 *------------------------------------------------- ---------------------------*/

25

26 #define MBOK (0) //Resultado correcto

27 #define MBERROR (-1) //Resultado incorrecto

28 #define MBErrorDirTabla (-2) //Dir tabla ilegal

29 #define MBerrorTamTabla (-3) //Tam tabla incorrecto

30 #define ErrorMemLlena (-4) //No hay hueco en el HEAP

31

32

33 /*------------------------------------------------- ---------------------------*


35 *------------------------------------------------- ---------------------------*/

36

37

38 /*------------------------------------------------- ---------------------------*


40 *------------------------------------------------- ---------------------------*/

41

42 char IniModBus (unsigned int *DirTabla , unsigned int TamTabla , unsigned int

NDatosEscrit ,unsigned char DirEsc , unsigned char modo);

43 char NuevosDatos (unsigned int *Tabla ); //Combrueba si han llegado nuevos datos

44

45 char TestModBusFree (unsigned char modo); //Comprueba si se están procesando

ordenes ModBus

46

47

48 //Fin de la cabecera ModBus

49 #endif

50

-1-

ModBus.c

1 /*================================================= ===========================*

2 * *

3 * FICHERO....: ModBus.c *




7 * VERSIÓN:.... 3.110 *


9 * *

10 * DESCRIPCION: Módulo encargado de la inicializaci ón y control de las *

11 * comunicaciones eerie en formato ModBus RTU entre el módulo y *

12 * el escada. *

13 * *

14 *================================================= ===========================*/

15

16

17 /*------------------------------------------------- ---------------------------*


19 *------------------------------------------------- ---------------------------*/

20

21 #include "ModBus.h" //Cabecera de modbus


23 #include <stdlib.h> //Cabecera para poder usar malloc

24

25

26 /*------------------------------------------------- ---------------------------*

27 * DEFINICIÓN DE ETIQUETAS Y MACROS LOCALES DEL MÓDULO *

28 *------------------------------------------------- ---------------------------*/

29

30 #define UARTModoTx P2OUT|=BIT6 //Macro para poner la UART en TX

31 #define UARTModoRx P2OUT&=(~BIT6) //Macro para poner la UART en RX

32

33

34 /*------------------------------------------------- ---------------------------*

35 * DEFINICIÓN DE CONSTANTES LOCALES DEL MÓD ULO *

36 *------------------------------------------------- ---------------------------*/

37

38 static const unsigned char aucCRCHi[] = {

39 0x00 , 0xC1, 0x81 , 0x40 , 0x01 , 0xC0, 0x80 , 0x41 , 0x01 , 0xC0, 0x80 , 0x41 ,



















-1-

ModBus.c



60 0x00 , 0xC1, 0x81 , 0x40 };

61

62 static const unsigned char aucCRCLo[] = {

63 0x00 , 0xC0, 0xC1, 0x01 , 0xC3, 0x03 , 0x02 , 0xC2, 0xC6, 0x06 , 0x07 , 0xC7,

64 0x05 , 0xC5, 0xC4, 0x04 , 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,

65 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09 , 0x08 , 0xC8, 0xD8, 0x18 , 0x19 , 0xD9,

66 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,

67 0x14 , 0xD4, 0xD5, 0x15 , 0xD7, 0x17 , 0x16 , 0xD6, 0xD2, 0x12 , 0x13 , 0xD3,

68 0x11 , 0xD1, 0xD0, 0x10 , 0xF0, 0x30 , 0x31 , 0xF1, 0x33 , 0xF3, 0xF2, 0x32 ,

69 0x36 , 0xF6, 0xF7, 0x37 , 0xF5, 0x35 , 0x34 , 0xF4, 0x3C, 0xFC, 0xFD, 0x3D,

70 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39 , 0xF9, 0xF8, 0x38 ,

71 0x28 , 0xE8, 0xE9, 0x29 , 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF,

72 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24 , 0x25 , 0xE5, 0x27 , 0xE7, 0xE6, 0x26 ,

73 0x22 , 0xE2, 0xE3, 0x23 , 0xE1, 0x21 , 0x20 , 0xE0, 0xA0, 0x60 , 0x61 , 0xA1,

74 0x63 , 0xA3, 0xA2, 0x62 , 0x66 , 0xA6, 0xA7, 0x67 , 0xA5, 0x65 , 0x64 , 0xA4,

75 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB,

76 0x69 , 0xA9, 0xA8, 0x68 , 0x78 , 0xB8, 0xB9, 0x79 , 0xBB, 0x7B, 0x7A, 0xBA,

77 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74 , 0x75 , 0xB5,

78 0x77 , 0xB7, 0xB6, 0x76 , 0x72 , 0xB2, 0xB3, 0x73 , 0xB1, 0x71 , 0x70 , 0xB0,

79 0x50 , 0x90 , 0x91 , 0x51 , 0x93 , 0x53 , 0x52 , 0x92 , 0x96 , 0x56 , 0x57 , 0x97 ,

80 0x55 , 0x95 , 0x94 , 0x54 , 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,

81 0x5A, 0x9A, 0x9B, 0x5B, 0x99 , 0x59 , 0x58 , 0x98 , 0x88 , 0x48 , 0x49 , 0x89 ,

82 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,

83 0x44 , 0x84 , 0x85 , 0x45 , 0x87 , 0x47 , 0x46 , 0x86 , 0x82 , 0x42 , 0x43 , 0x83 ,

84 0x41 , 0x81 , 0x80 , 0x40 };

85

86

87 /*------------------------------------------------- ---------------------------*

88 * DEFINICIÓN DE VARIABLES LOCALES DEL MÓDU LO *

89 *------------------------------------------------- ---------------------------*/

90

91 static unsigned int NTx=0; //Nº de bytes que quedan por transmitir

92 static unsigned int NRx=0; //Nº bytes recibidos

93 static unsigned int NRxLecMax=0; //Nº máximo registros de lectura

94 static unsigned int NRxEscMax=0; //Nº máximo registros de escritura

95 static unsigned char DirEsclavo =0; //Dirección esclabo modbus

96 static unsigned int NTxMsg=0; //Longitud mensaje a transmitir

97 static unsigned char *PunteroTablaDatos ; //Puntero que señala a la tabla de var.

compartidas

98 static unsigned char *PunteroTablaTX ; //Puntero que señala a la tabla de

transmisión

99 static unsigned char *PunteroTablaRX ; //Puntero que señala a la tabla de

recepción

100 static unsigned int PosComienzoEscritura =0;//Posición del comienzo del reg. de

escritura

101 static unsigned char FlagNuevosDatos =0; //Flag que indica si hay datos

pendientes de leer

102 static unsigned char BusyModBus=0; //Flag que indica si quedan datos por

transmitir

103

104

105 /*------------------------------------------------- ---------------------------*

106 * PROTOTIPOS DE LAS FUNCIONES LOCALES DEL MÓDULO *

107 *------------------------------------------------- ---------------------------*/

108

-2-

ModBus.c

109 //Funciones de inicialización

110 static void IniTIMERA (void ); //Inicia el Timer

111 static void IniUART (void ); //Inicia la UART

112

113 //Funciones principales

114 static void AnalizarDatos (void ); //Función de decodificación de la orden

115 static void Sobretiempo (unsigned int tiempo );//Función de congiuracion del timeout

116 static unsigned int CRC16( unsigned char * pucFrame , unsigned int Longitud );

117

118 //Funciones auxiliares

119 static void Error (unsigned char tipo ); //Prepara el mensaje de error a enviar

120 void AddCRC(unsigned int pos ); //Añade el CRC a la tabla de transmisión

121

122

123 /*------------------------------------------------- ---------------------------*


125 *------------------------------------------------- ---------------------------*/

126

127

128 /*================================================= ===========================*

129 * Comienzo de la función IniModBus() *

130 * *

131 * Función que inicializa las comunicaciones ModBus y todos los periféricos *

132 * asociados a dichas comunicaciones. *

133 *================================================= ===========================*/

134

135 char IniModBus (unsigned int *DirTabla , unsigned int TamTabla , unsigned int

NDatosEscrit ,unsigned char DirEsc , unsigned char modo)

136 {


138 if(DirTabla ==NULL) //Si la dirección de la tabla no es válida

139 return (char )MBErrorDirTabla ; //Devuelve código de error

140

141 if((TamTabla <NDatosEscrit )||(TamTabla ==0))//Si el tamaño de la tabla no es correcto

142 return (char ) MBerrorTamTabla ; //devuelve código de error

143

144 PunteroTablaRX =malloc ((2*NDatosEscrit )+9);//Se crea tabla de recepción

145 if(PunteroTablaRX ==0) //Si no hay memoria suficiente

146 return (char ) ErrorMemLlena ; //devuelve código de error

147

148 PunteroTablaTX =malloc ((2*TamTabla )+6); //Se crea tabla de transmisión

149 if(PunteroTablaTX ==0) //Si no hay memoria suficiente

150 return (char ) ErrorMemLlena ; //devuelve código de error

151

152 PunteroTablaDatos =(unsigned char *)DirTabla ;//Se guarda la dirección de la tabla de

datos

153

154 IniUART (); //Se inica la UART

155 IniTIMERA (); //Se inicia el TimerA

156

157 if (modo==0) //Si el modo es 0

158 PosComienzoEscritura =0; //Se da permiso de escritura a los

primeros bytes

159 else //Si no es 0

160 PosComienzoEscritura =(TamTabla -NDatosEscrit );//De da permiso de escritura a los

últimos

161

-3-

ModBus.c

162 DirEsclavo =DirEsc ; //Se almacena la dirección del esclavo

modbus

163 NRxLecMax=TamTabla ; //Se almacena el tamaño de la tabla

164 NRxEscMax=NDatosEscrit ; //Se almacena el nº de datos con

permisos de escritura

165

166 return (char )MBOK; //Se devuelve código inicialización OK

167 }

168 //Fin de la función IniModBus()

169

170

171 /*================================================= ===========================*

172 * Comienzo de la función NuevosDatos() *

173 * *

174 * Función que comprueba si hay datos pendientes de procesar. *

175 *================================================= ===========================*/

176

177 char NuevosDatos (unsigned int *Tabla )

178 {


180 unsigned int i = 0; //Variable auxiliar para bucles for

181 unsigned int DirTemp = 0; //Dirección del dato solicitado

182 unsigned int NDatoTemp = 0; //Nº datos solicitados

183 unsigned char *DirTabla ; //Puntero a tabla en la que almacenar

los datos

184


186 DirTabla =(unsigned char *)Tabla ; //Guardo el puntero en el que almacenar

los datos como char

187

188 if(FlagNuevosDatos ==0) //Si no hay nuevos dadtos

189 return (char ) MBERROR; //Se sale da la función con un código de

error

190

191 else

192 {

193 DirTemp =(unsigned int )((PunteroTablaRX [2]<<8)+PunteroTablaRX [3]);//Leo la

dirección de los datos

194 if(PunteroTablaRX [1]==6) //Si la orden es escritura de 1 dato

195 {

196 DirTabla [(2*DirTemp )+1]=PunteroTablaRX [4];//Almaceno el dato en la tabla

197 DirTabla [2*DirTemp ]=PunteroTablaRX [5];

198 }

199 else //Si la orden es de escritura de una tabla

200 {

201 NDatoTemp=(unsigned int )((PunteroTablaRX [4]<<8)+PunteroTablaRX [5]);

202 for(i =0;i <NDatoTemp;i ++) //Se almacenan todos los datos recibidon

en la tabla

203 {

204 DirTabla [(2*(DirTemp +i ))+1]=PunteroTablaRX [(2*i )+7];

205 DirTabla [2*(DirTemp +i )]=PunteroTablaRX [(2*i )+8];

206 }

207 }

208 FlagNuevosDatos =0; //Borro el flag, ya no hay datos

pendientes

209

210 return (char )MBOK; //Devuelvo código datos OK

-4-

ModBus.c

211 }

212 }

213 //Fin de la función NuevosDatos()

214

215

216 /*------------------------------------------------- ---------------------------*

217 * CÓDIGO DE LAS FUNCIONES LOCALES DEL MÓDU LO *

218 *------------------------------------------------- ---------------------------*/

219

220

221 /*================================================= ===========================*

222 * Comienzo de la función IniUART() *

223 * *

224 * Función que configura el periférico de la UART p ara la transmisión y *

225 * recepción serie asíncrona usada por modbus. *

226 *================================================= ===========================*/

227

228 static void IniUART (void )

229 {


231 UCA0CTL1|=UCSWRST; //Reseteo la UART

232

233 P2OUT=0x00 ; //Se borran la salida del puerto de la

UART

234 P2DIR=BIT4 +BIT6 ; //Se Configuran los puertos de salida

235 P2SEL=BIT4 +BIT5 ; //Se configuran los perifericos

multiplexados

236

237 UCA0CTL0=UCPEN+UCPAR+UCMODE_1; //Se configura paridad y modo dirección

en UART

238 UCA0CTL1|=UCSSEL_1+UCDORM; //Se configura el reloj

239 UCA0BR0=13; //Se configura velocidad a 28400Bps

240 UCA0BR1=0;

241 UCA0MCTL=UCBRF_0+UCOS16;

242 UCA0IRTCTL&=(~UCIREN); //Se borra el modo IRDA

243 UCA0IRRCTL&=(~UCIRRXFE);

244 UCA0ABCTL&=(~UCABDEN);

245

246 UCA0CTL1&=(~UCSWRST); //Libero la UART

247

248 IE2 |=UCA0RXIE; //Se activa la interrupción de recepción

249 UARTModoRx; //Se pone el driver 485 en modo RX

250 }

251 //Fin de la función IniUART()

252

253

254 /*================================================= ===========================*

255 * Comienzo de la función IniTIMERA() *

256 * *

257 * Función que configura el Timer A para usarlo en modbus. *

258 *================================================= ===========================*/

259

260 static void IniTIMERA (void )

261 {


263 TACTL=TASSEL_1+ID_3 +TACLR; //Modo continuo

264 TACCR0=0xFFFF; //Se innicializa el registro de

-5-

ModBus.c

comparación

265 TACCTL0=CCIE; //Se habilita la interrupción

266 }

267 //Fin de la función IniTIMERA()

268

269

270 /*================================================= ===========================*

271 * Comienzo de la función Sobretiempo() *

272 * *

273 * Función que programa un timeout del tiempo espec ificado en microsegundos. *

274 *================================================= ===========================*/

275

276 static void Sobretiempo (unsigned int tiempo )

277 {


279 TACTL&=(~MC_3); //Paro el timer

280 TACTL|=TACLR; //Borro la cuenta

281 TACCR0=tiempo ; //Configuro el tiempo

282 TACTL|=MC_2; //Arranco el timer

283 }

284 //Fin de la función Sobretiempo()

285

286

287 /*================================================= ===========================*

288 * Comienzo de la función AnalizarDatos() *

289 * *

290 * Función que decodifica el mensaje que ha llegado por el puerto serie y *

291 * elabora la trama de respuesta. *

292 *================================================= ===========================*/

293

294 static void AnalizarDatos (void )

295 {


297 unsigned int i = 0; //Variable auxiliar para recorrer las

tablas

298 unsigned char j = 0; //Variable auxiliar para apuntar al bit

en las tablas

299

300 unsigned int CRCDato = 0; //Dato CRC auxiliar para la comprobación

301

302 unsigned int DirTemp = 0; //Dirección contenida en el mensaje

303 unsigned int NDatoTemp = 0; //Nº de datos contenidos en el mensaje

304 unsigned int IndiceTemp ; //Índice auxiliar para la orden 2

305


307 PunteroTablaTX [0]=DirEsclavo ; //Almaceno en tabla transmisión la

dirección modbus

308 PunteroTablaTX [1]=PunteroTablaRX [1]; //Almaceno el tipo de orden en la tabla

de transmisión

309

310 DirTemp =(unsigned int )((PunteroTablaRX [2]<<8)+PunteroTablaRX [3]);//Se lee la

dirección del mensaje

311 NDatoTemp=(unsigned int )((PunteroTablaRX [4]<<8)+PunteroTablaRX [5]);//Se lee el Nº

de datos del mensaje

312

313 CRCDato=(unsigned int )(PunteroTablaRX [NRx-2]<<8|PunteroTablaRX [NRx-1]);//Se

calcula el CRC

-6-

ModBus.c

314 if(CRCDato==CRC16(PunteroTablaRX ,(NRx-2)))//Si el CRC es correcto

315 {

316 if((PunteroTablaRX [1]==3)) //Si la orden es la 3

317 {

318 if(NRx==8) //el mensaje contiene 8 bytes

319 {

320 if((DirTemp +NDatoTemp)<=NRxLecMax) //y la dirección es correcta

321 {

322 PunteroTablaTX [2]=(unsigned char )(0xFF&(2*NDatoTemp));//Se retransmiten

los datos solicitados

323 for(i =0;i <NDatoTemp;i ++)

324 {

325 PunteroTablaTX [(i *2)+4]=PunteroTablaDatos [(2*(DirTemp +i ))];

326 PunteroTablaTX [(2*i )+3]=PunteroTablaDatos [(2*(DirTemp +i ))+1];

327 }

328 AddCRC((i *2)+3);

329 }

330 else //Si la dirección está fuera de rango

331 Error (2); //Se retransmite el error 2

332

333 Sobretiempo (1003); //Se configura timeout de 3.5*T Byte

334 return; //Salgo de la función

335 }

336 }

337 else if((PunteroTablaRX [1]==6)) //Si la orden es 6

338 {

339 if(NRx==8) //y la longitud del mensaje es correcta

340 {

341 if((DirTemp >=PosComienzoEscritura )&&(DirTemp <(PosComienzoEscritura +NRxEscMax

)))//Si las direcciones son correctas

342 { //Preparo mensaje de respuesta escritura

OK

343 PunteroTablaTX [2]=PunteroTablaRX [2];




347 AddCRC(6);

348 FlagNuevosDatos =1; //Activo flag de datos de escritura

pendientes

349 }

350 else //Si la dirección no está dentro de rango


352



355 }

356 }

357 else if((PunteroTablaRX [1]==16)) //Si la orden es 16

358 {

359 if((NRx==(PunteroTablaRX [6]+8))&&(PunteroTablaRX [6]==(2*NDatoTemp))) //Si la

longitud del mensaje es correcta

360 {

361 if((DirTemp >PosComienzoEscritura )&&((DirTemp +NDatoTemp)<(PosComienzoEscritura

+NRxEscMax)))//Si la dirección es válida

362 {

363 PunteroTablaTX [2]=PunteroTablaRX [2];//Preparo mensaje respuesta escritura OK


-7-

ModBus.c



367 AddCRC(6);

368 FlagNuevosDatos =1; //Activo flag de datos de escritura

pendientes

369 }



372



375 }

376 }

377 else if (PunteroTablaRX [1]==2) //Si la orden es 2

378 {

379 if(((DirTemp +NDatoTemp)/16)<NRxLecMax)//Si la dirección es correcta

380 {

381 PunteroTablaTX [2]=(NDatoTemp/8); //Se prepara trama de respuesta

382 if((NDatoTemp%8)!=0) //con los bits solicitados

383 PunteroTablaTX [2]++;

384 PunteroTablaTX [3]=0;

385 j =0;

386 for(i =0;i <NDatoTemp;i ++)

387 {

388 IndiceTemp =(i +DirTemp )/8;

389 if(((PunteroTablaDatos [IndiceTemp ])&(0x01 <<((i +DirTemp )-(IndiceTemp *8))))!=

0)

390 PunteroTablaTX [(i /8)+3]|=(0x01 <<j );

391 j ++;

392 if(j >7)

393 {

394 j =0;

395 PunteroTablaTX [(i /8)+4]=0;

396 }

397 }

398 AddCRC(PunteroTablaTX [2]+3);

399 }



402



405 }

406 else //Si no se reconoce el código de la orden

407 {

408 Error (1); //Se retansmite error 1



411 }

412 }

413 UARTModoRx; //Si los datos no han llegado

correctamente

414 IE2 |=UCA0RXIE; //se configura UART en recepción de

dirección

415 BusyModBus|=0x02 ; //Se señala al Timer que no hay datos

pendientes

416 }

-8-

ModBus.c

417 //Fin de la función AnalizarDatos()

418

419

420 /*================================================= ===========================*

421 * Comienzo de la función CRC16() *

422 * *

423 * Función que calcula el CRC de una tabla. *

424 *================================================= ===========================*/

425

426 static unsigned int CRC16(unsigned char * pucFrame , unsigned int Longitud )

427 {


429 unsigned char ucCRCHi = 0xFF; //Variable que almacena la aprte alta

del CRC

430 unsigned char ucCRCLo = 0xFF; //Variable que almacena la aprte baja

del CRC

431 int iIndex ; //Variable auxiliar para recorrer la tabla

432


434 while( (Longitud --)>0 ) //Se recorre la tabla completa

435 {

436 iIndex = ucCRCHi ^ *( pucFrame ++ ); //Se calcula el nuevo índice

437 ucCRCHi = ( unsigned char )( ucCRCLo ^ aucCRCHi[iIndex ] );//Se calcula la

parte alta del CRC

438 ucCRCLo = aucCRCLo[iIndex ]; //Se calcula la parte baja del CRC

439 }

440 return ( unsigned int )( (ucCRCHi << 8) | ucCRCLo );//Se devuelve el CRC como

entro de 2 Bytes

441 }

442 //Fin de la función CRC16()

443

444

445 /*================================================= ===========================*

446 * Comienzo de la función AddCRC() *

447 * *

448 * Función que añade el CRC a la tabla de transmisi ón. *

449 *================================================= ===========================*/

450

451 void AddCRC(unsigned int pos )

452 {


454 unsigned int CRCDato; //Variable auxiliar para cálculo del CRC

455


457 CRCDato=CRC16(PunteroTablaTX ,pos ); //Se calcula el CRC

458 PunteroTablaTX [pos ]=(unsigned char )(0xFF&(CRCDato>>8));//Se añade parte alta a la

tabla

459 PunteroTablaTX [pos +1]=(unsigned char )(0xFF&CRCDato);//Se añada perte baja a la tabla

460 NTxMsg=pos +2; //Se memoriza Nº caracteres a transmitir

461 }

462 //Fin de la función AddCRC()

463

464

465 /*================================================= ===========================*

466 * Comienzo de la función Error() *

467 * *

468 * Función que memoriza en la tabla de transmisión la trama de error. *

-9-

ModBus.c

469 *================================================= ===========================*/

470

471 static void Error (unsigned char tipo )

472 {


474 PunteroTablaTX [1]=(PunteroTablaRX [1]+0x80 );//Se memoriza en tabla Tx orden + 0x80

475 PunteroTablaTX [2]=tipo ; //Se memoriza en tabla TX el código error

476 AddCRC(3); //Se añade el CRC a tabla transmisión

477 }

478 //Fin de la función CalculaRMS()

479

480

481 /*================================================= ===========================*

482 * Comienzo de la función TestModBusFree() *

483 * *

484 * Función que verifica si hay operaciones ModBus a ctivas. *

485 *================================================= ===========================*/

486

487 char TestModBusFree (unsigned char modo)

488 {


490 if((modo==0)&&((BusyModBus&0x0F)!=0)) //Si el acceso es en modo bloqueante y

la UART está ocupada

491 {

492 BusyModBus|=0xF0; //Informo al proceso que cuando finalize

me despierte

493 LPM3; //y duermo el micro

494 }

495

496 if(BusyModBus!=0) //Si la UART está ocupada

497 return (char )MBERROR; //Devuelvo un error

498 else //Si no hay transmisiones pendientes

499 return (char )MBOK; //aviso al programa con código OK

500 }

501 //Fin de la función TestModBusFree()

502

503

504 /*------------------------------------------------- ---------------------------*

505 * CÓDIGO DE LAS RUTINAS DE INTERRUPCIÓN *

506 *------------------------------------------------- ---------------------------*/

507

508

509 /*================================================= ===========================*

510 * Comienzo de la rutina de interrupción del Timer A *

511 * *

512 * Esta rutina se encarrga de determinar cuando fin alizan las tramas *

513 * de tranmsisión y recepción de datos, así como de generar los caracteres *

514 * de reposo definidos por el protocolo ModBus. *

515 *================================================= ===========================*/

516

517 #pragma vector=TIMERA0_VECTOR

518 __interrupt void IntTimer ( void )

519 {


521 TACTL&=(~MC_3); //Paro el timer

522 TACTL|=TACLR; //Borro la cuenta del timer

523

-10-

ModBus.c

524 _EINT(); //Habilito las interrupciones (bajo la

prioridad de la función)

525

526 if(NRx!=0) //Si hay datos almacenadoses en la tabla

de recepción

527 {

528 IE2 &=(~UCA0RXIE); //Deshabilito interrupción recepción de

la UART

529 UARTModoTx; //Configuro driver 485 en modo transmisión

530 AnalizarDatos (); //Se analiza la trama

531

532 if(FlagNuevosDatos ==1) //Si es una orden de escritura

533 LPM3_EXIT; //Despierto al microcontrolador

534

535 if((BusyModBus&0x0F)>1) //Si no hay operaciones pendientes

536 {

537 if((BusyModBus&0xF0)!=0) //Si el main está bloqueado esperando

que finalizen las comunicaciones


539 BusyModBus=0; //Indico que han finalizado las

comunicaciones

540 }

541

542 UCA0CTL1|=UCDORM; //Configuro UART en modo recepción de

dirección

543 NRx=0; //Nº datos recibidos = 0

544 }

545 else if(NTx==0) //Si no se ha enviado ningún dato

546 {

547 if(FlagNuevosDatos ==0) //Si no hay órdenes pendientes de procesar

548 {

549 UCA0TXBUF=PunteroTablaTX [0]; //Mando el primer Byte

550 IE2 |=UCA0TXIE; //Activo interupción TX de la UART

551 NTx=1; //memorizo que se ha enviado 1 byte

552 }

553 else //Si hay órdenes pendientes de procesar

554 {

555 LPM3_EXIT; //Despierto e microcontrolador

556 Sobretiempo (1000); //y espero un rato

557 }

558 }

559 else if(NTx==NTxMsg) //Si se ha enviado la respuesta completa

560 {

561 NTx=0; //Inicializao variable de datos

transmitidos

562 UCA0CTL1|=UCDORM; //Configuro UART en modo recepción de

dirección

563 UARTModoRx; //Driver 485 en modo recepción de datos

564 IE2 |=UCA0RXIE; //Se habilitan interrupciones de recepción

565

566 if((BusyModBus&0xF0)!=0) //Si el main está bloqueado esperando

que finalizen las comunicaciones


568 BusyModBus=0; //Indico que han finalizado las

comunicaciones

569 }

570 }

-11-

ModBus.c

571 //Fin de la rutina de interrupción del Timer A

572

573

574 /*================================================= ===========================*

575 * Comienzo de la rutina de interrupción de recepci ón de la UART *

576 * *

577 * Esta rutina se encarga de memorizar la trama que llega por la UART *

578 *================================================= ===========================*/

579

580 #pragma vector=USCIAB0RX_VECTOR

581 __interrupt void IntUARTRx (void ) //Función por completar

582 {


584 if(NRx==0) //Si es el primer Byte

585 {

586 if(UCA0RXBUF==DirEsclavo ) //Si le direcció9n recibida es la del

dispositivo

587 {

588 UCA0CTL1&=(~UCDORM); //Modo recepción de datos

589 PunteroTablaRX [0]=UCA0RXBUF; //Se memoriza el byte recibido

590 Sobretiempo (1003); //3.5*Twake =3.5*(11/9600)

591 NRx=1; //Se memoriza que se ha recibido 1 byte

592 BusyModBus=1; //Se señala que el modbus está ocupado

593 }

594 }

595 else //Si no es el primer byte

596 {

597 if (NRx<=NRxLecMax)

598 {

599 PunteroTablaRX [NRx]=UCA0RXBUF; //Se memoriza el byte recibido

600 NRx++; //Se incrementa cuenta de bytes recibidos

601 }


603 }

604 }

605 //Fin de la rutina de interrupción de recepción de la UART

606

607

608 /*================================================= ===========================*

609 * Comienzo de la rutina de transmisión de la UART *

610 * *

611 * Esta rutina se encarga de enviar la trama de res puesta por la UART *

612 *================================================= ===========================*/

613

614 #pragma vector=USCIAB0TX_VECTOR

615 __interrupt void IntUARTTx (void ) //Función por completar

616 {


618 UCA0TXBUF=PunteroTablaTX [NTx]; //Se transmite el Byte

619 NTx++; //Se incrementa la cuenta de Bytes

620 if(NTx>=NTxMsg) //Si se ha enviado el último byte

621 {


623 IE2 &=(~UCA0TXIE); //Se deshabilita interrupción de

transmisión

624 }

625 }

-12-

ModBus.c

626 //Fin de la rutina de transmisión de la UART

627

628

629 //Fin del módulo ModBus

630

-13-

Flash.h

1 /*================================================= ===========================*

2 * *

3 * FICHERO....: Flash.h *




7 * VERSIÓN:.... 3.110 *


9 * *

10 * DESCRIPCION: Fichero de cabezera del módulo de c ontrol de la Flash *

11 * *

12 *================================================= ===========================*/

13

14 #ifndef _Flash_H_

15 #define _Flash_H_

16

17

18 /*------------------------------------------------- ---------------------------*


20 *------------------------------------------------- ---------------------------*/

21

22

23 /*------------------------------------------------- ---------------------------*


25 *------------------------------------------------- ---------------------------*/

26

27 //Etieuetas de resultados a devolver por las funcio nes

28 #define FlashERROR (-1) //Operación de Flash no realizada

29 #define FlashOK (0) //Operación realizada con éxito

30

31 //Etiquetas de acceso a bloques

32 #define Flash1 ((unsigned char *)0x1040) //Primer bloque de Flash

33 #define Flash2 ((unsigned char *)0x1080) //Segundo bloque de Flash

34

35

36 /*------------------------------------------------- ---------------------------*


38 *------------------------------------------------- ---------------------------*/

39

40

41 /*------------------------------------------------- ---------------------------*


43 *------------------------------------------------- ---------------------------*/

44

45 float Flash2float (unsigned char *direccion );

46 void Flash2TablaFloat (float *Datos , unsigned char Ndatos , unsigned char *direccion );

47

48 void EraseFlash (unsigned char * direccion );

49 char WriteFlash (void *datos , unsigned char tamdato , unsigned char Ndatos , unsigned

char *PunteroFLASH );

50

51

52 //Fin de la cabecera Flash

53 #endif

54

-1-

Flash.c

1 /*================================================= ===========================*

2 * *

3 * FICHERO....: medidas.c *




7 * VERSIÓN:.... 3.110 *


9 * *

10 * DESCRIPCION: Módulo de funciones auxiliares util izadas para el control de *

11 * la memoria Flash. *

12 * *

13 *================================================= ===========================*/

14

15

16 /*------------------------------------------------- ---------------------------*


18 *------------------------------------------------- ---------------------------*/

19

20 #include "Flash.h" //Cabecera del módulo Flash


22

23

24 /*------------------------------------------------- ---------------------------*


26 *------------------------------------------------- ---------------------------*/

27

28

29 /*================================================= ===========================*

30 * Comienzo de la función Flash2float() *

31 * *

32 * Se encarga de leer un float de la memoria flash devolverla como resultado *

33 *================================================= ===========================*/

34

35 float Flash2float (unsigned char *direccion )

36 {


38 float Resultado =0; //Variable que almacena el dato a devolver

39 unsigned char i ; //Variable auxiliar para usar en los

bucles

40 unsigned char *dirResultado ; //Puntero para leer el dato como char

41


43 dirResultado =(unsigned char *)&Resultado ; //Se lee la dirección del dato como

puntero a char

44 for(i =0;i <sizeof(float );i ++) //Se leen todos los bytes que forman el

float

45 dirResultado [i ]=direccion [i ]; //y se almacenan en la variable a devolver

46

47 return Resultado ; //Se retorna el dato

48 }

49 //Fin de la función Flash2float()

50

51

52 /*================================================= ===========================*

53 * Comienzo de la función Flash2TablaFloat() *

54 * *

-1-

Flash.c

55 * Se encarga de leer de la memoria flash una tabla de float y devolverla *

56 * como resultado. *

57 *================================================= ===========================*/

58

59 void Flash2TablaFloat (float *Datos , unsigned char Ndatos , unsigned char *direccion )

60 {


62 unsigned char i ; //Variable auxiliar para recorrer los

bucles

63


65 for(i =0;i <Ndatos ;i ++) //Para todos los datos solicitados

66 Datos [i ]=Flash2float (&direccion [i *4]); //Se lee el float de la tabla en Flash

67 }

68 //Fin de la función Flash2TablaFloat()

69

70

71 /*================================================= ===========================*

72 * Comienzo de la función WriteFlash() *

73 * *

74 * Se encarga de grabar en Flashla tabla de datos q ue se le pasa como *

75 * parámetro en la llamada a la función. *

76 *================================================= ===========================*/

77

78 char WriteFlash (void *datos , unsigned char tamdato , unsigned char Ndatos , unsigned

char *PunteroFLASH )

79 {


81 unsigned char i ; //Variable auxiliar para recorrer los

bucles

82 unsigned char *PunteroDatos ; //Puntero para acceder a los datos como

char

83 unsigned char NBytes ; //Var. aux. que alacena el Nº de Bytes a

escribir

84


86 NBytes =tamdato *Ndatos ; //Se calcula el Nº de Bytes

87 if(NBytes >64) //Si no caben en un bloque de flash

88 return (char )FlashERROR; //Se da un error y se retorna

89

90 PunteroDatos =(unsigned char *)datos ; //Se lee la dirección de la tabla de

datos como char

91 EraseFlash (PunteroFLASH ); //Se borra el segmento de flash

92

93 FCTL3= FWKEY; //Borrar bloqueo acceso Flash

94 FCTL1 = FWKEY+ WRT; //Configuración de la Flash en modo

escritura

95

96 for (i =0;i <NBytes ;i ++) //Se escriben todos los bytes en Flash

97 PunteroFLASH [i ]=PunteroDatos [i ];

98

99 FCTL1 = FWKEY; //Configuramos la Flash en lectura

100 FCTL3 = FWKEY+ LOCK; //bloqueamos el acceso a flash

101

102 return FlashOK ; //si está OK, la función devuelve 0

103 }

104 //Fin de la función WriteFlash()

-2-

Flash.c

105

106

107 /*================================================= ===========================*

108 * Comienzo de la función EraseFlash() *

109 * *

110 * Esta función se encarga de borrar un segmento de Flash completo, el *

111 * a borrar es un arámetro que se le pasa como argu mento a esta función *

112 *================================================= ===========================*/

113

114 void EraseFlash (unsigned char * direccion )

115 {


117 _DINT(); //Se desabilitan las interrupciones

118 WDTCTL= WDTPW+ WDTHOLD; //Se para el perro guardian

119

120 FCTL3= FWKEY; //Se configura el controlador de Flash

121 FCTL4= FWKEY;

122 FCTL2=FWKEY+FSSEL_0+19;

123

124 FCTL1= FWKEY+ERASE; //Configuración de la FLASH en modo

borrado

125 *direccion =0x00 ; //Falsa escritura para borrar la Flash

126

127 FCTL1 = FWKEY; //Configuramos la Flash en lectura

128 FCTL3 = FWKEY+ LOCK; // bloqueamos el acceso a flash

129 }

130 //Fin de la función EraseFlash()

131

132

133 //Fin del módulo Flash

134

-3-



Sevilla a 10 de Septiembre de 2009

Los Ingenieros

Diego Francisco Larios Marín Enrique Personal Vázquez

Memoria Descriptiva

Documents

Transcript of Memoria Descriptiva