medidor de energÍa elÉctricatauja.ujaen.es/bitstream/10953.1/7459/1/tfg medidior de energia...

Escu

ela

Polit

écnic

a S

upe

rior

de

Jaén

UNIVERSIDAD DE JAÉN Escuela Politécnica Superior de Jaén

Trabajo Fin de Grado

MEDIDOR DE ENERGÍA

ELÉCTRICA

Alumno: José Juan Cabrera Higueras Tutor: Prof. D. Pedro Casanova Peláez Dpto: Ingeniería Electrónica y Automática

Febrero, 2018

Universidad de Jaén

Escuela Politécnica Superior de Jaén

Departamento de Ingeniería Electrónica y Automática

Don Pedro J.Casanova Peláez , tutor del Trabajo Fin de Grado titulado: Medidor

de energía eléctrica, que presenta José Juan Cabrera Higueras, autoriza su

presentación para defensa y evaluación en la Escuela Politécnica Superior de Jaén.

Jaén, febrero de 2018

El alumno: El tutor:

José Juan Cabrera Higueras Pedro J. Casanova Peláez

Pedro

Texto escrito a máquina

Pedro

Texto escrito a máquina

José Juan Cabrera Higueras Medidor de energía eléctrica

2 Escuela Politécnica Superior de Jaén

Índice 1. MEMORIA ...................................................................................................................... 4

1.1. OBJETO .................................................................................................................. 4

1.2. ALCANCE ............................................................................................................... 4

1.3. ANTECEDENTES ................................................................................................... 4

1.4. NORMAS Y REFERENCIAS ................................................................................... 4

1.4.1. BIBLIOGRAFIA ................................................................................................ 4

1.4.2. SOFTWARE UTILIZADO ................................................................................. 5

1.5. DEFINICIONES ....................................................................................................... 5

1.5.1. TENSIÓN ELÉCTRICA ................................................................................... 5

1.5.2. CORRIENTE ELÉCTRICA ............................................................................... 6

1.5.3. ENERGÍA ELECTRICA .................................................................................... 6

1.5.4. POTENCIA ELÉCTRICA .................................................................................. 7

1.5.5. POTENCIA ACTIVA ......................................................................................... 7

1.5.6. POTENCIA REACTIVA .................................................................................... 7

1.5.7. POTENCIA APARENTE ................................................................................... 8

1.5.8. FACTOR DE POTENCIA ................................................................................. 8

1.6. REQUISITOS DE DISEÑO...................................................................................... 8

1.7. ANÁLISIS DE SOLUCIONES .................................................................................. 9

1.8. RESULTADOS FINALES .......................................................................................10

1.8.1. CIRCUITO DE ALIMENTACIÓN .....................................................................10

1.8.2. CIRCUITOS DE ACONDICIONAMIENTO .......................................................11

1.8.3. CIRCUITO DE MEDIDA DE TENSIÓN............................................................13

1.8.4. CIRCUITO DE MEDIDA DE INTENSIDAD ......................................................14

1.8.5. CIRCUITO PARA LA PANTALLA ....................................................................16

1.8.6. PROGRAMACIÓN NEXTION ..........................................................................17

1.8.7. CIRCUITO PARA EL MICROCONTOLADOR .................................................29

1.8.8. PROGRAMACIÓN ARDUINO .........................................................................31

1.8.9. CAJETÍN PROTECTOR ..................................................................................46

1.9. CIRCUITO COMPLETO .........................................................................................46

2. ANEXOS .......................................................................................................................48

2.1. CALCULOS JUSTIFICATIVOS ................................................................................48

2.1.1. AMPLIFICADOR SUMADOR NO INVERSOR ..................................................48



2.1.2. FILTRO RC ......................................................................................................50

2.1.3. SELECCIÓN DEL TRASFORMADOR DE ALIMENTACIÓN.............................50

2.1.4. CÁLCULO DEL DISIPADOR ............................................................................51

2.2. CÓDIGO FUENTE DE ARDUINO ............................................................................52

3. PLANOS .........................................................................................................................61

3.1. PLANO ESQUEMÁTICO .........................................................................................61

3.2. PLANO PCB PLANO DE MASA ..............................................................................61

3.3. PLANO PCB SERIGRAFÍA ......................................................................................61

3.4. PLANO PCB PISTAS Y PADS .................................................................................61

3.5. PLANO PARTE SUPERIOR CAJETÍN .....................................................................61

3.6. PLANO PARTE INFERIOR CAJETÍN ......................................................................61

4. PRESUPUESTO .............................................................................................................62

4.1. PRECIOS SIMPLES ................................................................................................62

4.2. MANO DE OBRA .....................................................................................................62

4.3. UNIDADES DE OBRA .............................................................................................63

4.4. PRESUPUESTO TOTAL .........................................................................................64



1. MEMORIA

1.1. OBJETO

El objeto es diseñar, fabrica, montar y calibrar un sistema capaz de medir la

potencia y energía electrica consumida por cualquier aparato conectado a su

terminal, untilizando un Arduino nano para su procesamiento.

1.2. ALCANCE

El alcance consiste en, mediante una serie de sensores, obtener la tension y

corriente, para calcular asi la potencia y energía que puede consumir cualquier

aparato eléctrico conectado.

1.3. ANTECEDENTES

Este proyecto ha sido realizado ante la necesidad de conocer el consumo de

potencia y energía eléctrica de cualquier aparato domestico, para poder tomar

medidas sobre eficiencia energética.

1.4. NORMAS Y REFERENCIAS

1.4.1. BIBLIOGRAFIA

Para la realizacion de este proyecto, la siguiente bibliografica ha sido de gran

utilidad y apoyo justificativo para los calculos, a parte de algunos datasheets de

componentes y manuales de algunos de los programas utilizados.

A.S. Sedra, K.C. Smith. Circuitos Microelectrónicos (5ª ed.). McGraw-Hill, 2006.

R.C. Jaeger, T.N. Blalock. Diseño de Circuitos Microelectrónicos (2ª ed.).

McGraw-Hill, 2005.

Store.arduino.cc. (2018). Arduino Nano. [online] Disponible en:

https://store.arduino.cc/arduino-nano .

https://store.arduino.cc/arduino-nano



Itead.cc. (2018). Nextion HMI Solution - ITEAD Wiki. [online] Disponible en:

https://www.itead.cc/wiki/Nextion_HMI_Solution .

Forum.arduino.cc. (2018). Español. [online] Disponible en:

https://forum.arduino.cc/index.php?board=32.0 .

HETPRO. (2018). Nextion Pantalla Touch con Arduino HeTPro. [online]

Disponible en: https://hetpro-store.com/TUTORIALES/pantalla-nextion-arduino/ .

1.4.2. SOFTWARE UTILIZADO

Los principales softwares utilizados son los siguientes:

EAGLE versión 8.3.2 , desarrollado por Autodesk. Software utilizado para el

desarrollar y diseñar PCBs.

Arduino versión 1.6.9, desarrollado por Arduino.cc. Software utilizado para la

programacion de placas Arduino o compatibles.

Microsoft Office 2013, desarrollado por Microsoft. Software ofimático.

Nextion editor versión 0.52, desarrollado por Nextion. Software utilizado para la

programaciion de la pantalla TFT.

Inventor versión 2017, desarrollado por Autodesk. Software urilizado para el

diseño de piezas.

1.5. DEFINICIONES

1.5.1. TENSIÓN ELÉCTRICA

La tensión eléctrica es una magnitud física que cuantifica la diferencia de

potencial eléctrico entre dos puntos. También se puede definir como el trabajo por

unidad de carga ejercido por el campo eléctrico sobre una pratícula cargada para

moverla entre dos posiciones determinadas. Su unidad de medida es el voltio (V). la

tension entre dos puntos es independiente del camino recorrido y depende

https://www.itead.cc/wiki/Nextion_HMI_Solution

https://forum.arduino.cc/index.php?board=32.0

https://hetpro-store.com/TUTORIALES/pantalla-nextion-arduino/



exclusivamente del potencial eléctrico de dichos puntos en el campo eléctrico, que

es un campo conservativo.

1.5.2. CORRIENTE ELÉCTRICA

La corriente eléctrica es un flujo de carga eléctrica que recorre un material. Se

debe al movimiento de las cargas, normalmente electrones, en el interior del mismo.

Al caudal de corriente se le denomina intensidad de corriente eléctrica, cuya unidad

de medida es el amperio (A).

Hay que diferenciar los dos tipos de corriente (y tensión) eléctrica que tenemos,

siendo estos continua (DC) y corriente alterna (AC).

Se denomina corriente continua o corriente directa al flujo de cargas eléctricas

que no cambia de sentido con el tiempo. La corriente eléctrica a través de un

material se establece entre dos puntos de distinto potencial. Cuando hay corriente

continua, los terminales de mayor y menor potencial no se intercambian entre sí. Es

continua toda corriente cuyo sentido de circulación es siempre el mismo,

independiente de su valor absoluto.

Se denomina corriente alterna a la corriente eléctrica en la que la magnitud y

dirección varía cíclicamente por variar la tensión. La forma de onda de la corriente

alterna más común es la de una onda senoidal.

1.5.3. ENERGÍA ELECTRICA

Se denomina energía eléctrica a la forma de energía que resulta de la

existencia de una diferencia de potencial entre dos puntos, lo que permite establecer

