Node MCU es una plataforma para el desarrollo de proyectos IoT que integra el famoso chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source que pueden ademas pueden involucrar el IoT .
Esta placa destaca porque integra capacidades de comunicación via WiFi , conteniendo en su interior un microprocesador que puede ser programado fácilmente usando el conocido lenguaje de programación Lua o bien vía Arduino IDE.
Obviamente ante todo no podemos perder de vista su bajisimo precio ( menos de 7.5€ ) comparados con otras opciones , pues no debemos olvidar que incluye el modulo wifi integrado y un bus GPIO para conectar dispositivos de E/S. Node MCU es una plataforma de desarrollo permite un prototipado rápido, para una vez satisfechos con el resultado, portar el desarrollo a un sistema final con un chip ESP8266 como pieza central.
A la hora de programar nuevas funciones, si optamos por utilizar Lua, dispondremos de un sistema simple con buena comunidad de usuarios. En cambio programar con el sistema Arduino nos aporta un fantástico IDE y un sinfin de manuales y ejemplos de desarrollo.
Este modulo es Ideal como una solución independiente en lugar de Arduino además de Wi-Fi integrado siendo fácil de programar a través del IDE de Arduino (como vamos a ver ) , al igual que un Arduino. Todos los periféricos con bus I2C puede unirse,por ejemplo Pantallas OLED, pantallas LCD, temperatura, presión, sensores de humedad pueden ser conectados en paralelo. También se puede conectar múltiples DS18B20
Sin embargo, sólo hay una entrada analógica y salida y las pantallas táctiles no se pueden conectar con ella.
Es necesario instalar el controlador USB requerido en su ordenador para que pueda programar el ESP8266. Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de la computadora.
El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, para lo cual generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico.Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador.
Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de la computadora y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.
Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:
Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema) Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.
Ahora que estamos listos para comunicarnos con nuestro ESP8266 a través del CP2102, podemos explorar algunas de las diferentes opciones de firmware disponibles.
Conecte un cable usb de datos al ESP8266
Seleccione Herramientas –>ESP8266 y ahi la placa que haya comprado. En caso de haberla comprado en Amazon aqui seleccione NodeMCU 1.0 (ESP-12EModule).
En el IDE de Arduino, vaya al menú de herramientas, seleccionada su placa y elija el puerto al que está conectado su ESP8266.En el ejemplo es el COM11
Problemas al reconocer el puerto
En varios casos, la placa no se detecta debido a que faltan los controladores. Sin embargo, también puede ser por el puerto USB o el cable.
Si después de instalar los controladores sigue sin funcionar, por favor:
Verifique conectando la placa en otro puerto
Intente cambiar el cable USB de conexión por otro porque a veces aunque haya alimentación pueden fallar ( no olvidar que en un cable USB standard deberia haber 4 hilos)
Pruebae en otro ordenador distinta
Una vez dicho eso, veamos los controladores de NodeMCU 8266 en Windows.
Una vez que lo descargues, extraer el fichero comprimido con extension .zip. Tendrá un programa llamado CH341SER.EXE, ejecútelo y dale permisos de administrador.
En la siguiente ventana haz click en Install:
Espere a recibir la notificación de que se ha instalado y eso es todo. Debe detectar el dispositivo en un puerto COM; yo lo tenía en el COM4.
Conclusión
Es necesario mencionar que esto lo probé en Windows 10 de 64 bits usando PlatformIO dentro de Visual Studio Code, pero supongo que debe funcionar de igual modo en otras plataformas.
Cuando se habla de potencia en corriente alterna (CA), es más complicado, ya que implica forma de onda y diferencia de fase, pero básicamente, hay 3 términos para la alimentación de CA: la potencia aparente , la potencia activa y la potencia reactiva .
La potencia aparente se refiere a la potencia total en un circuito de CA que incluye la potencia disipada y absorbida. Este término es importante para el diseño de generadores de energía y cables para asegurarse de que todo el cableado y la energía puedan soportar todo tipo de cargas. La potencia aparente se puede calcular multiplicando el valor de voltaje de raíz cuadrada media (RMS) y el valor de corriente (RMS).
El segundo término es el Poder Activo / Real . Es la potencia real consumida por la carga. La potencia activa se puede calcular promediando el producto de los valores instantáneos de forma de onda de voltaje y corriente.
El tercer término es la potencia reactiva, que se refiere a la potencia que se desperdicia y que la carga no utiliza como trabajo útil debido a la diferencia de fase entre las formas de onda de voltaje y corriente. Cuando la potencia reactiva se suma a la potencia activa, le dará la potencia aparente.
Usaremos un Arduino para medir la potencia aparente y la potencia real por lo que para medir la energía de CA , necesitamos usar 2 sensores separados que son el módulo de voltaje de CA monofásico y el módulo de corriente de CA.
Cada módulo puede encajar en el pin de entrada analógica Arduino . Para un Arduino UNO, hay 6 pines de entrada analógicas (A0-A5)pero para un Arduino NANO tiene 8 pines, mientras que Arduino MEGA tiene 16 pines de entrada. Los pines de entrada analógica asignarán voltajes de entrada entre 0 y 5 V en valores enteros entre 0 y 1023 con una resolución de 4,9 mV por unidad (5,00 V / 1024 unidades).
!Cuidado ! Asumimos que tiene los conocimientos básicos de electricidad y sabe a qué se enfrenta. Es posible que necesite la orientación de personas con experiencia si es nuevo en el trabajo eléctrico. La seguridad y la precaución deben tenerse siempre en cuenta. No seremos responsables de nada que le suceda.
Puede medir voltaje CA como 110Vac, 220Vac y 240Vac mediante el uso de la disposición en el mercado individual Fase V de CA módulo de voltaje. Puede detectar la forma de onda instantánea para el valor de voltaje. La señal se puede utilizar con el sensor de corriente CA para determinar más información útil, como el factor de potencia, la dirección del flujo de corriente, la potencia real y la potencia aparente.
Es posible que deba precalibrar el módulo. Mediante el uso del potenciómetro trimpot, se puede ajustar la amplitud de la forma de onda de voltaje. Se recomienda utilizar un segundo medidor que lea el voltaje RMS para facilitar la calibración.
Módulo de voltaje CA monofásico
Este módulo ZMPT101 B está equipado con un transformador de voltaje de alta precisión ZMPT101B y un circuito de amplificador operacional. Puede medir voltaje CA dentro de 250V. La señal de salida correspondiente se puede ajustar utilizando el potenciómetro de ajuste.
Estas resumidamente algunas de sus características:
Módulo de transformador de voltaje monofásico activo Sensor de voltaje de salida de CA
Equipado con la serie ZMPT101B de transformador de voltaje de alta precisión y corriente de amplificador operacional de alta precisión, fácil de 250V dentro de la adquisición de señal de alimentación de CA
Transformador de voltaje: Transformador de micro voltaje de precisión a bordo
Salida de voltaje de modo: el módulo puede medir el voltaje de CA dentro de 250 V, el modo de salida correspondiente se puede ajustar
Circuito amplificador operacional: circuito amplificador integrado de alta precisión, la señal para hacer el muestreo exacto y la compensación adecuada y otras funciones
El sensor de Intensidad
El segundo sensor del que queremos hablar es el Módulo Sensor de Corriente. El sensor de corriente ampliamente utilizado que es compatible con Arduino es el módulo de sensor de corriente ACS712. Utiliza el fenómeno de efecto hall cuyo voltaje se produce a partir del movimiento de la corriente dentro de la región del campo magnético. El voltaje producido por el efecto hall es directamente proporcional a la corriente aplicada, lo que lo hace adecuado para estimar la corriente aplicada a partir del voltaje detectado.
El módulo de sensor de corriente estándar ACS712se vende en tres versiones de 5A, 20A y 30A que sons adecuadas para la mayoría de las aplicaciones. El módulo 5A tiene una resolución de 185 mV / amperio, el módulo 20A tiene 100 mV / amperio, mientras que el módulo 30A tiene una resolución de 66 mV / amperio.
Estos módulos requieren contacto directo, lo cual podria ser un gran inconveniente pues debe conectarse en serie al valor medido . El cableado del sistema existente debe modificarse para que el módulo encaje en el sistema existente.
Si no tiene experiencia con la alimentación de CA, personalmente no recomiendo este módulo. Este módulo es aceptable para CC de bajo voltaje, pero puede ser peligroso en CA si no se toma en serio ,por lo que una alternativa es usar un tipo de sensor de efecto Hall con transformador de núcleo dividido (como se muestra en la imagen de la izquierda). Es el móduloHSTS016L del sensor de núcleo dividido de efecto Hall . El modelo va desde 10A hasta 200A . Con el tipo de sensor de corriente de núcleo dividido, no se requiere alteración en el sistema existente. !!! El voltaje de salida de este sensor es de 2,5 V +/- 0,625 V con una precisión decente. Recomiendo encarecidamente este sensor para medir la corriente alterna en caso de no tener experiencia con BT.
Codigo arduino
Para fines de demostración, usaremos el sensor de núcleo dividido de efecto Hall que no requiere contacto eléctrico con el sistema de cableado existente, lo que definitivamente es una forma más segura !!!Las señales detectadas por Arduino están en valores analógicos. A continuación se muestran las señales detectadas por el voltaje (azul) y el sensor de corriente (rojo). Puede copiar el siguiente código para probar el suyo. Puede ver la forma de onda en Serial Plotter. Conecte el módulo de voltaje en el pin A2 de Arduino mientras que el módulo de corriente en el pin A3 . La magnitud del voltaje (onda azul) se puede calibrar mediante el módulo de voltaje de CA utilizando el potenciómetro integrado y se puede comparar con el voltímetro RMS de referencia. Para una onda sinusoidal pura como esta, el valor RMS en el voltímetro multiplicado por la raíz cuadrada 2 es igual al voltaje máximo(magnitud desde la mitad de la oscilación). La magnitud de la onda de corriente (onda roja) está sujeta a su carga aplicada. Puede modificar el código Arduino para aumentar su magnitud con fines de visualización. El patrón de onda de CA puede no ser 100% suave como una onda de voltaje y está sujeto a la carga sobre cómo se extrae la corriente. El cambio de fase o la diferencia de fase entre el voltaje y la corriente también están sujetos a la carga aplicada.
float vAnalogRead; float iAnalogRead; int voltageInputPin = A2; // Analog input pin for voltage sensor int currentInputPin = A3; // Analog input pin for current sensor int currentOffset = 0; // key in value for current offset setting int voltageOffset = 0; // key in value for voltage offset setting float virtualMagnification = 5; // to increase the magnification of current value in display
El punto medio para Ambas ondas debería estar técnicamente en 512 (valor analógico) y fluctúa entre 0 y 1023 de forma predeterminada. Sin embargo, he modificado el código para que las ondas oscilen en el punto medio del valor 0 entre 512 y -512 para facilitar el cálculo más adelante. Antes de continuar, es necesario realizar una calibración antes de la medición, ya que algunos módulos pueden tener un error de desviación diferente. Puede ir a la publicación de sensores individuales para obtener más información.
Cómo se procesa la señal
Necesitamos determinar los 2 valores de potencia de CA, el valor de potencia de CA RMS y el valor de potencia de CA activa . Antes de continuar, comencemos con la calibración inicial de ambos sensores. Necesitamos minimizar cualquier error potencial de desviación o inexactitud tanto como sea posible. Los sensores son muy sensibles, asegúrese de utilizar conectores ajustados y terminales de cable.
Necesitamos una calibración de 2 veces para cada sensor de módulo . Ambas calibraciones deben realizarse sin medir la corriente y el voltaje. La primera calibración es asegurarse de que cuando no se mide voltaje o corriente, se muestra exactamente en el punto 0. Es una calibración de valor analógico. Es posible que algunos módulos no se muestren exactamente en el valor analógico 512 (lo he cambiado al punto 0 usando el código Arduino para una fácil comprensión) cuando no se detecta ningún valor. Necesitamos agregar un valor de compensación para que esto vuelva a ajustarlo al origen cuando no se detecta ningún valor.
La segunda calibración es para eliminar aún más el valor de la señal falsa durante el cálculo RMS. Incluso después de que se realiza la primera calibración, todavía hay algún ruido fantasma o eléctrico menor incluso cuando no se miden voltaje ni corriente. Tenemos que agregar otro desplazamiento para llegar al valor cero en la etapa final de visualización. Esta segunda calibración debe realizarse solo después de que la primera calibración entre en vigor. Ambas calibraciones se pueden realizar manualmente (la forma más difícil) o automáticamente presionando el botón SELECT en el protector de la pantalla LCD y espere unos 5 segundos. Por eso es necesario tener el escudo para que funcione. ¡Puede comprar en nuestro enlace de afiliado aquí !
El cálculo de la potencia cuadrática media de la raíz
La potencia de CA RMS es el producto de los valores de voltaje CA RMS y corriente CA RMS . El voltaje CA RMS y la corriente CA RMS se calculan por separado. Al encontrar la potencia de CA RMS, el voltaje RMS y la corriente RMS se encuentran indirectamente.
Nuestro código está diseñado para calcular o mostrar un valor que se deriva de un promedio de 1000 muestras por conjunto. Encontré un problema de que un tiempo de grabación de muestra más corto (menos de 1 milisegundo para 1 lectura de muestra) podría retrasar el tiempo de procesamiento, lo que hizo que el tiempo de visualización se ralentizara. He configurado que cada muestra se registre cada 1 milisegundo (0,001 segundos). En otras palabras, el conjunto completo total equivale a 50 ondas con cada onda dividida en 20 secciones o lecturas (para 50 Hz). Técnicamente, debería durar 1 segundo para 1 conjunto de lectura. También es adecuado para el sistema de 60 Hz, ya que el tiempo de medición para 1 juego de lectura es de 1 segundo.
Cada valor analógico de muestra individual se eleva al cuadrado inicialmente y una vez que se acumulan los valores de 1000 muestras , el valor promedio de las 1000 muestras se establece en raíz cuadrada para obtener el valor analógico RMS (para 1 sensor). Convierta el valor analógico RMS en voltaje medido o valor actual. Realice el cálculo similar por separado para el otro sensor y multiplique ambos valores RMS para convertirlos en energía CA RMS. A continuación se muestra un ejemplo de cómo funciona el código. Tomo un cuarto de onda como ejemplo .
En la conversión de voltaje RMS , multiplico el valor analógico RMS por 2 . Durante la calibración de este módulo, reduje la amplitud de onda a la mitad (es por eso que en el código es necesario multiplicar por 2) porque la onda de voltaje comenzó a distorsionarse o cortarse cerca de 250Vac, lo que puede dar inexactitud en la medición. Puede aumentar el voltaje de suministro al módulo para eliminar el efecto de corte (según el manual del módulo) pero creo que lo dejaré así ya que no voy a agregar suministro de voltaje adicional. En cuanto a la conversión de corriente RMS, el mV / A es la clasificación del sensor de corriente y lo dejo como el símbolo de la unidad. 1023 es la conversión de valor analógico, mientras que 5000 es el valor de voltaje en mV. Para obtener más información sobre esto, puede ir a mi publicación sobre el sensor de CA aquí..
El cálculo de la potencia instantánea
Active o Real Power es más simple en comparación con RMS Power. Es el valor promedio de todas las multiplicaciones de voltaje instantáneo y valor de corriente instantánea . Los valores analógicos de tensión y corriente se convierten primero en valores de tensión y corriente medidos . Luego, el voltaje se multiplica por su valor de corriente instantánea y se convierte en una lectura de muestra.
Similar al método de potencia RMS, la potencia activa también se deriva de un promedio de 1000 muestras por conjunto. Cada muestra se registra cada milisegundo, es decir, el conjunto completo total equivale a 50 ondas con cada onda dividida en 20 secciones o lecturas (para 50 Hz).
Puede ser interesante añadir una pantalla LCD de 16X2 que se puede colocar directamente en la parte superior de la placa Arduino sin la necesidad de cableado adicional para la pantalla LCD. Sin la pantalla LCD, solo puede monitorear el valor de corriente medido en la PC a través del Monitor en serie.
La buena noticia es que no necesita calibrar manualmente la configuración de compensación si tiene lapantalla LCDcon usted. A continuación, adjuntamos el código que utiliza la función del botón que podría calibrarse automáticamente por sí mismo cuando presionó el botón SELECT . Puede descargar desde el final de esta página a continuación.
Conexión de hardware
Es posible que deba encontrar una manera de colocar el cable del sensor de CA en el pin Arduino. El cable del sensor que compré venía presoldado en la punta, lo que facilita el acceso a los pines de Arduino. Abra el módulo de corriente Split Core y se mostrará un símbolo de flecha que indica el camino del flujo de corriente. Una vez que todo esté listo, asegúrese de que el núcleo partido esté bien cerrado.
Asegúrese de que debajo del sensor de voltaje no haya conductores expuestos o placas de metal que puedan causarle un cortocircuito accidental en el terminal del módulo. Debe obtener el fusible rápido de baja corriente para el cable del sensor de voltaje, mientras que el MCB o el fusible de corriente nominal suficiente según su carga para protegerlo contra cualquier posible cortocircuito y riesgo de incendio.
Para conectar el cableado entre la placa Arduino y el módulo, necesita los cables de línea dupont macho a hembra . ¡Puedes conseguirlo en nuestro enlace de afiliado aquí !
Necesita el conector que pueda asegurar los cables y aislarlos del contacto accidental. ¡Obtenga el conector rápido en nuestro enlace de afiliado aquí !
Código final Arduino
El paso final sería agregar el código fuente a la placa Arduino. Supongo que ha instalado el software Arduino. Si no ha instalado el software, el enlace aquí puede llevarlo al sitio oficial de descarga. Una vez que haya descargado el software, puede descargar el archivo de código (.ino) para esta aplicación a continuación (haga clic con el botón derecho en el enlace para guardar).
Hay 2 archivos de códigos fuente adjuntos que son código fuente con y sin función de protección de pantalla LCD. Si no tiene el protector de pantalla LCD con usted, elija el código que no tiene el protector de pantalla LCD, pero debe calibrar manualmente e ingresar los 2 valores de compensación para ambos sensores. Sin embargo, le recomiendo encarecidamente que obtenga un protector de pantalla LCD.
Con el protector de pantalla LCD, una vez que el código se carga en la placa Arduino, el valor actual se mostrará en la pantalla LCD. Hemos agregado la función de autocalibrado, una vez que se presiona el botón SELECT, el valor regresa al punto cero exacto. Puede que tenga que esperar entre 5 y 8 segundos hasta que se vuelvan a calibrar todos los valores. Si la primera pulsación no está satisfecha, puede repetir pulsando de nuevo .
Proceso de calibracion
Una vez que el código se carga en el Arduino, si tiene un protector de pantalla LCD adjunto, verá la corriente, el voltaje, la potencia activa y el valor de potencia aparente. Asegúrese de apagar la fuente de voltaje de CA que está midiendo. Presione el botón SELECT del protector de pantalla LCD y espere 5 segundos. Debería llegar a 0 voltios . Lo mismo para la corriente CA que muestra 0A . Para las personas que no tienen el protector de pantalla LCD, puede compensar manualmente ingresando el valor de compensación en el código y volver a cargarlo. Hay 2 valores de compensación (voltageOffset1 y voltageOffset2) que se deben calibrar. Haga lo mismo para el módulo de corriente CA para 2 valores de compensación (currentOffset1 y currentOffset2) y finalmente es el powerOffset.
Ajuste de voltaje de CA del potenciómetro de trimpot
Esta configuración es para ajustar la magnitud de la onda de voltaje de CA. A diferencia de la corriente CA, calculamos y obtenemos la corriente esperada, pero para el voltaje CA, necesitamos un voltaje de referencia para el ajuste.
Una vez realizada la calibración, debería ver el valor 0 voltios cuando no se detecta voltaje. Ahora, encienda la fuente de voltaje y encienda el lector de voltaje de referencia (el multímetro o el medidor de energía). Compare ambos valores de voltaje. Gire el potenciómetro de ajuste (trimpot) con un destornillador pequeño para reducir o aumentar el valor de voltaje detectado por Arduino. Debe girar el potenciómetro hasta que el voltaje que se muestra en la pantalla LCD Shield o Monitor serial sea el mismo que el valor de referencia de voltaje en el medidor de voltaje o energía. ¡¡¡Y felicitaciones, ya está hecho !!!!
Si realmente lee los códigos, en realidad hemos reducido la amplitud de onda potencial a la mitad (en la fórmula es por 2).
RMSVoltageMean = (sqrt (voltageMean)) * 2;
Es por eso que cuando se aplica voltaje de monitoreo, el valor medido es alto y es necesario reducirlo. La amplitud de onda completa (x 1) se distorsiona cuando está cerca de 250 V, lo que nos hizo tener esta opción para superar el problema de distorsión.
Resultado: en monitor de serie
Para archivos de código Arduino, recuerde hacer clic derecho> Guardar enlace como … Puede modificar el código interno como desee. ¡Feliz codificación!
AC Power.ino
// AC Power Monitoring By Solarduino
// Note Summary
// Note : Safety is very important when dealing with electricity. We take no responsibilities while you do it at your own risk.
// Note : This AC Power Monitoring Code needs AC current module and AC Voltage Module to determine AC Power value.
// Note : This Code monitors RMS Voltage, RMS current, RMS AC Power (Apparent Power) and Instantaneous AC Power (Active Power)
// Note : The value shown in Serial Monitor is refreshed every second, can be used for 50Hz and 60Hz.
// Note : The frequency is measured by counting time and average it for every 50 samples taken (1 sample is 1 cycle for 50Hz by default).
// Note : You have to manually calibrate 5 offsets readings : voltageOffset1,voltageOffset2,currentOffset1,currentOffset2 & powerOffset.
// Note : The unit provides reasonable accuracy and may not be comparable with other expensive branded and commercial product.
// Note : All credit shall be given to Solarduino.
/*/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/////////////*/
/* 0- General */
int decimalPrecision = 2; // decimal places for all values shown in LED Display & Serial Monitor
/* 1- AC Voltage Measurement */
int voltageOffset1 = 0; // key in offset value
int voltageOffset2 = 0; // key in offset value
int VoltageAnalogInputPin = A2; // Which pin to measure voltage Value
float voltageSampleRead = 0; /* to read the value of a sample*/
float voltageLastSample = 0; /* to count time for each sample. Technically 1 milli second 1 sample is taken */
float voltageSampleSum = 0; /* accumulation of sample readings */
float voltageSampleCount = 0; /* to count number of sample. */
float voltageMean ; /* to calculate the average value from all samples*/
float RMSVoltageMean ; /* square roof of voltageMean*/
/* 2- AC Current Measurement */
int currentOffset1 = 0; // key in offset value
int currentOffset2 = 0; // key in offset value
int CurrentAnalogInputPin = A3; // Which pin to measure Current Value
float mVperAmpValue = 31.25; // If using ACS712 current module : for 5A module key in 185, for 20A module key in 100, for 30A module key in 66
// If using "Hall-Effect" Current Transformer, key in value using this formula: mVperAmp = maximum voltage range (in milli volt) / current rating of CT
/* For example, a 20A Hall-Effect Current Transformer rated at 20A, 2.5V +/- 0.625V, mVperAmp will be 625 mV / 20A = 31.25mV/A */
float currentSampleRead = 0; /* to read the value of a sample*/
float currentLastSample = 0; /* to count time for each sample. Technically 1 milli second 1 sample is taken */
float currentSampleSum = 0; /* accumulation of sample readings */
float currentSampleCount = 0; /* to count number of sample. */
float currentMean ; /* to calculate the average value from all samples*/
float RMSCurrentMean =0 ; /* square roof of currentMean*/
float FinalRMSCurrent ; /* the final RMS current reading*/
/* 3- AC Power Measurement */
int powerOffset =0; // key in offset value
float sampleCurrent1 ; /* use to calculate current*/
float sampleCurrent2 ; /* use to calculate current*/
float sampleCurrent3 ; /* use to calculate current*/
float apparentPower; /* the apparent power reading (VA) */
float realPower = 0; /* the real power reading (W) */
float powerSampleRead = 0; /* to read the current X voltage value of a sample*/
float powerLastSample = 0; /* to count time for each sample. Technically 1 milli second 1 sample is taken */
float powerSampleCount = 0; /* to count number of sample. */
float powerSampleSum = 0; /* accumulation of sample readings */
float powerFactor = 0; /* to display power factor value*/
void setup() /*codes to run once */
{
/* 0- General */
Serial.begin(9600); /* to display readings in Serial Monitor at 9600 baud rates */
}
void loop() /*codes to run again and again */
{
/* 1- AC Voltage Measurement */
if(millis() >= voltageLastSample + 1 ) /* every 1 milli second taking 1 reading */
{
voltageSampleRead = 2*(analogRead(VoltageAnalogInputPin)- 512) + voltageOffset1; /* read the sample value */
voltageSampleSum = voltageSampleSum + sq(voltageSampleRead) ; /* accumulate value with older sample readings*/
voltageSampleCount = voltageSampleCount + 1; /* to move on to the next following count */
voltageLastSample = millis() ; /* to reset the time again so that next cycle can start again*/
}
if(voltageSampleCount == 1000) /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
{
voltageMean = voltageSampleSum/voltageSampleCount; /* calculate average value of all sample readings taken*/
RMSVoltageMean = sqrt(voltageMean)+ voltageOffset2; /* square root of the average value*/
Serial.print("Voltage RMS: ");
Serial.print(RMSVoltageMean,decimalPrecision);
Serial.println("V ");
voltageSampleSum =0; /* to reset accumulate sample values for the next cycle */
voltageSampleCount=0; /* to reset number of sample for the next cycle */
}
/* 2- AC Current Measurement */
if(millis() >= currentLastSample + 1) /* every 1 milli second taking 1 reading */
{
currentSampleRead = analogRead(CurrentAnalogInputPin)-512 + currentOffset1; /* read the sample value */
currentSampleSum = currentSampleSum + sq(currentSampleRead) ; /* accumulate value with older sample readings*/
currentSampleCount = currentSampleCount + 1; /* to move on to the next following count */
currentLastSample = millis(); /* to reset the time again so that next cycle can start again*/
}
if(currentSampleCount == 1000) /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
{
currentMean = currentSampleSum/currentSampleCount; /* calculate average value of all sample readings taken*/
RMSCurrentMean = sqrt(currentMean)+currentOffset2 ; /* square root of the average value*/
FinalRMSCurrent = (((RMSCurrentMean /1024) *5000) /mVperAmpValue); /* calculate the final RMS current*/
Serial.print("Current RMS: ");
Serial.print(FinalRMSCurrent,decimalPrecision);
Serial.println(" A ");
currentSampleSum =0; /* to reset accumulate sample values for the next cycle */
currentSampleCount=0; /* to reset number of sample for the next cycle */
}
/* 3- AC Power with Direction */
if(millis() >= powerLastSample + 1) /* every 1 milli second taking 1 reading */
{
sampleCurrent1 = analogRead(CurrentAnalogInputPin)-512+ currentOffset1;
sampleCurrent2 = (sampleCurrent1/1024)*5000;
sampleCurrent3 = sampleCurrent2/mVperAmpValue;
voltageSampleRead = 2*(analogRead(VoltageAnalogInputPin)- 512)+ voltageOffset1 ;
powerSampleRead = voltageSampleRead * sampleCurrent3 ; /* real power sample value */
powerSampleSum = powerSampleSum + powerSampleRead ; /* accumulate value with older sample readings*/
powerSampleCount = powerSampleCount + 1; /* to move on to the next following count */
powerLastSample = millis(); /* to reset the time again so that next cycle can start again*/
}
if(powerSampleCount == 1000) /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
{
realPower = ((powerSampleSum/powerSampleCount)+ powerOffset) ; /* calculate average value of all sample readings */
Serial.print("Real Power (W): ");
Serial.print(realPower);
Serial.println(" W ");
apparentPower= FinalRMSCurrent*RMSVoltageMean; /*Apparent power do not need to recount as RMS current and RMS voltage values available*/
Serial.print("Apparent Power (VA): ");
Serial.print(apparentPower,decimalPrecision);
Serial.println(" VA ");
powerFactor = realPower/apparentPower;
if(powerFactor >1 || powerFactor<0)
{
powerFactor = 0;
}
Serial.print("Power Factor: ");
Serial.println(powerFactor,decimalPrecision);
Serial.println(" ");
powerSampleSum =0; /* to reset accumulate sample values for the next cycle */
powerSampleCount=0; /* to reset number of sample for the next cycle */
}
}
lcd (AP Power with LCD Disply.ino)
// AC Power Monitoring with LCD By Solarduino
// Note Summary
// Note : Safety is very important when dealing with electricity. We take no responsibilities while you do it at your own risk.
// Note : This AC Power Monitoring Code needs AC current module and AC Voltage Module to determine AC Power value.
// Note : This Code monitors RMS Voltage, RMS current, RMS AC Power (Apparent Power) and Instantaneous AC Power (Active Power)
// Note : The value shown in Serial Monitor is refreshed every second, can be used for 50Hz and 60Hz.
// Note : The frequency is measured by counting time and average it for every 25 samples taken (1 sample is 1 cycle).
// Note : The auto calibration (voltageOffset1 & currentOffset1) is using averaged analogRead value of 1000 samples.
// Note : The auto calibration (voltageOffset2 & currentOffset2) is using calculated RMS value including Offset1 value for calibration.
// Note : The unit provides reasonable accuracy and may not be comparable with other expensive branded and commercial product.
// Note : All credit shall be given to Solarduino.
/*/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/////////////*/
/* 0- General */
int decimalPrecision = 2; // decimal places for all values shown in LED Display & Serial Monitor
/* 1- AC Voltage Measurement */
int VoltageAnalogInputPin = A2; // Which pin to measure voltage Value
float voltageSampleRead = 0; /* to read the value of a sample*/
float voltageLastSample = 0; /* to count time for each sample. Technically 1 milli second 1 sample is taken */
float voltageSampleSum = 0; /* accumulation of sample readings */
float voltageSampleCount = 0; /* to count number of sample. */
float voltageMean ; /* to calculate the average value from all samples*/
float RMSVoltageMean ; /* square roof of voltageMean*/
/*1.1 Offset AC Voltage */
int voltageOffsetRead = 0; /* to change the mode for offset */
float voltageOffset1 = 0; // to Offset deviation and accuracy. Offset any fake current when no current operates.
// Offset will automatically callibrate when SELECT Button on the LCD Display Shield is pressed.
// If you do not have LCD Display Shield, look into serial monitor to add or minus the value manually and key in here.
float voltageOffset2 = 0; // to offset value due to calculation error from squared and square root.
float voltageSampleSumOffset =0; /* accumulation of sample readings for offset */
float offsetVoltageMean = 0; /* to calculate the average value from all samples for offset, in analog values*/
float voltageOffsetLastSample = 0; /* to count time for each sample for offset purpose. */
float voltageOffsetSampleCount = 0; /* to count number of sample for offset. */
/* 2- AC Current Measurement */
int CurrentAnalogInputPin = A3; // Which pin to measure Current Value
float mVperAmpValue = 31.25; // If using ACS712 current module : for 5A module key in 185, for 20A module key in 100, for 30A module key in 66
// If using "Hall-Effect" Current Transformer, key in value using this formula: mVperAmp = maximum voltage range (in milli volt) / current rating of CT
/* For example, a 20A Hall-Effect Current Transformer rated at 20A, 2.5V +/- 0.625V, mVperAmp will be 625 mV / 20A = 31.25mV/A */
float currentSampleRead = 0; /* to read the value of a sample*/
float currentLastSample = 0; /* to count time for each sample. Technically 1 milli second 1 sample is taken */
float currentSampleSum = 0; /* accumulation of sample readings */
float currentSampleCount = 0; /* to count number of sample. */
float currentMean ; /* to calculate the average value from all samples*/
float RMSCurrentMean =0 ; /* square roof of currentMean*/
float FinalRMSCurrent ; /* the final RMS current reading*/
/*2.1 Offset AC Current */
int currentOffsetRead = 0; /* to change the mode for offset */
float currentOffset1 = 0; // to Offset deviation and accuracy. Offset any fake current when no current operates.
// Offset will automatically callibrate when SELECT Button on the LCD Display Shield is pressed.
// If you do not have LCD Display Shield, look into serial monitor to add or minus the value manually and key in here.
// 26 means add 26 to all analog value measured
float currentOffset2 = 0; // to offset value due to calculation error from squared and square root.
float currentSampleSumOffset = 0; /* accumulation of sample readings for offset */
float offsetCurrentMean = 0; /* to calculate the average value from all samples for offset, in analog values*/
float currentOffsetLastSample = 0; /* to count time for each sample for offset purpose. */
float currentOffsetSampleCount = 0; /* to count number of sample for offset. */
/* 3- AC Power Measurement */
float sampleCurrent1 ; /* use to calculate current*/
float sampleCurrent2 ; /* use to calculate current*/
float sampleCurrent3 ; /* use to calculate current*/
float apparentPower; /* the apparent power reading (VA) */
float realPower = 0; /* the real power reading (W) */
float powerSampleRead = 0; /* to read the current X voltage value of a sample*/
float powerLastSample = 0; /* to count time for each sample. Technically 1 milli second 1 sample is taken */
float powerSampleCount = 0; /* to count number of sample. */
float powerSampleSum = 0; /* accumulation of sample readings */
float powerFactor = 0; /* to display power factor value*/
/*3.1 Offset AC Power */
int powerOffsetRead = 0; /* to change the mode for offset */
float powerOffset = 0; // to Offset deviation and accuracy. Offset any fake current when no current operates.
// Offset will automatically callibrate when SELECT Button on the LCD Display Shield is pressed.
// If you do not have LCD Display Shield, look into serial monitor to add or minus the value manually and key in here.
float powerOffsetLastSample = 0; /* to count time for each sample for offset purpose. */
float powerOffsetSampleCount = 0; /* to count number of sample for offset. */
/* 4 - LCD Display */
#include<LiquidCrystal.h> /* Load the liquid Crystal Library (by default already built-it with arduino solftware)*/
LiquidCrystal LCD(8,9,4,5,6,7); /* Creating the LiquidCrystal object named LCD. The pin may be varies based on LCD module that you use*/
unsigned long startMillisLCD; /* start counting time for LCD Display */
unsigned long currentMillisLCD; /* current counting time for LCD Display */
const unsigned long periodLCD = 1000; // refresh every X seconds (in seconds) in LED Display. Default 1000 = 1 second
int page = 1; /* flip page to display values*/
void setup() /*codes to run once */
{
/* 0- General */
Serial.begin(9600); /* to display readings in Serial Monitor at 9600 baud rates */
/* 4 - LCD Display */
LCD.begin(16,2); /* Tell Arduino that our LCD has 16 columns and 2 rows*/
LCD.setCursor(0,0); /* Set LCD to start with upper left corner of display*/
startMillisLCD = millis(); /* Start counting time for LCD display*/
}
void loop() /*codes to run again and again */
{
/* 0- General */
/* 0.1- Button Function */
int buttonRead;
buttonRead = analogRead (0); // Read analog pin A0. Pin A0 automatically assigned for LCD Display Button function (cannot be changed)
/*Right button is pressed */
if (buttonRead < 60)
{ LCD.setCursor(0,0); LCD.print ("PRESS <SELECT> "); }
/* Up button is pressed */
else if (buttonRead < 200)
{
page = 1;
}
/* Down button is pressed */
else if (buttonRead < 400)
{
page = 2;
}
/* Left button is pressed */
else if (buttonRead < 600)
{ LCD.setCursor(0,0); LCD.print ("PRESS <SELECT> "); }
/* Select button is pressed */
else if (buttonRead < 800)
{
currentOffsetRead = 1; // to activate offset for current
voltageOffsetRead = 1; // to activate offset for voltage
powerOffsetRead = 1; // to activate offset for power
LCD.setCursor(0,0); /* set display words starting at upper left corner*/
LCD.print ("INITIALIZING..... ");
LCD.setCursor(0,1); /* set display words starting at lower left corner*/
LCD.print ("WAIT 5 SEC ..... ");
}
/* 1- AC Voltage Measurement */
if(millis() >= voltageLastSample + 1 ) /* every 1 milli second taking 1 reading */
{
voltageSampleRead = 2*(analogRead(VoltageAnalogInputPin)- 512) + voltageOffset1; /* read the sample value */
voltageSampleSumOffset = voltageSampleSumOffset + voltageSampleRead; /* values accumulate for offset purpose every milli second */
voltageSampleSum = voltageSampleSum + sq(voltageSampleRead) ; /* accumulate value with older sample readings*/
voltageSampleCount = voltageSampleCount + 1; /* to move on to the next following count */
voltageLastSample = millis() ; /* to reset the time again so that next cycle can start again*/
}
if(voltageSampleCount == 1000) /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
{
offsetVoltageMean = voltageSampleSumOffset/voltageSampleCount; /* average the offset reading*/
voltageMean = voltageSampleSum/voltageSampleCount; /* calculate average value of all sample readings taken*/
RMSVoltageMean = sqrt(voltageMean)+ voltageOffset2; /* square root of the average value*/
Serial.print(" The Voltage RMS value is: ");
Serial.print(RMSVoltageMean,decimalPrecision);
Serial.println(" V ");
voltageSampleSum =0; /* to reset accumulate sample values for the next cycle */
voltageSampleCount=0; /* to reset number of sample for the next cycle */
voltageSampleSumOffset=0;
}
/* 1.1 - Offset AC Voltage */
if(voltageOffsetRead == 1) /* Run this code when button SELECT is pressed */
{
voltageOffset1 = 0;
if(millis()>= voltageOffsetLastSample + 1) /* keep countng time for offset1*/
{
voltageOffsetSampleCount = voltageOffsetSampleCount + 1; /* 1 milli second add 1 count*/
voltageOffsetLastSample = millis(); /* to reset the time again so that next cycle can start again*/
}
if(voltageOffsetSampleCount == 2000) /* after 2 seconds, run this codes. */
{
voltageOffset1 = -1*(offsetVoltageMean); /* set the offset values */
voltageOffsetRead = 2; /* go for second offset Settings */
voltageOffsetSampleCount = 0; /* to reset the time again so that next cycle can start again */
}
}
if(voltageOffsetRead == 2) /* Run this code after first offset done */
{
voltageOffset2 = 0; /* set back currentOffset2 as default*/
if(millis()>= voltageOffsetLastSample + 1) /* keep countng time for offset2*/
{
voltageOffsetSampleCount = voltageOffsetSampleCount + 1;
voltageOffsetLastSample = millis();
}
if(voltageOffsetSampleCount == 2000) /* after 2 seconds, run this codes. */
{
voltageOffset2 = - RMSVoltageMean; /* set the offset values */
voltageOffsetRead = 0; /* change the offset mode to original, wait until the button is pressed again */
voltageOffsetSampleCount = 0; /* to reset the time again so that next cycle can start again */
}
}
/* 2- AC Current Measurement */
if(millis() >= currentLastSample + 1) /* every 1 milli second taking 1 reading */
{
currentSampleRead = analogRead(CurrentAnalogInputPin)-512 + currentOffset1; /* read the sample value */
currentSampleSumOffset = currentSampleSumOffset + currentSampleRead; /* accumulate offset value */
currentSampleSum = currentSampleSum + sq(currentSampleRead) ; /* accumulate value with older sample readings*/
currentSampleCount = currentSampleCount + 1; /* to move on to the next following count */
currentLastSample = millis(); /* to reset the time again so that next cycle can start again*/
}
if(currentSampleCount == 1000) /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
{
offsetCurrentMean = currentSampleSumOffset/currentSampleCount; /* average offset value*/
currentMean = currentSampleSum/currentSampleCount; /* calculate average value of all sample readings taken*/
RMSCurrentMean = sqrt(currentMean)+currentOffset2 ; /* square root of the average value*/
FinalRMSCurrent = (((RMSCurrentMean /1024) *5000) /mVperAmpValue); /* calculate the final RMS current*/
Serial.print(" The Current RMS value is: ");
Serial.print(FinalRMSCurrent,decimalPrecision);
Serial.println(" A ");
currentSampleSum =0; /* to reset accumulate sample values for the next cycle */
currentSampleCount=0; /* to reset number of sample for the next cycle */
currentSampleSumOffset=0; /* to reset accumulate offset value for the next cycle*/
}
/* 2.1 - Offset AC Current */
if(currentOffsetRead == 1) /* Run this code when button SELECT is pressed */
{
currentOffset1 = 0; /* set currentOffset back to default value*/
if(millis()>= currentOffsetLastSample + 1) /* keep countng time for offset1*/
{
currentOffsetSampleCount = currentOffsetSampleCount + 1;
currentOffsetLastSample = millis();
}
if(currentOffsetSampleCount == 2000) /* after 2 seconds, run this codes. */
{
currentOffset1 = - offsetCurrentMean; /* set the offset values */
currentOffsetRead = 2; /* go for second offset Settings */
currentOffsetSampleCount = 0; /* to reset the time again so that next cycle can start again */
}
}
if(currentOffsetRead == 2) /* Run this code after first offset done */
{
currentOffset2 = 0; /* set back currentOffset2 as default*/
if(millis()>= currentOffsetLastSample + 1) /* keep countng time for offset2*/
{
currentOffsetSampleCount = currentOffsetSampleCount + 1;
currentOffsetLastSample = millis();
}
if(currentOffsetSampleCount == 2000) /* after 2 seconds, run this codes. */
{
currentOffset2 = - RMSCurrentMean; /* set the offset values */
currentOffsetRead = 0; /* change the offset mode to original, wait until the button is pressed again */
currentOffsetSampleCount = 0; /* to reset the time again so that next cycle can start again */
}
}
/* 3- AC Power with Direction */
if(millis() >= powerLastSample + 1) /* every 1 milli second taking 1 reading */
{
sampleCurrent1 = analogRead(CurrentAnalogInputPin)-512+ currentOffset1;
sampleCurrent2 = (sampleCurrent1/1024)*5000;
sampleCurrent3 = sampleCurrent2/mVperAmpValue;
voltageSampleRead = 2*(analogRead(VoltageAnalogInputPin)- 512)+ voltageOffset1 ;
powerSampleRead = voltageSampleRead * sampleCurrent3 ; /* real power sample value */
powerSampleSum = powerSampleSum + powerSampleRead ; /* accumulate value with older sample readings*/
powerSampleCount = powerSampleCount + 1; /* to move on to the next following count */
powerLastSample = millis(); /* to reset the time again so that next cycle can start again*/
}
if(powerSampleCount == 1000) /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
{
realPower = ((powerSampleSum/powerSampleCount)+ powerOffset) ; /* calculate average value of all sample readings */
Serial.print(" The Real Power (W) is: ");
Serial.print(realPower);
Serial.println(" W ");
apparentPower= FinalRMSCurrent*RMSVoltageMean; /*Apparent power do not need to recount as RMS current and RMS voltage values available*/
Serial.print(" The Apparent Power (VA) is: ");
Serial.print(apparentPower,decimalPrecision);
Serial.println(" VA ");
powerFactor = realPower/apparentPower;
if(powerFactor >1 || powerFactor<0)
{
powerFactor = 0;
}
Serial.print(" The Power Factor is: ");
Serial.println(powerFactor,decimalPrecision);
powerSampleSum =0; /* to reset accumulate sample values for the next cycle */
powerSampleCount=0; /* to reset number of sample for the next cycle */
}
/* 3.1 - Offset AC Power */
if(powerOffsetRead == 1) /* Run this code after first offset done */
{
powerOffset = 0; /* set back currentOffset2 as default*/
if(millis()>= powerOffsetLastSample + 1) /* keep countng time for offset2*/
{
powerOffsetSampleCount = powerOffsetSampleCount + 1;
powerOffsetLastSample = millis();
}
if(powerOffsetSampleCount == 5000) /* after 5 seconds, run this codes. */
{
powerOffset = -realPower;
powerOffsetRead = 0; /* change the offset mode to original, wait until the button is pressed again */
powerOffsetSampleCount = 0; /* to reset the time again so that next cycle can start again */
}
}
/* 4 - LCD Display */
currentMillisLCD = millis(); /* Set current counting time */
if (currentMillisLCD - startMillisLCD >= periodLCD && page ==1) /* for every x seconds, run the codes below*/
{
LCD.setCursor(0,0); /* Set cursor to first colum 0 and second row 1 */
LCD.print("I=");
LCD.print(FinalRMSCurrent,decimalPrecision); /* display current value in LCD in first row */
LCD.print("A ");
LCD.print("V=");
LCD.print(RMSVoltageMean,decimalPrecision); /* display current value in LCD in first row */
LCD.print("V ");
LCD.setCursor(0,1);
LCD.print(realPower,decimalPrecision);
LCD.print("W ");
LCD.print(apparentPower,decimalPrecision); /* display current value in LCD in first row */
LCD.print("VA ");
startMillisLCD = currentMillisLCD ; /* Set the starting point again for next counting time */
}
if( currentMillisLCD - startMillisLCD >= periodLCD && page ==2)
{
LCD.setCursor(0,0); /* Set cursor to first colum 0 and second row 1 */
LCD.print("PF=");
LCD.print(powerFactor,decimalPrecision);
LCD.print(" ");
LCD.setCursor(0,1);
LCD.print(" ");
startMillisLCD = currentMillisLCD ; /* Set the starting point again for next counting time */
}
}
La plataforma FIWARE surgió en el año 2014 aproximadamente a partir de las propuestas del Horizonte 2020 de la Unión Europea. Se trata de un intento de estandarizar una nube que permita conectar el IoT estando ya finalizado, aunque su desarrollo continúa siendo dirigido por la propia comunidad de FIWARE. Si estudiamos el interés en esta plataforma, encontramos que su inicio fue explosivo, debido a la gran aglomeración de empresas y noticias que generaron contenido y búsquedas en su planteamiento, desarrollo y lanzamiento, que después se vio reducido. Sin embargo, podemos empezar a observar un leve repunte en el interés por esta plataforma, ya que algunas empresas como Telefónica buscan convertirlo en el estándar de facto mediante su uso, que comenzó a impulsarse en 2015
Para lograr esta conectividad de elementos y a su vez permitir la adición de otras funcionalidades, el elemento principal de la nube de FIWARE es el llamado ORION Context Broker, un intermediario que permite la conectividad a todo tipo de elementos, bien mediante su API NGSI que emplea REST, o bien mediante agentes. Estos agentes no son más que módulos intermediarios que pueden traducir otros formatos o protocolos de comunicación a NGSI, de manera que se posibilita de esta forma la conectividad con otros dispositivos que no puedan establecer comunicaciones mediante REST.
Por otro lado, aplicaciones externas de desarrolladores pueden comunicarse con Orion a través de la API REST mencionada.
Todos los componentes de FIWARE son, según su propia nomenclatura, denominados Generic Enablers (GEs), dado que proveen nuevas características al sistema que otros componentes no pueden ofrecer: persistencia de los datos, comunicación, autenticación segura, etc. 2.2.1 Cosmos Uno de los GE disponibles en FIWARE es Cosmos destinado a permitir el análisis Big Data una vez que los datos han sido almacenados de manera persistente.
Cosmos permite el análisis de los datos mediante aplicaciones del tipo map&reduce, o mediante Apache Hive. 2.3 Docker Docker es un sistema de contenedores de software, que empaqueta el software en estos contenedores, de manera que contienen todo lo necesario para funcionar. Esto facilita el despliegue y mantenimiento de las aplicaciones, ya que para que la propia aplicación funcione evitamos requerir unas dependencias previas a la máquina host, provee de una capa a la vez de seguridad y de abstracción al aislar los contenedores del resto de dicha máquina, y evita la sobrecarga de necesitar ejecutar un sistema operativo completo sobre el host.
De los múltiples componentes que existen en la arquitectura de FIWARE, la siguiente imagen refleja cuales son aquellos que existen como contenedores en Docker, con un color oscuro los propios de FIWARE, y en un color más claro aquellos relacionados y que también existen y por tanto es viable emplearlos en un despliegue.
Como podemos comprobar, Orion está disponible, y a su vez sería necesario emplear un contenedor de MongoDB para poder desplegar Orion y tenerlo en funcionamiento.
En este proyecto emplearemos FIWARE como intermediario para conectar nuestro escenario IoT. La razón de uso de esta plataforma se encuentra en dos motivos principales:
Permitir conectar un escenario IoT completo, sean cuales sean los componentes que lo conforman. Si bien nuestro escenario puede ser suficientemente pequeño como para no requerir el uso de esta plataforma, es útil de cara a la conceptualización del trabajo, su uso en un escenario de mayor tamaño y para el propio aprendizaje.
La no existencia de plataformas similares que no sean privadas, por tanto, la única alternativa abierta a su uso para todo el mundo.
En tercer lugar, emplearemos Docker como sistema de contenedores para desplegar los componentes de FIWARE que necesitemos emplear. De esta manera, conseguiremos:
Ahorrar tiempo y dificultades en el despliegue y configuración de los GE de FIWARE.
Facilitar la actualización o reemplazo de componentes desplegados en contenedores.
Finalmente, hemos podido observar como el análisis de datos está a la orden del día, aplicándose estas técnicas 12 Análisis de datos de un escenario FIWARE basado en Docker 12 a ámbitos cada vez más diversos
Docker Compose le permite vincular un contenedor Orion Context Broker a un contenedor MongoDB en unos minutos. Este método requiere que instale Docker Compose.
Considere este método si desea probar Orion Context Broker y no quiere preocuparse por las bases de datos o no le importa perder datos.
Seguimos estos pasos:
Creamos un directorio en su sistema en el que trabajar (por ejemplo, c: / fiware).
Creamos un nuevo archivo llamado docker-compose.yml dentro del directorio con el siguiente contenido:
Usando la línea de comandos y dentro del directorio que creamos, escribiremos:
C:\fiware>docker-compose up
NOTA IMPORTANTE: Dado que puede dar problemas en la ejecución de la imagen de docker especialmente al lanzar la imagen de fiware_orion_1 , es mejor desde el directorio de despliegue lanzar el siguiente comando:
$ docker-compose up –force-recreate orion
Con respecto a –nojournal, no se recomienda para producción, pero acelera el inicio del contenedor mongo y evita algunos problemas de condiciones de carrera si el contenedor Orion es más rápido y no encuentra la base de datos lista y lista.
Lo que he hecho con este método es descargar imágenes para Orion Context Broker y MongoDB desde el repositorio público de imágenes llamado Docker Hub: es entonces cuando ha creado dos contenedores basados en ambas imágenes.
Después de unos segundos, debería tener su Context Broker ejecutándose y escuchando en el puerto 1026 lo cual podemos comprobar si nos vamos a la url: http// localhost: 1026/version
También desde el interfaz gráfico de dockers debe aparecer corriendo el contenedor de fiware ejecutándose:
Si desea detener el escenario, debe presionar Control + C en el terminal donde se está ejecutando docker-compose, pero se perderían todos los datos que se estaban utilizando en Orion con este método.
Creemos ahora una entidad tipo práctica del tipo Medida al que el vamos asociar la temperatura y humedad de una habitación.
Debemos extremar las cabeceras (headers) cuando enviamos datos a Orión Content Bróker, pues el Key Host que viene por defecto en Postman no nos sirve, para lo cual deberemos crear otra key asociándola a “application/json”. Asimismo, de igual manera lo haremos con el atributo “Content-Type”.
Asimismo, podemos cambiar no solo el valor de un atributo, sino también el tipo de dato usando PUT:
Es precisamente este el formato que podríamos usar para enviar las muestras al Content-bróker de Fiware desde el endpoint http://192.168.1.66:1026/v2/entities/
Como posibles valores de prueba podemos usar los siguientes:
{
“Temperatura”: {
“type”: “Integer”,
“value”: 35,
“metadata”: {}
},
“Humedad”: {
“type”: “Float”,
“value”: 51,
“metadata”: {
“accuracy”: {
“type”: “Float”,
“value”: 9
}
}
}
}
Podemos cambiar solo la temperatura:
{
“Temperatura”: {
“type”: “Integer”,
“value”: 99,
“metadata”: {}
}
}
O también cambiar el valor de la humedad:
{ “Humedad”: {
“type”: “Float”,
“value”: 51,
“metadata”: {
“accuracy”: {
“type”: “Float”,
“value”: 9
}
}
}
}
-Desde un navegador Chrome con las extensiones json y refresh nos iremos a http://192.168.1.66:1026/v2/entities/ podemos comprobar que se ha actualizado
Dado que puede dar problemas en la ejecución de la imagen de docker especialmente al lanzar la imagen de fiware_orion_1 , es mejor desde el directorio de despliegue lanzar el siguiente comando:
$ docker-compose up –force-recreate orion
Una vez iniciados los dos servicios comprobaremos mediante el interfaz de docker que ya podemos empezar a trabajar
Lo siguiente es crear las entidades finales usando el siguiente código en Json:
Para que esta práctica tenga sentido vamos a implementar un caso práctico de un sensor real basado en DHTX conectado a un ESP32 que será el que envié las medidas a ORION Content Broker que consistirán en las siguientes:
Temperatura exterior
Humedad exterior
Temperatura interior
Nivel señal wifi
Sensor Hall(opcional)
DHT11 y DHT22 son dos modelos de una misma familia de sensores, que permiten realizar la medición simultánea de temperatura y humedad usando además un único hilo para comunicar los datos vía serie, para lo cual ambos disponen de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino, ESP8266 o el node MCU que usaremos.
Ambos son similares pero el DHT11 presenta una carcasa azul (es el que usaremos en la práctica), mientras que el sensor DHT22 es blanco, compartiendo además los mismos pines disponiendo de 4 patillas, de las cuales usaremos sólo 3: Vcc, Output y GND. Como peculiaridad, la salida la conectaremos a una entrada digital, pero necesitaremos poner una resistencia de 10K entre Vic y el Pin Output, pero existen unos módulos que integran esta junto con los pines VCC, OUT y GND.
El DHT11 puede medir temperaturas entre 0 a 50, con una precisión de 2ºC, humedad entre 20 a 80%, con precisión del 5% y con una a frecuencia de muestreo de 1 muestras por segundo (1 Hz)
En clara superioridad con el dHT11, el modelo DHT22 tiene unas características mucho más profesionales.
Medición de temperatura entre -40 a 125, con una precisión de 0.5ºC
Medición de humedad entre 0 a 100%, con precisión del 2-5%.
Frecuencia de muestreo de 2 muestras por segundo (2 Hz)
Destacar que este tipo de sensores de temperatura (y, aún más, los sensores de humedad), sonsensores con elevada inercia y tiempos de respuesta elevados. Es decir, al “lentos” para reflejar los cambios en la medición.
Conectar el DHT11 o el DHT22 a un Arduino o al Node MCU es sencillo, simplemente alimentamos desde Arduino al sensor a través de los pines GND y Vcc del mismo. Por otro lado, conectamos la salida Output a una entrada digital de Arduino. Necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output.
El esquema eléctrico queda como la siguiente imagen:
Los sensores DHT11 y DHT22 usan su propio sistema de comunicación bidireccional mediante un único hilo, empleando señales temporizadas por lo que en general, lo normal es que empleemos una librería existente para simplificar el proceso.
Como vemos el circuito para conectar al Node MCU el sensor de temperatura y humedad DHT11 no puede ser más sencillo, pues simplemente alimentaremos con 3.3v DC tanto el DHT11 como el Node MCU en sus pines correspondiente sin olvidar que la salida de datos del DH11pin datos) tenemos que conectarla al pin 5 del GPIO.
Respecto a la placa de desarrollo usada es la NodeMCU-32S basada en ESP32, placa que cuenta con conectividad WiFi + Bluetooth, CP2102 a bordo y llaves. Además, todos los pines de E / S del módulo ESP-WROOM-32 son accesibles a través de los encabezados de extensión. Gracias a los ricos recursos de código abierto, admite el desarrollo de varias formas, como los comandos Lua / AT / MicroPython / Arduino / IOT, etc., lo que le ayuda a crear prototipos rápidos de aplicaciones de IoT.
Algunas características de esta placa:
Módulo ESP-WROOM-32 integrado
CP2102 integrado, convertidor de USB a UART
Puerto USB para entrada de energía, programación de firmware o depuración UART
Cabezales de extensión de 2×19 pines, rompen todos los pines de E / S del módulo
2x teclas, utilizadas como reinicio o definidas por el usuario
Lo siguiente es descargue esta biblioteca como un archivo zip aquí.
Instalamos la biblioteca zip descargada desde Sketch -> Incluir biblioteca -> Agregar biblioteca .ZIP.
Ahora ya podemos conectar el módulo ESP a su pc a usando un USB y seleccionado su puerto (y el un módulo ESP) en el menú Herramientas.
Es interesante destaca de que puede según los casos, tengamos que añadir una regla al Cortafuegos de Windows 10 para permitir el acceso desde el ESP32 al Content Server Bróker.
Por ultimo cargaremos el siguiente código en nuestro ESP32 personalizándolo con las características de nuestra red wifi y los datos que vayamos a enviar al Content Bróker:
Una vez que ya tenemos datos en la plataforma Fiware, necesitamos no solo que haga de conexión entre diferentes dispositivos, sino que buscamos ver y entender que nos están diciendo nuestros equipos. Hacer esto, hoy por hoy, requiere al menos un cierto manejo de lenguajes de programación como podría ser por ejemplo node-js. Sin embargo, hay quienes están trabajando porque esto no sea así como es el caso de Freeboard, un producto de Bug Labs, una Startup de Nueva York. “A damn-sexy, open source real-time dashboard builder/viewer for IOT and other web mashups”.
Freeboard seguramente no sea la plataforma de aplicaciones más sofisticada técnicamente que existe para el Internet de las Cosas pues estamos ante un panel web que podríamos decir “sencillo” y que muestra la información de los diferentes dispositivos que tengamos conectados en tiempo real.
Destacar también que es una plataforma Open Source, cuyo código fuente está disponible en GitHub donde allí tenemos el código fuente de la parte cliente.
Según sus fundadores, “Freeboard.io trata de convertir el Internet de las Cosas en un entorno mucho más sencillo, simple y accesible para todo el mundo”.
No necesitamos nada más para hacer funcionar tus dispositivos, aunque se podría potenciar mucho el sistema mediante la conexión por ejemplo con dweet.io o IFTTT.com, creando de una forma rápida y sencilla una robusta aplicación IoT. También podemos mezclar plataformas y dispositivos, levantando un excelente entorno desde donde controlar nuestros equipos.
Trabajar con ella es muy sencillo: Freeboard puede ejecutarse bien en un entorno cloud ( freeboard.io) con un plan gratuito con 30 días de duración. Una vez registrados podemos crear paneles indicadores configurados a nuestro gusto para visualizar la información, aunque primero habrá que añadir como fuente de datos(datasource) y sobre estos datos montar nuestro propio dashboard.
Otra forma de trabajar podría ser descargando o clonando el repositorio de Github, pero, aunque podría parecer trivial no se trata de abrir “index.html” simplemente en su navegador favorito pues tendremos que tener una servidor web (por ejemplo, Apache web server), tener node-js instalado y por supuesto tener Freeboard correctamente configurado especialmente todo lo relacionado con los CORS( Access-Control-Allow-Origin) donde por cierto la extensión de Chrome “Allow Cors” podría ser muy útil.
Como esta instalación podría ser problemática, lo más sencillo es cargar una imagen de docker con Freeboard pues así tendremos todo bien configurado y no tendremos ningún problema a la hora de ejecutar este entorno
No debemos por cierto antes de ejecutar dicha imagen de Freeboard de Docker instalar node-js, necesario para que todos los componentes funcionen correctamente.
Los pasos a seguir para hacer funcionar localmente Freeboad localmente:
Instalar node-js (si aún no lo tiene instalado)
Instalar Docker en la maquina
Crear y ejecutar el contenedor de Freeboard(https://github.com/h6w/freeboard-docker ) donde ejecutaremos el resto de contenedores Dockers, para lo cual simplemente desde el directorio desde line de comandos ejecutaremos:docker run --name myfreeboard -p 8080:80 -d tudorh/freeboard (este comando expondrá una instalación de Freeboard en http://localhost:8080 )
Ahora nos iremos a Docker para comprobar que está corriendo en el puerto 8080 el servidor de Freeboard.
Una vez hecho esto pulsaremos en el símbolo de refresh en la parte superior y ya debería verse reflejado la hora de esa actualización.
Ahora pulsaremos en “ADD PANE” para crear el entorno donde mostraremos gráficamente las diferentes variables que queremos mostrar en nuestro panel:
Temperatura exterior
Humedad exterior
Temperatura interior
Nivel señal wifi
Temperatura exterior:
Lo ideal es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.
Asimismo, Freeboard permite añadir un histórico usando el tipo Sparkline.
Por ejemplo, así se mostraría en tiempo real como fluctúa la temperatura exterior:
Temperatura interior:Lo ideal, igual que con la temperatura exterior es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.
Señal wifi:Lo ideal, es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.
Humedad:Lo ideal, es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.
También podemos mostrar la misma información en modo texto:
Es interesante además de mostrar un histórico, de modo que al igual que se ha hecho con la temperatura exterior lo haremos con la humedad exterior usando el control Sparkline:
Para terminar, usaremos un Pointer para mostrar un valor de la humedad mas visible.
Con todos estos cambios pulsaremos en “SAVE FREEBORAD” para almacenar en un fichero Json en local todos los cambios realizados
El aspecto de como queda el panel es el siguiente:
Podemos comprobar que la información es actualizada con la fuente de datos, usando el monitor serie de Arduino:
Sin tener instalado Freeboard, aparte de la herramienta Postman (fundamental para depurar los formatos de envió), hay dos herramientas muy interesantes para monitorizar las variables almacenadas en Fiware alimentado por los datos que nos está enviando nuestra placa ESP32 y el sensor DHT11.
Las dos extensiones de Google Chrome que han resultado muy útiles son las siguientes:
Esta extensión es no solo un browser sino también un editor documentos JSON permitiendo ver de una sola vez de una manera muy visualmente atractiva los datos en nuestro caso de los diferentes sensores.
Esta extensión permite recargar la página a intervalos definidos para refrescar los datos y poder mostrar los cambios, lo cual es muy útil para no tener que estar constantemente refrescando la página desde obtenemos la información del Content bróker ( en nuestro caso http://192.168.1.66:1026/v2/entities/ )
El punto medio para Ambas ondas debería estar técnicamente en 512 (valor analógico) y fluctúa entre 0 y 1023 de forma predeterminada. Sin embargo, he modificado el código para que las ondas oscilen en el punto medio del valor 0 entre 512 y -512 para facilitar el cálculo más adelante. Antes de continuar, es necesario realizar una calibración antes de la medición, ya que algunos módulos pueden tener un error de desviación diferente. Puede ir a la publicación de sensores individuales para obtener más información.