una corriente eléctrica entre ambos cuando se los pone en contacto por medio de un

conductor eléctrico.



1.5.4. POTENCIA ELÉCTRICA

La potencia eléctrica es la relación de paso de energía de un flujo por unidad

de tiempo, es decir, la cantidad de energía entregada o absorbida por un elemento

por unidad de tiempo. La unidad en el Sistema Internacional de Unidades es el vatio

(W).

En corrientre alterna hay que distinguir entre potencia activa, reactiva y

aparente.

1.5.5. POTENCIA ACTIVA

La potencia activa es la potencia capaz de trasformar la energía eléctrica en

trabajo. Los diferentes dispositivos eléctricos existentes conviertes la energía

eléctrica en otras formas de energía tales como: mecánica, lumínica, etc. esta

potencia es, por tanto, la realmente consumida por los circuitos y, en consecuencia,

cuando se habla de demanda eléctrica, es esta potencia la que se utiliza para

determinar dicha demanda. Se mide en vatios (W), siendo su fórmula matemática la

siguiente:

P=V·I·cos(Φ)

1.5.6. POTENCIA REACTIVA

Esta potencia no se consume ni se genera en el sentido estricto y en circuitos

lineales solo aparece cuando existen inducciones y capacidades y en consecuencia

de la variación de energía del campo electromagnético en estos elementos cuando

circula corriente alterna. Su unidad en el Sistema Internacional de Unidades es el

voltioamperio reactivo (VAr), y su fórmula matemática es la siguiente:

Q=V·I·sin(Φ)



1.5.7. POTENCIA APARENTE

La potencia aparente de un circuito eléctrico de corriente alterna, es la suma

vectorial, que se puede observar en la Ilustracion 1.1, de la potencia que disipa dicho

circuito y se transforma en calor o trabajo, y la potencia utilizada utilizada para la

formacion de los campos eléctricos y magnéticos de sus componentes, que fluctuará

entre estos componentes y la fuente de energía. Esto significa que la potencia

aparente representa la potencia total desarrollada en un circuito con impedancia Z.

se mide en voltioamperios (VA) y su fórmula matemática es la siguiente:

S2=P2+Q2

Ilustración 1.1

1.5.8. FACTOR DE POTENCIA

Se define factor de potencia de un circuito de corriente alterna, como la relación

entre la potencia activa (P) y la potencia aparente (S). da una medida de la

capacidad de una carga de absorber potencia activa. Por esta razón, su valor es uno

si la carga es puramente resistiva, y cero en elementos inductivos o capacitivos

ideales sin resistencias.

f.d.p.=P/|S| = cos(Φ)

1.6. REQUISITOS DE DISEÑO

Los requisitos son poder medir la tensión y corriente eléctricas instantáneas

para calcular la potencia activa, reactiva y aparente, asi como la energía consumida,



y mostrar, mediante una pantalla, sus valores numéricos de las señales de tensión e

intensidad medidos.

Por tanto, hay que crear un circuito de alimentación, y otro de medida. Para el

procesamiento de los datos se precisa de un microcontrolador.

Tambien se debe poder selecionar las diferentes opciones de mostrar los

datos, de manera que haya una interacción con el usuario.

1.7. ANÁLISIS DE SOLUCIONES

Ante los requisitos de diseño, para la interacción con el usuario del sistema, se

ha optado por utilizar una pantalla TFT, de manera que en dicha pantalla se muestra

los datos requeridos, de tension, intensidad y graficas de éstas, como de potencias y

energía consumida. De la misma manera, este tipo de pantallas permiten crear

botones tactiles, que servirán de entradas para nuestro sistema, para elegir entre las

diferentes opciones de visualización.

Para medir los valores de tensión e intensidad, se realizaran mediante dos

transformadores, uno de tensión y otro de intensidad, que mediante unos circuitos

de acondicionamiento, serán las entradas para el microcontrolador.

Para los circuitos de acondicionamiento, hay que tener en cuenta, que el

microcontrolador solo acepta una tension de entrada de 0V a 5V, por lo que hay q

adaptar la señal a esos parametros.

El microcontrolador utilizado es un Arduino nano, por su facilidad de control y

su reducido tamaño, ideal para este tipo de sistema. Ademas presenta un bajo

consumo de energía eléctrica y una velocidad de muestreo suficiente para medir

este tipo de señales.

El sistema presenta cuatro terminales roscados, dos para conectar los cables

de alimentación, y otros dos para los cables del conector hembra donde se

enchufarán los aparatos eléctricos de los cuales queremos medir sus parámetros

especificados anteriormente.



1.8. RESULTADOS FINALES

Como resultados finales, se realizará la descripccion de cada uno de los

circuitos que aparecen el la realización de la PCB, como la programacion de la

pantalla y del microcontrolador, dividido en los siguientes apartados:

Circuito de alimentación.

Circuitos de acondicionamiento.

Circuito de medida de tensión.

Circuito de medida de intensidad.

Circuito para la pantalla.

Circuito para el microcontrolador.

Cajetín protector.

1.8.1. CIRCUITO DE ALIMENTACIÓN

Nuestro sistema se conectará a la red eléctrica española de 230V ac eficaes y

50Hz, y nuestro sistema funciona a 5V dc, por lo que necesitamos un circuito para

realizar esa conversión. Para ello, el principal elemento es el trasfromador utilizado

como se muestra en la Ilustración 1.2.

Ilustración 1.2

Las principales características de este trasformador son las siguientes:

Tensión nominal del secundario 9V ac

Potencia nominal 10VA



Tensión nominal primario 230V ac

Frecuencia funcionamiento 50Hz a 60Hz

Temperatura máxima +40ºC

La salida del trasfromador nos da una tension alterna de 9V, la cual tenemos

que convertir en continua. Para ello utilizamos, en primer lugar, un puente de diodos,

con un condensador para obtener una señal mas o menos contínua, con un pequeño

rizado. Para convertir esta señal en una señal de 5V dc, utilizamos el regulador de

tensión LM7805, con sus correspondientes condensadores de desacoplo,

proporcionados por el datasheet del fabricante. En la Ilustración 1.3 se puede ver el

esquemático de este sistema de alimentación.

Ilustración 1.3

1.8.2. CIRCUITOS DE ACONDICIONAMIENTO

En cuanto al acondicionamiento de señales, tenemos tres bloques. El primer

bloque es el encargado de generar una tensión de referencia de 2.5V. Un segundo

bloque que costa de un amplificador de dos canales, utilizado en modo sumador no

inversor. Por ultimo, un bloque de filtrado, para eliminar el ruido de alta frecuencia.

Bloque tensión de referencia

Para generar una tensión de referencia de 2.5V, utilizamos un LT1009CZ, que

alimentado a 5V, a partir del circuito de alimentación, y con una resistencia de 120Ω,

genera una tensión de 2.5V, con una tolerancia de ±0.005V. en la Ilustración 1.4 se

puede ver el esquematico de este bloque.



Ilustración 1.4

Bloque amplificador sumador no inversor

Para este bloque se ha utilizado el amplificador LMC6482IN, que cuenta con

dos unidades en el mismo chip, con una alimentación única típica de 5V, lo cual

facilita su alimentacion de 0V a 5V sin necesidad de otro circuito de alimentación.

Ademas cuenta con un producto de ancho de banda de ganancia típica de 1.5MHz y

un slew rate típico de 1.3V/µs.

Se configura en modo sumador no inversor, para que, mediante la tensión de

referencia de 2.5V del anterior bloque, introducir un offset a la tensión procedentes

de los circuitos de medida de tensión y e intensidad.

A continuación, se muestra en la Ilustración 1.5 el esquemático de este bloque.

Ilustración 1.5



Bloque de filtrado

Este bloque consiste en un filtro de primer orden, pasa baja, para filtrar las

señales de alta frecuencia, dejando pasar la señal con frecuencias inferiores a

100Hz. Este tipo de filtros de primer orden presentan dos componentes pasivos, que

son un condensador y una resistencia, configurados como se muestra en la

Ilustración 1.6. en nuestro sistema tendremos dos filtros de este tipo, uno por cada

salida del bloque anterior, es decir, uno por señal medida, uno para la señal de

tensión y otro para la señal de intesnidad.

Ilustración 1.6

1.8.3. CIRCUITO DE MEDIDA DE TENSIÓN

Este sistema de medida de tensión está diseñado para una tension de red de

230V eficaces y una frecuencia de 50Hz, que es el caso de la tensión de red de

España, y para los aparatos eléctricos que se conectan a dicha red. Para obtener la

tensión que toma el aparato conectado, se utiliza un trasformador de alterna, que se

puede ver en la Ilustración 1.7, y a continuación los datos de más relevancia.

Ilustración 1.7

Tensión nominal del secundario 6V ac



Potencia nominal 0.5VA

Tensión nominal primario 230V ac

Frecuencia funcionamiento 50Hz a 60Hz

Temperatura máxima +70ºC

Como se puede observar, este trasfromador da en el secundario una tensión

de 6V eficaces, y el microcontrolador tiene una entrada de 0V a 5V, lo cual hay que

adaptarla. Para ello, utilizamos un potenciómetro para ajustarlo a 2.5V de pico

cuando la tensión de red sea de 250V eficaces. Mediante el bloque de

acondicionamiento del amplificador modo sumador no inversor, se le suma la tensión

de referencia de 2.5V, para tener la señal de 0V a 5V a la entrada del

microcontrolador. A continuacion se muestra en la Ilustración 1.8 el esquemático

referente al trasformador y su acondicionamiento mendiante el potenciómetro.

Ilustración 1.8

1.8.4. CIRCUITO DE MEDIDA DE INTENSIDAD

Para medir la intensidad que demanda el aparato a medir, utilizaremos un

trasfromador de corriente, concretamente el AC1025, como se puede observar en la

Ilustración 1.9, del cual vemos sus características mas relevantes a continuación.



Ilustración 1.9

Corriente de entrada 25A

Proporción de giros 1000:1

Frecuencia de funcionamiento 50Hz a 60Hz

Voltios por Amperio con una resistencia de 100Ω: 0.1V/A.

Esta última característicaquiere decir que, conectando una resistencia de 100Ω

a la salida del trasfromador de corriente, y pasando un cable por el interior de éste,

con una corriente de un amperio, generará una tension en los extremos de la

resistencia de 0.1V. En la Ilustración 1.10 se puede ver el trasfromador de corriente

con los correspondientes jumpers para pasar el cable a través del trasformador, y la

salida del trasformador conectado a dicha resistencia.

Ilustración 1.10

De esta forma, tenemos una tension maxima de 2.5V de pico, lo cual a través

del bloque amplificador sumador, y con la tensión de referencia de 2.5V, tenemos

una salida entre 0V y 5V, a la entrada del microcontrolador.



1.8.5. CIRCUITO PARA LA PANTALLA

Para el circuito referente a la pantalla, necesitamos alimentar ésta a 5V, y las

conexiones al microcontrolador mediante comunicacion por puerto serie, por lo que

tenemos que conectar los pines RX y TX de la pantalla y el microcontrolador. Para

ello conectamos el pin RX del microcontrolador al TX de la pantalla, y el pin TX del

microcontrolador al RX de la pantalla.

La pantalla utilizada es la Nextion NX4832T035 HMI TFT LCD, una pantalla

táctil de tipo resistiva, en la Ilustracion 1.11 se puede ver la pantalla, y

posteriormente sus principales características.

Ilustración 1.11

Resolución de pantalla 480x320

RGB 65K

Pantalla TFT con panel táctil resistivo de 4 hilos integrado

Memoria Flash 16M

Fuente recomendada DC 5V 500mA

Consumo energético 5V 145mA (0.725W)

Como este tipo de pantalla traen consigo el conector a la pantalla, dejando en

el otro extremo los terminales hembras, para el circuito, se pondrán cuatro

conectores macho, como los que se muestran en la Ilustración 1.12.



Ilustración 1.12

1.8.6. PROGRAMACIÓN NEXTION

Para la programación de esta pantalla, utilizaremos el software proporcionado

por el fabricante de este tipo de pantalla. Se trata de una programación gráfica, en

tanto en cuanto estamos diseñando la interfaz con el usuario, aunque tambien

podemos añadir algunos comandos para determinadas acciones como se verá más

adelante.

En cuanto a la interfaz, cabe destacar cinco ventanas, la cual se van a explicar

brevemente a continuación.

Toolbox

En esta ventana aparecen todos los elementos que podemos utilizar para la

interfaz como son los recuadro de texto, botones, slider y otros más. En la Ilustración

1.13 se pueden ver todas estas herramientas, de las cuales sólo se van a explicar

las utilizadas en este proyecto.



Ilustración 1.13

- Text: para poner notas de texto en la pantalla.

- Number: para poner recuadros numéricos donde mostrar los datos

obtenidos desde Arduino.

- Button: utilizados para movernos entre páginas y comunicarnos con

Arduino.

Pictures

En esta ventana se cargan al programa las imágenes que utilizaremos de una

forma u otra en nuestra interfaz.



Ilustración 1.14

Para añadir las imágenes hay que pinchar sobre el símbolo de suma, y buscar

las imágenes que queramos introducir para utilizar en nuestra interfaz. En la

Ilustración 1.14 se pueden ver la imágenes utilizadas para este proyecto, cuyo pie de

imágen es el número de imágen y el tamaño en píxeles de dicha.

Page

Aqui apareceran todas las páginas que tiene nuestro proyecto.



Ilustración 1.15

De esta ventana cabe destacar que para añadir una nueva página hay que

pinchar sobre el primer elemento (hoja de color amarillo con el signo de suma

verde), y para eliminar una imágen pinchar justo el de al lado (hoja blanca con una

cruz roja). Aparecerá recuadrada de azul la página en la que estemos en cada

momento, y pinchanco en cada página accederemos a dicha página para su

programación.

Attribute

En esta ventana podremos ver toda la informacion de cada elemento.



Ilustración 1.16

Aquí se puede ver toda la información de botón b0, y destacar la siguiente

información relevante de esta ventana.

- Id: corresponde con el identificador de este elemento.

- Objname: indica el nombre de dicho elemento.

- Sta: utilizado para el tipo de fondo que tendrá este objeto, del cual hay tres

posibilidades. Solid color, el elemto tendrá un fondo de un solo color. Image,

tendra de fondo una imagen predeterminada, y se adaptara el objeto al

tamaño de dicha imagen. Crop image, similar al anterior, pero este

elemento no tiene por qué tener el mismo tamaño que la imagen.



- Picc y picc2: indica el número de la imagen q tienen de fondo.

- Pco y pco2: indica el color de letra del texto del elemento.

- Txt: para poner una nota de texto en el elemento.

- X,Y: son las coordenadas del vértice superior izquierdo del elemento dentro

de la página.

- W,H: indica el tamaño de dicho elemento.

Event

En esta ventana podemos declarar algunos comandos, principalmente en

botones, para que realicen una función determinada.

Ilustración 1.17

Las principales funciones de esta ventana son:

- Send Component ID: si se habilita esta opción, se enviara dicha informacion

al Arduino cuando se pulse sobre el botón.

- User code: donde podemos escribir las lineas de código que debe realizar la

pantalla por si misma sin necesidad de comunicación con Arduino.

- Touch Press Event: donde se puede habilitar las anteriores opciones. Estas

opciones las hará cuando se pulse sobre el botón.

- Touch Release Event: donde se puede habilitar las anteriores opciones.

Estas opciones las hará cuando se sueltela pulsación sobre el botón.

Una vez conocemos ya el entorno, nos dispondremos a explicar la

programación realizada sobre nuestro proyecto. Para ello veremos una a una cada

una de las páginas, y explicaremos cada elemento en dicha página.

Page 0



Ilustración 1.18

- Página de inicio page 0, con id 0, imagen de fondo pic 1.

- Botón b0 que nos llevará a la página 1 y la que hace las veces de menú, id

1, sta:crop image,picc y picc2: 1, pco:0 (color negro), pco2: 63488 (color

rojo), txt: INICIO, x:185, y:253, w:141, h:44. Touch Release Event: User

code (page 1).

Page 1

Ilustración 1.19

- Página de menú page 1, con id 0, imagen de fondo pic 0.

- Botón b0 que nos llevará a la página 2, donde se muestran los datos

generales, id 1, sta:crop image,picc y picc2: 0, pco:0 (color negro), pco2:

63488 (color rojo), txt: GENERAL, x:120, y:67, w:230, h:53. Touch Press

Event: Send Component ID. Touch Release Event: User code (page 2).



- Botón b1 el cual nos llevará a la página 3, donde se visualizarán las

potencias, id 2, sta:crop image,picc y picc2: 0, pco:0 (color negro), pco2:

63488 (color rojo), txt: POTENCIAS, x:120, y:134, w:230, h:53. Touch Press

Event: Send Component ID. Touch Release Event: User code (page 3).

- Botón b0 que nos conduce a la página 4 utilizada para la depuración del

código del Arduino, id 3, sta:crop image,picc y picc2: 0, pco:0 (color negro),

pco2: 63488 (color rojo), txt: PARAMETROS, x:120, y:200, w:230, h:53.

Touch Press Event: Send Component ID. Touch Release Event: User code

(page 4).

Page 2

Ilustración 1.20

- Página de datos general page 2, con id 0, imagen de fondo pic 0.

- Botón b0 que nos redirige a página 1 de menú, id 1, sta:crop image,picc y

picc2: 0, pco:0 (color negro), pco2: 63488 (color rojo), txt: INICIO, x:338, y:1,

w:141, h:44. Touch Release Event: User code (page 1).

- Botón b1 utilizado para indicar al Arduino que nos encontramos en la página

2, id 6, sta:crop image,picc: 2, picc2: 3, pco:0 (color negro), pco2: 0 (color

negro), x: 0, y:0, w:65, h:55. Touch Press Event: Send Component ID.

Touch Release Event: Send Component ID.

- Texto t2, id 7, sta:crop image,picc: 0, pco:0 (color negro), txt: TENSION,

x:84, y:97, w:125, h:36.



- Texto t3, id 8, sta:crop image,picc: 0, pco:0 (color negro), txt: CORRIENTE,

x:242, y:100, w:152, h:36.

- Texto t0, id 4, sta:crop image,picc: 0, pco:0 (color negro), txt: V, x:179,

y:132, w:35, h:44.

- Texto t4, id 10, sta:crop image,picc: 0, pco:0 (color negro), txt: ,(coma),

x:275, y:133, w:17, h:39.

- Texto t1, id 5, sta:crop image,picc: 0, pco:0 (color negro), txt: A, x:345,

y:129, w:34, h:44.

- Texto t5, id 11, sta:crop image,picc: 0, pco:0 (color negro), txt: ANGULO FI,

x:84, y:196, w:176, h:38.

- Texto t6, id 13, sta:crop image,picc: 0, pco:0 (color negro), txt: º (grados),

x:324, y:187, w:55, h:30.

- Número n1 donde visualizaremos el valor de tensión procedente desde

Arduino, id 2, sta:crop image,picc: 0, pco:0 (color negro), x:92, y:132, w:92,

h:42.

- Número n2 donde visualizaremos la componente entera de la corriente

procedente del Arduino, id 3, sta:crop image,picc: 0, pco:0 (color negro),

x:240, y:133, w:36, h:39.

- Número n0 visualizador de la componente decimal de la corriente, id 9,

sta:crop image,picc: 0, pco:0 (color negro), x:284, y:132, w:72, h:41.

- Número n3 muestra el ángulo fi en grados procedente del Arduino, id 12,

sta:crop image,picc: 0, pco:0 (color negro), x:258, y:199, w:100, h:39.

Page 3

Ilustración 1.21



- Página de potencias page 3, con id 0, imagen de fondo pic 0.

- Botón b0 para volver a la página menú, id 1, sta:crop image,picc y picc2: 0,

pco:0 (color negro), pco2: 63488 (color rojo), txt: INICIO, x:338, y:1, w:141,

h:44. Touch Release Event: User code (page 1).

- Botón b1 para indicarle al Arduino que queremos comenzar a medir

energía, id 14, sta:crop image,picc y picc2: 0, pco:0 (color negro), pco2:

63488 (color rojo), txt: INICIO, x:179, y:250, w:104, h:44. Touch Press

Event: Send Component ID.

- Botón b2 para indicarle al Arduino que deje de calcular energía, id 15,

sta:crop image,picc y picc2: 0, pco:0 (color negro), pco2: 63488 (color rojo),

txt: FIN, x:261, y:249, w:103, h:44. Touch Press Event: Send Component ID.





- Texto t0, id 2, sta:crop image,picc: 0, pco:0 (color negro), txt: ACTIVA, x:32,

y:52, w:233, h:40.

- Texto t4, id 10, sta:crop image,picc: 0, pco:0 (color negro), txt: W, x:375,

y:52, w:52, h:52.

- Texto t1, id 3, sta:crop image,picc: 0, pco:0 (color negro), txt: REACTIVA,

x:31, y:100, w:233, h:40.

- Texto t5, id 11, sta:crop image,picc: 0, pco:0 (color negro), txt: VAr, x:377,

y:100, w:53, h:42.

- Texto t2, id 4, sta:crop image,picc: 0, pco:0 (color negro), txt: APARENTE,

x:31, y:151, w:233, h:40.

- Texto t6, id 12, sta:crop image,picc: 0, pco:0 (color negro), txt: VA, x:379,

y:153, w:53, h:42.

- Texto t3, id 5, sta:crop image,picc: 0, pco:0 (color negro), txt: ENERGIA,

x:33, y:202, w:233, h:40.

- Texto t7, id 13, sta:crop image,picc: 0, pco:0 (color negro), txt: Ws, x:381,

y:203, w:53, h:40.



- Número n4 visualizador del valor de potencia activa procedente del Arduino,

id 6, sta:crop image,picc: 0, pco:0 (color negro), x:280, y:51, w:92, h:42.

- Número n1 muestra el valor de la potencia reactiva calculado por el Arduino,

id 7, sta:crop image,picc: 0, pco:0 (color negro), x:280, y:100, w:92, h:42.

- Número n2 visualizador de la potencia aparente procedente del Arduino, id

8, sta:crop image,picc: 0, pco:0 (color negro), x:280, y:151, w:92, h:42.

- Número n3 visualizador de la energía calculada por Arduino, id 9, sta:crop

image,picc: 0, pco:0 (color negro), x:280, y:200, w:92, h:42.

Page 4

Ilustración 1.22

- Página de depuración page 4, con id 0, imagen de fondo pic 0.

- Botón b0 que nos lleva a la página menú, id 12, sta:crop image,picc y picc2:

0, pco:0 (color negro), pco2: 63488 (color rojo), txt: INICIO, x:338, y:1,

w:141, h:44. Touch Release Event: User code (page 1).





- Texto t1, id 2, sta:crop image,picc: 0, pco:0 (color negro), txt: MEDIDO,

x:189, y:81, w:102, h:33.



- Texto t2, id 3, sta:crop image,picc: 0, pco:0 (color negro), txt: REAL, x:318,

y:81, w:102, h:33.

- Texto t0, id 1, sta:crop image,picc: 0, pco:0 (color negro), txt: TENSION,

x:30, y:122, w:125, h:35.

- Texto t7, id 16, sta:crop image,picc: 0, pco:0 (color negro), txt: V, x:429,

y:124, w:34, h:44.

- Texto t3, id 4, sta:crop image,picc: 0, pco:0 (color negro), txt: CORRIENTE,

x:12, y:164, w:157, h:35.

- Texto t6, id 15, sta:solid color, bco: 50712 (color gris), pco:0 (color negro),

txt: , (coma), x:348, y:171, w:17, h:34.

- Texto t4, id 14, sta:crop image,picc: 0, pco:0 (color negro), txt: A, x:426,

y:167, w:34, h:44.

- Texto t5, id 5, sta:crop image,picc: 0, pco:0 (color negro), txt: ANGULO FI,

x:24, y:216, w:146, h:35.

- Número n0 muestra el valor de tensión digital leído por Arduino, id 6,

sta:solid color, bco: 50712 (color gris), pco:0 (color negro), x:195, y:131,

w:100, h:34.

- Número n1 muestra el valor de tensión, id 7, sta:solid color, bco: 50712

(color gris), pco:0 (color negro), x:318, y:130, w:100, h:34.

- Número n2 visualizador de del valor de corriente digital leída, id 8, sta:solid

color, bco: 50712 (color gris), pco:0 (color negro), x:193, y:171, w:100, h:34.

- Número n3 muestra la componente entera de la corriente, id 9, sta:solid


- Número n4 muestra la componente decimal de la corriente, id 13, sta:solid


- Número n5 visualizador del angulo fi en grados procedente del Arduino, id

10, sta:solid color, bco: 50712 (color gris), pco:0 (color negro), x:256,

y:222, w:100, h:34.



1.8.7. CIRCUITO PARA EL MICROCONTOLADOR

En cuanto al microcontrolador, es el encargado de gestionar la información,

recibiendo la informacion de tensión e intensidad medios, realizar los calculos

oportunos y enviarlos a la pantalla. Para ello se ha utilizado el Arduino nano, ya que

es de pequeño tamaño, tiene un bajo consumo y es sencillo de utilizar. En la

Ilustración 1.23 se muestra este dispositivo con la información de cada patilla.

Ilustración 1.23

Este dispositivo debe estar alimentado a 5V por la patilla VIN y puesta a tierra

las patillas de GND.

En cuanto a memoria, tenemos que el ATmega328 tiene 32 KB, (también se

usan 2 KB para el gestor de arranque. El ATmega328 tiene 2 KB de SRAM y 1 KB

de EEPROM.



En el apartado de entradas y salidas tenemos que cada una de las 14 patillas

digitales en el Nano se puede usar como entrada o salida, usando las funciones

pinMode (), digitalWrite () y digitalRead (). Operan a 5 voltios.Cada pin puede

proporcionar o recibir un máximo de 40 mA y tiene una resistencia interna de pull-up

(desconectada por defecto) de 20-50 kOhms. Además, algunos pines tienen

funciones especializadas:

Serie: 0 (RX) y 1 (TX). Se usa para recibir (RX) y transmitir (TX) datos

en serie TTL. Estos pines están conectados a los pines

correspondientes del chip serie FTDI USB-TTL.

Interrupciones externas: 2 y 3. Estas clavijas se pueden configurar

para activar una interrupción en un valor bajo, un flanco ascendente o

descendente, o un cambio en el valor. Para ello se utiliza la función

attachInterrupt ().

PWM: 3, 5, 6, 9, 10 y 11. Proporcionan salida PWM de 8 bits con la

función analogWrite ().

SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines admiten la

comunicación SPI, que, aunque proporcionada por el hardware

subyacente, no se incluye actualmente en el lenguaje Arduino.

LED: 13. Hay un LED integrado conectado al pin digital 13. Cuando el

pin tiene un valor ALTO, el LED está encendido, cuando el pin está

BAJO, está apagado.

El Nano tiene 8 entradas analógicas, cada una de las cuales proporciona 10

bits de resolución (es decir, 1024 valores diferentes). Por defecto, miden desde tierra

a 5 voltios. Los pines analógicos 6 y 7 no se pueden usar como pines

digitales. Además, algunos pines tienen una funcionalidad especializada:

I2C: 4 (SDA) y 5 (SCL). Admite la comunicación I2C (TWI) utilizando la

biblioteca Wire.

Por último, en cuanto a comunicavion tenemos que el Arduino Nano tiene

varias facilidades para comunicarse con un ordenador, otro Arduino u otros

microcontroladores. El ATmega328 proporciona comunicación serial UART TTL

(5V), que está disponible en los pines digitales 0 (RX) y 1 (TX). Un FTDI FT232RL



en la placa canaliza esta comunicación en serie a través de USB y los controladores

FTDI (incluidos con el software Arduino) proporcionan un puerto virtual para el

software en la computadora. El software Arduino incluye un monitor serie que

permite el envío de datos textuales simples hacia y desde la placa Arduino. Los LED

RX y TX de la placa parpadearán cuando los datos se transmitan a través del chip

FTDI y la conexión USB a la computadora (pero no para la comunicación serial en

los pines 0 y 1). Una biblioteca de SoftwareSerial permite la comunicación serial en

cualquiera de los pines digitales de Nano. El ATmega328 también admite la

comunicación I2C (TWI) y SPI. El software Arduino incluye una biblioteca Wire para

simplificar el uso del bus I2C.

Para nuestro proyecto, utilizaremos los pines de alimentación, VIN y GND para

alimentar la placa Arduino. Los pines analógicos 0 y 1 (A0 y A1 respectivamente)

para medir los valores de tensión (A1) e intensidad (A0). Y por último, los pines de

comunicación TTL, que son los pines digital 1 (TX) y digital 0 (RX).

1.8.8. PROGRAMACIÓN ARDUINO

Una vez visto el esquemático por completo, se va a proceder a la programación

del Arduino. Para ello se utiliza el lenguaje implementado por Arduino, basado en C,

y que se puede programar desde su programa de Arduino.

En primer lugar debemor declarar las librerías q utilizaremos, para ello se

declararan al principio y de la siguiente forma.

Ilustración 1.24

La libreria “Nextion.h” se utilizará para la comunicacion con la panalla del

fabricante Nextion, donde mostraremos los resultados. Esta librería se encarga de

parte de comunicacion puerto serie entre Arduino y Nextion, lo cual dicha parte no

tenemos que programarla nosotros. La libreria “TimerOne.h” se utilizará para



habilitar una interrupcion por temporización, que utilizaremos para realizar las

medidas de corriente y tensión.

Seguidamente, procederemos a definir parámetros requeridos por la pantalla

Nextion. Para ellos nos ayudaremos de la librería ya incluida de Nextion. Para ello

definiremos los botones utilizados, así como los display numéricos y las páginas

utilizadas de la siguiente forma.

- Definición de los botones: tenemos que declarar todos los botones que, de

una forma u otra, tengan que comunicarse con el Arduino. Para ello

utilizaremos la siguiente expresión:

NexButton nombre en Arduino=NexButton(nº de página, id, nombre en Nextion)

Ilustración 1.25

De esta forma quedan declarados todos los botones que comunicacn con

Arduino.

- Definición de los displays numéricos: para enviar desde Arduino los datos

numéricos a la pantalla Nextion, hay de definirlos de la siguiente manera:

NexNumber nombre en Arduino=NexNumber(nº de página, id, nombre en

Nextion)



Ilustración 1.26

- Definición de las páginas: por último, definimos las páginas utilizadas en

este proyecto, para ello utilizaremos la siguiente expresión:

NexPage nombre en Arduino=NexPage(nº de página, id, nombre en Nextion)

Ilustración 1.27

Una vez tenemos definidos todos los botones, displays y páginas, definiremos

la función encargada de consultar el estado de los botones. En la Ilustración 1.28 se

puede ver dicha función.

Ilustración 1.28



Ahora nos dispondremos a declarar las variables globales utilizadas en el

programa.

Ilustración 1.29

Una vez tenemos definidas las variables globales, podemos definir las

funciones que utilizaremos en el programa principal. En la siguiente imagen se

pueden ver todas las funciones utilizadas, y posteriormente se va a detallar su

utilización.

Ilustración 1.30

- Función flagpg2: esta función es llamada cuando se accede a la página dos

de la pantalla, y es utilizada para asignar a la variable global flagPg el valor

numérico de dos.



- Función flagpg3: esta función tiene la misma finalidad qu la función anterior,

solo que se accede cuando accedemos a la página tres y asignamos el

valor tres.

- Función flagpg2: igual que las anteriores, solo que para cuando accedemos

a la página cuatro y asignamos el valor de cuatro a la variable.

- Función flagEner1: a esta función accedemos cuando pulsamos el boton de

inicio de la página tres, que indica el comienzo para calcular energía. Su

finalidad es poner a uno la variable global flagEnergia, inicializar a cero la

variable global EnergiaReal y asignar una referencia de tiempo

proporcionado por la función millis() implementada por Arduino. Esta función

millis() obtiene el valor de tiempo en milisegundos, el cual dividimos entre

1000 para obtener dicho valor en segundos.

- Función flagEner0: pone a cero la variable flagEnergiapara que deje de

calcular la energía consumida.

- Función FlagLeer: en esta función leemos los valores de tensión presentes

en las patillas analógicas A0 y A1 del Arduino. Para leer estos datos,

utilizamos la función implementada por Arduino analogRead, que mediante

un convertidor analógico-digital, convierte la tensión en un valor digital.

Dicha tensión debe estar comprendida entre 0V y 5V. El convertidor AD que

implementa Arduino es de 10 bits, lo cual nos da un rango de valores de

1024 puntos. De este modo, el valor de tensión de 0V corresponde a un

valor de 0 digital a la salida del convertidor, y el valor de tensión de 5V

corresponde a un valor a la salida del convertidor de 1023 digital. Esto nos

viene a decir que tenemos una resolución en tensión de 48mV por cada

valor digital. Por último inclementa en uno el valor de la variable x.

- Función Funcion_ff: esta función es utilizada a la hora de enviar datos a la

pantalla Nextion, ya que tras enviar cada dato, hay q enviar tres valores

0xff, por como esta definido el protocolo de comunicación.

Ahora que ya tenemos las variables globales y las funciónes definidas, vamos a

pasar a programar el setup de Arduino. La principal tarea de esta función es la

inicialización de comunicaciones e interrupciones. En la Ilustración 1.30 se puede

ver la programación utilizada y posteriormente viene explicado cada comando

utilizado.



Ilustración 1.31

- Serial.begin(velocidad): este comando inicializa la comunicación serial con

la pantalla a una velocidad de 9600 baudios por segundo.

- nexInit(): Inicializa la comunicación con Nextion mediante su librería.

- Nombre en Arduino.attachPush(función, &nombre en Arduino): este

comando define a qué función acudir cuando es pulsado un botón.

- Nombre en Arduino.attachPop(función, &nombre en Arduino): este comando

define a qué función acudir cuando es soltado un botón.

- Timer1.initialize(tiempo en microsegundos): utilizada para inicializar el timer

1 de Arduino, que se activa cada milisegundo.

- Timer1.attachInterrupt(función): habilita la interrupción del timer 1 y le

asocia la función FlagLeer a la que atender cuando se produce una

interrupción.

Utilizamos el timer 1 y su interrupción asociada cada milisegundo para el

muestreo de la señal de tensión y corriente.

Antes de explicar las distintas funciones de las que consta nuestra función loop,

vamos a comentar brevemente cómo funcionan las declaraciones de control

utilizadas en dicha función, ya que aparecen muy a menudo en todo nuestra

programación. Las declaraciones de control son usadas para controlar el proceso de

ejecución del programa. Las que nosotros hemos utilizado son:



- If-else: con la ayuda de este comando se pueden tomar decisiones, y su

estructura es la siguiente:

Ilustración 1.32

Primero se evalúa la “expresión” y si es cierta ejecuta la “sentencia_1”, en caso

contrario ejecuta la “sentecia_2”.

- For: utilizada para repetir una sentencia un número predefinido de veces.

Ilustración 1.33

En las expresiones del FOR la “inicialización” es una variable a la cual se le

asigna un valor inicial con el que controlar el bucle. La “condición de finalización”

sirve para evaluar antes de ejecutar las sentencias si es cierta o no, en el caso de

ser cierta se ejecutan las “sentencias” y en caso contrario se sale del bicle for. Por

último, la expresión de “incremento” o decremento modifica la variable de control

después de ejecutar el bucle.

- While: utilizado para repetir sentencias un número de veces no conocido.

Ilustración 1.34

La “expresión” se evalúa y las “sentencias” se ejecuta mientras la “expresión”

es verdadera, cuando es falsa se sale del bucle while.



Ahora se va aproceder a programar el bucle loop de Arduino. Este bucle es

repetido contínuamente por el microcontrolador, y es, por lo tanto, donde va nuestra

programación principal de control y de cálculo del sistema.

En primer lugar vamos a definir una serie de variable locales de este apartado.

Se distinguen de las variable globales en que, las variables locales, solo son

utilizadas por el bucle loop, miestras que a las variables globales pueden acceder

todas las funciones. En la Ilustración 1.35 se pueden ver declaradas nuestra

variables locales y para qué están destinadas cada una de ellas.

Ilustración 1.35

Las líneas que siguen se encarga de consultar el estado de los botones

pulsados en la pantalla Nextion, y de muestrear las señales de tensión y corriente.

Dichas líneas se pueden observar en la Ilustración 1.36.

Ilustración 1.36

- nexLoop(nex_listen_list): consulta los estados de los botones de la pantalla,

por si ha sido pulsado alguno de ellos.

- While: en el interior de este bucle tenemos el comando interrupts() que

habilita la interrupción del timer 1 ya definida e inicializada anteriormente. El



bucle se repetira hasta que el valor de la variable x sea de 40, comenzando

por el valor 0. Esto es así ya que cada milisegundo se incrementa el valor

de la variable x en uno por la función asociada a la interrupcion, a la vez

que se mide un valor de tensión e intensidad. Como la red eléctrica

española es de 50Hz, y el periodo es la inversa de la frecuencia, tenemos

que el periodo es 20 milisegundos. En la Ilustración 1.37 se puede ver un

periodo de una señal de tensíon y corrietne. De modo que midiendo un

valor cada milisegundo, y midiendo 40 datos, medimos dos periodos de las

señales, 20 datos por periodo, para asegurarnos detectar el paso por cero

ascendente de dichas señales de tensión y corriente.

Ilustración 1.37

En la Ilustración 1.38 podemos ver la señal discreta leída por Arduino, y con

la que trabajaremos.

Ilustración 1.38

- noInterrupts(): esta línea deshabilita las interrupciones para el resto del

bucle loop, hasta la siquiente iteracion de este bucle.



Una vez tenemos ya leidos los valores de interés, se procederá a realizar los

cálculos pertinentes para obtener los valores reales. Para ello, en primer lugar,

introduciremos un bucle for, como se muestra en la Ilustración 1.39, que itere hasta

el número de muestras leídas, que deben de ser 40.

Ilustración 1.39

Una vez dentro del bucle, debemos obtener los valores de tensión e intensidad

reales en primer lugar. Para ello lo realizaremos del siguiente modo:

- Tension real de pico: para obtener la tensión real de pico, tenemos que

tener en cuenta que, como ya se ha dicho anteriormente, la tensión real de

red cuando vale 0V corresponde a una tensión de 2.5V leídos por Arduino,

lo que es un valor de 513 digital. En la Ilustración 1.40 podemos ver el

código implementado, y a continuación se explicará cada línea.

Ilustración 1.40

Para obtener el valor de pico, nos quedamos sólo con los semiciclos

positivos. Ahora bien, para convertir el valor digital leído al valor real de

tensión utilizamos la siguiente fórmula:

Tension Real = valor digital·250V/(1023-513) – 250V

Esta fórmula la obtenemos ya que, el valor máximo de tensión que

podemos leer es de 250V, lo que corresponde a una tensión de entrada del

Arduino de 5V y por tanto un valor digital de 1023. Por tanto, esos 250V se

dividen entre el valor máximo digital, 1023 menos el valor de 0V, valor de

513 digital. A ese valor hay que restarle los 250V de pico de los semiciclos

negativos, que corresponden con los valores comprendidos entre 512 y 0

digitales. Este valor lo almacenamos en la variable tensionreal.



Ya calculada la tensión real, cuando detectamos que el valor de dicha

variable, tensionreal, es mayor a la tensión de pico almacenada

anteriormente, tensionpico, se actualiza dicha variable con el valor

almacenado en tensionreal. Ademas se almacena el valor digital de esa

tensión en la variable tenion_medido.

- Intensidad real de pico: para la intensidad, seguimos el mismo

procedimiento que para la tensión, como se muestra en la Ilustración 1.41.

Ilustración 1.41

La diferencia con respecto a la tensión, a parte del nombre de las variables,

es la fórmula para calcular la corriente real. De manera análoga, el

planteamiento es el mismo, salvo que de valor máximo a medir son 25A en

lugar de 250V, de manera que queda la siguiente fórmula.

Intensidad Real = valor digital·25A/(1023-513) – 25A

El siguiente paso es el cálculo del ángulo fi. Para ello, vamos a obtenerlo a

partir del paso ascendente por 0V de la tensión y contamos el tiempo hasta que la

corriente realiza el paso ascendente por 0A. El código para realizar esa operación se

muestra en la Ilustración 1.42.

Ilustración 1.42



Para detectar el paso por cero ascendente de la tensión tenemos que

comprobar que la variable llamada tensión, sea mayor o igual a 513 de valor digital,

y la variable TensionAnt, donde almacenamos el valor digital de la tensión de la

iteración anterior, sea menor o igual a 513. Además, tenemos que tener la variable

falgFI a cero, que viene a decir, que no hemos calculado ya un valor de fi. Cuando

se cumplen estas condiciones, ponemos la variable aux a cero, que nos servirá para

el cálculo del tiempo del desfase. También ponemos a uno la variable flagTension,

que nos indica que ya hemos detectado el paso por cero de la tensión.

El siguiente paso es detectar el paso por cero ascendente de la corriente, que

se realiza de igual forma que la tensión, y además debe estar a uno la variable

flagTension que nos indica que se ha detectado el paso por cero de la tensión. Una

vez se cumplen esos requisitos, procedemos a realizar el cálculo del ángulo fi en

radianes y en grados. Para calcularlo en radianes utilizaremos la siguiente fórmula.

Ángulo en radianes= (1/(aux/1000)Hz·2π rad)/50 Hz

Donde:

aux es el tiempo en milisegundos entre el paso por cero de la tensión y el paso por cero de la corriente.

Para el cálculo del ángulo fi en grados, realizamos la conversión de radianes a

grados, que, mediante la funcion de Arduini (int), convertimo en un valor entero,

eliminando la parte decimal para mostrarlo por la pantalla. Para el cálculo utilizamos

la siguiente fórmula.

Ángulo en grados = (ángulo en radianes·180º)/ π rad

Una vez calculado el ángulo, ponemos a uno la variable flagFI que nos indica

que ya hemos calculado el ángulo fi.

Por último, las dos últimas líneas de esta parte del código, realizan la

actualización del valor digital de tensión y corriente para la siguiente iteración dentro

del bucle for, y de este modo hemos finalizado la programación de este bucle.

Fuera ya del bucle for, vamos a proceder a realizar el cálculo de las potencias y

de la energía. Para ello ejecutaremos la siguiente parte de código mostrado en la

Ilustración 1.43.



Ilustración 1.43

El cálculo de cada potencia se realiza con respectiva fórmula matemática vista

anteriormente, convirtiendo el resultado en entero para la visualización por la pantalla.

En cuanto a la energía, para calcularla, debemos tener a uno la variable

flagEnergia, la cual nos indica que ha sido pulsado el botón para comenzar a

calcular energía. En primer lugar, calculamos el tiempo trascurrido desde que se

pulsó el botón, o desde la anterior iteración del bucle loop. Para ello, obtenemos con

la función millis() una nueva referencia de tiempo, y a la que le restamos la

referencia de tiempo anterior, para sacar así el tiempo trascurrido en segundos. Para

el cálculo de la energía, sabemos que es la potencia activa por el tiempo trascurrido,

y a la que le sumamos la potencia de la iteración anterior para tener el valor

acumulado. En la variable Energia, almacenamos el valor entero de la energía para

su visualización, y por último, obtenemos una nueva referencia de tiempo.

Las siguientes dos líneas de nuestro código son utilizadas para obtener el

valor de la corriente como dos enteros, lo cual uno representa la parte entera de la

corriente, y la otra variable la parte decimal de la corriente, ya que hay que enviar

valores numéricos enteros a la pantalla. En la Ilustración 1.44 podemos ver como se

ha realizado dicha operación.

Ilustración 1.44

Cabe destacar la segunda línea, ya que para obtener la parte decimal como

entero, se le resta al valor de la corriente el valor entero de dicha, y es multiplicada

por mil para obtener un dígito sin decimales.



Por último, sólo queda programar la parte de envío de datos a la pantalla para

su visualización por ésta. Cada página donde se visualicen datos, tiene su propio

código y a continuación veremos la programación correspondiente a cada página.

Para enviar los datos numéricos desde Arduino a Nextion, hay que seguir el

siguiente protocolo. En primer lugar hay que enviar el nombre del elemento en la

pantalla Nextion de la siguiente forma:

“Nombre del elemento Nextion.val=”

Para enviar dicha información, utilizamos la función de Arduino Serial.print(),

que consiste en escribir por puesrto serie lo que se le indique. A continuación hay

que enviar el valor que queramos que se visualice utilizando tambien la función

Serial.print(). Por úlrimo, debemos enviar 0xff, 0xff y 0xff, para indicar a la pantalla el

fin de ese mensaje. Para enviar esta última información utilizaremos la función que

ya hemos implementado llamada Funcion_ff().

Ahora vamos a ver dicho código para cada página.

- Página 2: en esta página se visualizan los valores de tensión, intensidad y

el ángulo fi. Para ello utilizamos la programación mostrada en la Ilustración

1.45.

Ilustración 1.45

- Página 3: en esta página se visualizan las potencias. Para ello debemos

enviar los valores de potencia activa, potencia reactiva, potencia aparente y

energía acumulada, como se puede ver en la Ilustración 1.46.



Ilustración 1.46

- Página 4: donde visualizamos algunos datos de control, como son los

valores digitales de la tensión y corriente, los valores de tensión y corriente

de pico y el ángulo fi. En la Ilustración 1.47 podemos ver el código utilizado.

Ilustración 1.47

Antes de cerra el bucle loop, debemos restituir el valor de la variable auxsiliar

llamada x al valor de 0, para medir otros 40 datos en la siguiente iteración del bucle

loop. Cerramos el bucle loop y finalizamos nuestra programación.



1.8.9. CAJETÍN PROTECTOR

Para proteger la placa, y que quede un producto acabado, dejando sólo

accesible la pantalla para visualizar los datos y los terminales de conexión de red, se

ha diseñado una carcasa. En la Ilustración 1.48 se puede ver el diseño de dicha

carcasa.

Ilustración 1.48

1.9. CIRCUITO COMPLETO

Una vez realizado todo lo anterior, podemos ver en la Ilustración 1.49, nuestro

sistema acabado y montado. En la Ilustración 1.50 podemos ver el cajetín protector

físicamente.



Ilustración 1.49

Ilustración 1.50



2. ANEXOS

2.1. CALCULOS JUSTIFICATIVOS

En este apartado se detallarán los calculos justificativos del diseño de los

diferentes circuitos, así como la seleccion de algunos de los componentes.

2.1.1. AMPLIFICADOR SUMADOR NO INVERSOR

Para el acondicionamiento de la señal medida, a la entrada analógica del

Arduino, se utiliza un amplificador operacional, en configuración sumador no

inversor. De este modo, le sumamos a la señal procedente de la adquisición,2.5V de

pico, una tensión de referencia de 2.5V, para obtener una salida de 0V a 5V

adaptada correctamete a la entrada analógica.

En la Ilustración 2.1, se muestra el esquema básico de toda configuracion

sumadora no inversora, que a continuación analizaremos.

Ilustración 2.1

Para analizar este circuito de forma sencilla, utilizaremos el principio de

superposición, donde:

Vo=Vo1 + Vo2

V+ = V-

Siendo Vo1 la tensión de salida cuando conectamos V2 a tierra, y Vo2 cuando

es V1 la conectada a tierra. V1 es la señal procedente de cualquier de los

trasformadores, y V2 la tensión de referencia.

Calculamos ahora Vo1:



[1] IR1-IR2 =0

(V1 - V+)/R1 - V+/R2 = 0

Operando obtenemos:

V+= V1 / R1

[2] IR4 - IR3 =0

- V- / R4 – (V- - Vo1)/R3 =0

Operando se obtiene:

V- = Vo1/R3

V+ = V-

V1 / R1= Vo1/R3

Vo1=(R3/R1) V1

Una vez tenemos la salida de Vo1, calculamos Vo2:

[1] IR2- IR1 =0

(V2 - V+)/R2 - V+/R1 = 0

Operando obtenemos:

V+= V2 / R2

[2] IR4 - IR3 =0

- V- / R4 – (V- - Vo2)/R3 =0

Operando se obtiene:

V- = Vo2/R3

V+ = V-

V2 / R2= Vo2/R3



Vo1=(R3/R2) V2

Una vez tenemos ambas salidas por separado, sustituimos en Vo=Vo1 + Vo2 y

obtenemos lo siguiente:

Vo=(R3/R1) V1+(R3/R2) V2

Ahora bien, para obtener ganancia unitaria, tenemos que

R1=R2=R3=R4=10kΩ.

2.1.2. FILTRO RC

Para eliminar el ruido que pueda existir a altas frecuencias, tenemos un filtro de

primer orden pasa baja. En la Ilustración 2.2 se puede ver el esquema de este tipo

de filtros.

Ilustración 2.2

La fórmula para calcular los componentes es la siguiente:

Frecuencia =1/(2πRC)

Para poder disponer de resistencias y condensadores del mercado, suponemos

una resistencia R=3.3kΩ y un condensador C=100nF. Calculamos ahora la

frecuencia con estos valores, para saber la frecuencia de corte:

Frecuencia =1/(2π3.3kΩ·100nF)

Frecuencia = 482Hz

2.1.3. SELECCIÓN DEL TRASFORMADOR DE ALIMENTACIÓN

Para la eleción del trasformador para la alimentación, tenemos que fijarnos en

la tensión del secundario y de la potenia que sumunistra. La tensión de salida la



tenemos definida a 9V ac, y para calcular la potencia, atendemos a las intensidades

que consmumen cada elemento del circuito siendo las siguientes:

3. Arduino nano: 19mA + 4 canales x 40mA = 179mA

4. Nextion: 145mA (Recomendado 500mA) = 500mA

5. Amplificador: 2canales x 30mA = 60mA

6. Referencia de tensión = 20mA

7. Total = 759 mA

Para poder alimentar el sistema y suplir esa demanda de corriente

seleccionamos un trasformador de 10VA de potencia, lo cual nos suministra una

intensidad máxima de 1.11A.

2.1.4. CÁLCULO DEL DISIPADOR

Para el cálculo del disipador para el regulador, sabemos que por él va a

circular una corriente máxima de 1.5A y una tensión de 5V. A continuación

calcularemos la potencia a sorportar con estas condiciones.

P=V·I=5V·1.5A=7.5W

Ahora calcularemos la potencia máxima que puede soportar sin disipador. Para

ello obtenemos del datasheet del fabriacnte los siguientes datos de, temperatura de

unión máxima que soporta, Tjmax = 150ºC, y de resistencia térmica unión-ambiente,

Rja=19ºC/W. Para ello supondremos una temperatura ambiente de 25ºC.

Pmax=( Tjmax-Ta)/ Rja =(150ºC-25ºC)/19ºC/W = 6.5789W

Como vemos, sin disipador, no es capaz de disipar toda la potencia que

consume. Para ello se ha introducido un disipador, y obtenemos del datasheet del

fabricante la siguiente resistencia termica unión-ambiente, Rja=14ºC/W, y calculamos

de nuevo.

Pmax=( Tjmax-Ta)/ Rja =(150ºC-25ºC)/14ºC/W = 8.92W

Con este elemento es capaz de disipar toda la potencia consumida por el

regulador.



2.2. CÓDIGO FUENTE DE ARDUINO

#include "Nextion.h" // Libreria de nextion

#include "TimerOne.h" // Libreria para el timer

NexButton b0 = NexButton(1,1,"b0"); // Definimos los botones (pagina,id,nombre)

NexButton b1 = NexButton(1,2,"b1");


NexButton br1 = NexButton(2,6,"b1");





NexNumber n0= NexNumber(2,2,"n1"); // Definimos los display numericos

(pagina,id,nombre)

NexNumber n1= NexNumber(2,3,"n2");

NexNumber n3fi= NexNumber(2,12,"n3");













NexPage page0 = NexPage(0, 0, "page0"); // Definimos la pagina (nº pagina,id,nombre)

NexPage page1 = NexPage(1, 0, "page1");




NexTouch *nex_listen_list[] = // Funcion para consultar el estado de los botones

&b0,

&b1,

&b2,

&b3,

&b4,

&br1,

&br2,

&br3,

&page0,

&page1,

&page2,

&page3,

&page4,

NULL

;



// VARIABLES GLOBALES

int flagEnergia=0; // Para indicar si debemos calcular energía

int flagPg=0; // Para saber en qué página estamos

int tiempo=0; // Para contar el tiempo para el cálculo de la energía

int intensidad[40]; // Vector donde almacenar los valores de intensidad leídos

int tension[40]; // Vector donde almacenar los valores de tensión leídos

int x=0; // Variable auxiliar utilizada de contador

float EnergiaReal=0; // Variable donde almacenar el valor de la energía

// FUNCIONES UTILIZADAS

void flagpg2(void *ptr) // Funcion que se llama cuando se pulsa el boton de la pantalla

(GENERAL)

flagPg=2;

void flagpg3 (void *ptr) // Funcion que se llama cuando se pulsa el boton de la pantalla

(POTENCIAS)

flagPg=3;

void flagpg4 (void *ptr) // Funcion que se llama cuando se pulsa el boton de la pantalla

(ARAMETROS)

flagPg=4;

void flagEner1(void *ptr) // Funcion que se llama cuando se pulsa el boton de la pantalla

(INICIO) para empezar a contar energia

flagEnergia=1;

EnergiaReal=0;

tiempo=millis()/1000; // Iniciamos el contador de tiempo y dividimos por 1000 para

tenerlo e segundos;

void flagEner0(void *ptr) // Funcion que se llama cuando se pulsa el boton de la pantalla

(FIN) para terminar de contar energia



flagEnergia=0;

void FlagLeer(void)

intensidad[x]=analogRead(A0); // Leemos el valor analogico A0 Intensidad

tension[x]=analogRead(A1); // Leemos el valor analogico A1 Tension

x++;

void Funcion_ff(void) // Función utilizada para la comunicación

Serial.write(0xff);

Serial.write(0xff);

Serial.write(0xff);

// SETUP

void setup()

Serial.begin(9600); // Iniciamos la comunicación con la pantalla a 9600 baud

nexInit(); // Inicia la comunicacion con Nextion

b0.attachPush(flagpg2, &b0); // Define lo que hacer si se pulsa el boton

b1.attachPush(flagpg3, &b1);

b2.attachPush(flagpg4, &b2);

b3.attachPush(flagEner1, &b3);

b4.attachPush(flagEner0, &b4);

br1.attachPush(flagpg2, &br1);



br1.attachPop(flagpg2, &br1);





Timer1.initialize(1000); // Dispara cada 1 ms

Timer1.attachInterrupt(FlagLeer); // Activa la interrupcion

// LOOP

void loop()

// VARIABLES LOCALES

int PotActiva=0; // Variable para almacenar la potencia activa

int PotReactiva=0; // Variable para almacenar la potencia reactiva

int PotAparente=0; // Variable para almacenar la potencia aparente

int Energia; // Variable para almacenar la energía

float angFIrad=0; // Variable para almacenar el ángulo FI en radianes

int angFI; // Variable para almacenar el ángulo FI en grados

int flagFI=0; // Variable para indicar el cálculo del ángulo FI

int tension_medido=0; // Variable para almacenar el valor digital de tensión medido

int inten_medido=0; // Variable para almacenar el valor digital de intensidad medido

int tensionpico=0; // Variable para almacenar el valor de tensión de pico real

float intensidadpico=0; // Variable para almacenar el valor de intensidad de pico real

int flagTension=0; // Variable para indicar el paso por cero de la tensión

int aux; // Variable auxiliar para el cálculo del ángulo FI

int TensionAnt; // Variable para almacenar el valor de tensión de la iteración anterior

float IntensidadAnt; // Variable para almacenar el valor de intensidad de la iteración

anterior

int tensionreal; // Variable para almacenar el valor de tensión real de cada iteración



float intereal; // Variable para almacenar el valor de intensidad real de cada iteración

nexLoop(nex_listen_list); // Para consultar si cambian los botones

while (x<40)

interrupts(); // Habilita que se puedan producir interrupciones

noInterrupts(); // Deshabilita que se puedan producir interrupciones

for(int y=0;y<x;y++)

// TENSION REAL DE PICO

if (tension[y]>=513) // Nos quedamos con los semiciclos positivos

tensionreal =(tension[y]*0.49)-250;

if(tensionpico <= tensionreal)

tension_medido=tension[y]; // Guardamos el valor digital

tensionpico=tensionreal; // Guardamos el valor de pico real

// INTENSIDAD REAL DE PICO

if (intensidad[y]>=515) // Nos quedamos con los semiciclos positivos

intereal=((intensidad[y])*0.049)-25;

if (intensidadpico <= intereal)

inten_medido=intensidad[y]; // Guardamos el valor digital

intensidadpico=intereal; // Guardamos el valor de pico real

// CALCULO DE ANFULO FI

if ((tension[y]>=513 && TensionAnt<=513) && (flagFI!=0))



aux=0; // Variable para contar los intervalos

flagTension=1; // Variable para indicar la realización de la estructura

if ((intensidad[y]>=513 && IntensidadAnt<=513) && (flagTension))

angFIrad=(((1/(aux/1000))*2*PI)/50); // Cálculo del ángulo en radianes

angFI=(int)((angFIrad*180)/PI); // Cálculo del ángulo en grados

flagFI=1;

TensionAnt=tension[y]; // Actualizar valor de tensión

IntensidadAnt=intensidad[y]; // Actualizar valor de corriente

////// FOR

//POTENCIA ACTIVA (W)

PotActiva=(int)(tensionpico*intensidadpico*cos(angFI));

//POTENCIA REACTIVA (VAr)

PotReactiva=(int)(tensionpico*intensidadpico*sin(angFI));

//POTENCIA APARENTE (VA)

PotAparente=(int)(sqrt((PotActiva*PotActiva)+(PotReactiva*PotReactiva)));

//ENERGIA ACUMULADA (Ws)

if (flagEnergia==1)

tiempo=(millis()/1000)-tiempo; // Tiempo trascurrido

EnergiaReal=PotActiva*tiempo + EnergiaReal; // Cálculo de la energía

Energia=(int)(EnergiaReal); // Conversión a entero para mostrarlo en pantalla

tiempo=millis()/1000; // Nueva referencia de tiempo.

int intensidad_entero=(int)intensidadpico; // Parte entera

int intensidad_decimal=(int)((intensidadpico-intensidad_entero)*1000); // Parte decimal



nexLoop(nex_listen_list); // Para consultar si cambian los botones

if(flagPg==2) // Página 2

Serial.print("n1.val=");

Serial.print(tensionpico);

Funcion_ff();


Serial.print(intensidad_decimal);

Funcion_ff();


Serial.print(intensidad_entero);

Funcion_ff();


Serial.print(angFI);

Funcion_ff();



Serial.print(PotActiva);

Funcion_ff();


Serial.print(PotReactiva);

Funcion_ff();


Serial.print(PotAparente);

Funcion_ff();




Serial.print(Energia);

Funcion_ff();



Serial.print(tension_medido);

Funcion_ff();


Serial.print(tensionpico);

Funcion_ff();


Serial.print(inten_medido);

Funcion_ff();


Serial.print(intensidad_decimal);

Funcion_ff();


Serial.print(intensidad_entero);

Funcion_ff();


Serial.print(angFI);

Funcion_ff();


Serial.print(flagTension);

Funcion_ff();

x=0;



3. PLANOS

3.1. PLANO ESQUEMÁTICO

3.2. PLANO PCB PLANO DE MASA

3.3. PLANO PCB SERIGRAFÍA

3.4. PLANO PCB PISTAS Y PADS

3.5. PLANO PARTE SUPERIOR CAJETÍN

3.6. PLANO PARTE INFERIOR CAJETÍN



4. PRESUPUESTO

4.1. PRECIOS SIMPLES

Trasformador PCB 10VA 8.22€

Trasformador de corriente 25A 3.16€

Trasformador PCB 0.5VA 4.62€

Voltaje referencia 2.5V 2.52€

Amplificador LMC6482IN 1.57€

Arduino nano 20.00€

Pantalla Nextion 20.86€

Diodo 1N4004 0.12€

LM7805 0.36 €

Condensador electrolítico 470µF 0.10€

Condensador 100nF 0.06€

Condensador 330nF 0.21€

Potenciómetro 100Ω 0.17€

Resistencia 5% 0.04€

Resistencia 1% 0.10€

Clemas PCB 2 pines 0.23€

Tira de postes macho PCB 2unds 0.07€

Zócalo para amplificador 0.12€

Tira de postes Hembra PCC 40unds 0.52€

Alargador eléctrico 1m 1.80€

Fabricación PCB + envío 1.61€

Carrete estaño para soldar 19.93€

Tornillo y tuerca 0.10€

4.2. MANO DE OBRA

Operario 10.00€/h

PLA impreso 0.20€/g



4.3. UNIDADES DE OBRA

Ud. Montaje

Unidad montaje, en la que hay q realizar la colocación da cada componente,

según planos, par su soldadura. Deben de cortarse los etremos sobrantes de los

patillajes una vez soldados. El alargador eléctrico debe ser cortado y adaptado .Una

vez acabado esto, debe comprobarse continuidad de las patillas soldadas por el

circuito.

Descomposición en la siguiente tabla:

TÍTULO CANTIDAD PRECIO TOTAL

Fabricación PCB + envío 1 1.61€ 1.61€

Trasformador PCB 10VA 1 8.22€ 8.22€

Trasformador de corriente 25A 1 3.16€ 3.16€

Trasformador PCB 0.5VA 1 4.62€ 4.62€

Voltaje referencia 2.5V 1 2.52€ 2.52€

Amplificador LMC6482IN 1 1.57€ 1.57€

Arduino nano 1 20.00€ 20.00€

Pantalla Nextion 1 20.86€ 20.86€

Diodo 1N4004 4 0.12€ 0.48€

LM7805 1 0.36 € 0.36 €

Condensador electrolítico 470µF 1 0.10€ 0.10€

Condensador 100nF 3 0.06€ 0.18€

Condensador 330nF 1 0.21€ 0.21€

Potenciómetro 100Ω 1 0.17€ 0.17€

Resistencia 5% 8 (10KΩ) + 3(3.6KΩ) = 11

0.04€ 0.44€

Resistencia 1% 1 (100 Ω) 0.10€ 0.10€

Clemas PCB 2 pines 2 0.23€ 0.46€

Tira de postes macho PCB 2unds 3 0.07€ 0.21€

Zócalo para amplificador 1 0.12€ 0.12€

Tira de postes Hembra PCC 40unds 1 0.52€ 0.52€



Alargador eléctrico 1m 1 1.80€ 1.80€

Carrete estaño para soldar 0.25 19.93€ 4.99€

Operario 1.5h 10.00€/h 15.00€

TOTAL 87.70€

Tabla 4.1

Ud. Cajetín y acabado

Unidad para la realización del cajetín segun planos, mediante una impresora

3D. Una vez tenemos las piezas, el operario debe montar la placa, conectar los

cables y, mediante tornillos y tuercas, atornillar la pantalla y cerrar la caja.

Descomposición en la siguiente tabla:

TÍTULO CANTIDAD PRECIO TOTAL

PLA impreso 78g (parte arriba) + 43g (parte abajo) = 121g

0.20€/g 24.20€

Tornillo y tuerca 8 0.10€ 0.80€

Operario 0.5h 10.00€/h 5.00€

TOTAL 30.00€

Tabla 4.2

4.4. PRESUPUESTO TOTAL

UNIDAD DE OBRA CANTIDAD PRECIO TOTAL

Ud. Montaje 1 87.70€ 87.70€

Ud. Cajetín y acabado 1 30.00€ 30.00€

TOTAL 117.70€

Tabla 4.3

TOTAL: CIENTO DIECISIETE EUROS CON SETENTA CÉNTIMOS.

medidor de energÍa elÉctricatauja.ujaen.es/bitstream/10953.1/7459/1/tfg medidior de energia...

Documents