IoT simplificado: captura de datos meteorológicos remotos: UV y temperatura y humedad del aire: 7 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-02-01 14:40

En este tutorial, capturaremos datos remotos como UV (radiación ultravioleta), temperatura del aire y humedad. Esos datos serán muy importantes y se utilizarán en una futura estación meteorológica completa.

El diagrama de bloques muestra lo que obtendremos al final.

Paso 1: BoM - Lista de materiales

NodeMCU (ESP8266-12E): 9,00 USD

Sensor de temperatura y humedad (DHT22) - USD10.00

Sensor UV - USD 4,00

OLED USD 12,00

Tablero de pruebas - USD1.00

Paso 2: el sensor UV analógico

Este sensor UV genera una salida analógica proporcional a la radiación ultravioleta que se encuentra en el espectro de detección de luz. Utiliza un fotodiodo UV (basado en nitruro de galio), que puede detectar el rango de luz de 240-370 nm (que cubre los rayos UVB y la mayor parte del espectro UVA). El nivel de señal del fotodiodo es muy pequeño, en el nivel de nanoamperios, por lo que el módulo tiene incorporado un amplificador operacional para amplificar la señal a un nivel de voltaje más legible (0 a 1V).

El sensor y el amplificador operacional se pueden alimentar conectando VCC a 3.3VDC (o 5VDC) y GND a la tierra de alimentación. La señal analógica se puede obtener desde el pin OUT.

Su Salida estará en milivoltios y será leída por la Entrada Analógica de nuestro NodeMCU. Una vez leído, deberíamos "convertirlo" (o "mapearlo") para que los valores sean mejor manejados por el código. Podemos hacerlo con la función readSensorUV ():

/ * Leer sensor UV en mV y llamar al cálculo del índice UV * /

vacío readSensorUV () {byte numOfReadings = 5; dataSensorUV = 0; para (int i = 0; i <numOfReadings; i ++) {dataSensorUV + = analogRead (sensorUVPin); retraso (200); } dataSensorUV / = numOfReadings; dataSensorUV = (dataSensorUV * (3.3 / 1023.0)) * 1000; Serial.println (dataSensorUV); indexCalculate (); }

Una vez que tenemos los datos de UV, podemos calcular fácilmente el índice de UV como se define en la tabla anterior. La función indexCalculate () lo hará por nosotros:

/ * Cálculo del índice UV * /

void indexCalculate () {if (dataSensorUV <227) indexUV = 0; de lo contrario si (227 <= dataSensorUV && dataSensorUV <318) indexUV = 1; de lo contrario si (318 <= dataSensorUV && dataSensorUV <408) indexUV = 2; de lo contrario, si (408 <= dataSensorUV && dataSensorUV <503) indexUV = 3; de lo contrario si (503 <= dataSensorUV && dataSensorUV <606) indexUV = 4; si no (606 <= dataSensorUV && dataSensorUV <696) indexUV = 5; de lo contrario si (696 <= dataSensorUV && dataSensorUV <795) indexUV = 6; else if (795 <= dataSensorUV && dataSensorUV <881) indexUV = 7; else if (881 <= dataSensorUV && dataSensorUV <976) indexUV = 8; else if (976 <= dataSensorUV && dataSensorUV <1079) indexUV = 9; else if (1079 <= dataSensorUV && dataSensorUV <1170) indexUV = 10; si no indexUV = 11; }

Paso 3: Instalación de una pantalla: OLED

Para fines de prueba, incluiremos un OLED en nuestro medidor de UV (este paso es completamente opcional).

Está bien durante las pruebas utilizar el monitor en serie, pero ¿qué sucede cuando utiliza sus prototipos lejos de su PC en modo autónomo? Para eso instalemos una pantalla OLED, la SSD1306, cuyas principales características son:

• Tamaño de la pantalla: 0,96"
• Serie I2C IIC SPI
• 128X64
• LED LCD OLED blanco

Siga el esquema eléctrico y conecte los 4 pines de nuestro OLED:

• VCC va a 3,3 V
• GND va a tierra
• SCL va a NodeMCU (GPIO 2) ==> D4
• SDA va a NodeMCU (GPIO 0) ==> D3

Una vez que hayamos conectado la pantalla, descarguemos e instalemos su biblioteca en nuestro IDE de Arduino: el "Controlador OLED ESP8266 para pantalla SSD1306" desarrollado por Daniel Eichhorn (¡Asegúrese de usar la Versión 3.0.0 o superior!).

Instale la biblioteca en su Arduino IDE, que se puede encontrar en SSD1306Wire.h

Una vez que reinició el IDE, la biblioteca ya debería estar instalada.

La biblioteca admite el protocolo I2C para acceder a la pantalla OLED utilizando la biblioteca Wire.h incorporada:

/ * OLED * /

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; Pantalla SSD1306Wire (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);

Enumeremos algunas API importantes que se utilizarán con nuestra pantalla OLED. La lista completa se puede encontrar en el GITHub proporcionado anteriormente.

A. Control de pantalla:

void init (); // Inicializar la pantalla

void displayOn (vacío); // Enciende la pantalla void displayOff (void); // Apaga la pantalla void clear (void); // Limpia el búfer de píxeles local void flipScreenVertically (); // Pon la pantalla boca abajo

B. Operaciones de texto:

void drawString (int16_t x, int16_t y, String text); // (xpos, ypos, "Texto")

void setFont (const char * fontData); // Establece la fuente actual.

Fuentes predeterminadas disponibles:

• ArialMT_Plain_10,

• ArialMT_Plain_16,

• ArialMT_Plain_24

Una vez instalados tanto el OLED como su biblioteca, escribamos un programa simple para probarlo. Ingrese con el código de abajo en su IDE, el resultado debe ser una pantalla como se muestra en la foto de arriba:

* OLED * /

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; Pantalla SSD1306Wire (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); configuración vacía () {Serial.begin (115200); configuración de pantalla(); } void loop () {} / * Iniciar y mostrar datos de configuración en OLED * / void displaySetup () {display.init (); // inicializar display display.clear (); // Limpiar la pantalla display.flipScreenVertically (); // Dar la vuelta a la pantalla display.display (); // Coloca los datos en la pantalla Serial.println ("Iniciando Prueba de Pantalla"); display.setFont (ArialMT_Plain_24); display.drawString (30, 0, "OLED"); // (xpos, ypos, "Texto") display.setFont (ArialMT_Plain_16); display.drawString (18, 29, "Prueba iniciada"); display.setFont (ArialMT_Plain_10); display.drawString (10, 52, "Serial BaudRate:"); display.drawString (90, 52, String (11500)); display.display (); // Poner los datos en la pantalla delay (3000); }

El programa anterior se puede descargar desde mi GitHub:

NodeMCU_OLED_Test

Paso 4: un medidor de UV local

Ahora, con la pantalla OLED instalada, podemos conectar una batería y hacer algunas pruebas remotas usando nuestro "Medidor UV".

#define SW_VERSION "UV_Sensor_V.1"

/ * Sensor UV * / #define sensorUVPin A0 int dataSensorUV = 0; int indexUV = 0; / * OLED * / #include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; Pantalla SSD1306Wire (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); configuración vacía () {Serial.begin (115200); configuración de pantalla(); } bucle vacío () {readSensorUV (); displayUV (); retraso (1000); } / * Iniciar y mostrar datos de configuración en OLED * / void displaySetup () {display.init (); // inicializar display display.clear (); // Limpiar la pantalla display.flipScreenVertically (); // Dar la vuelta a la pantalla display.display (); // Ponga los datos en la pantalla Serial.println ("Iniciando prueba del sensor UV"); display.setFont (ArialMT_Plain_24); display.drawString (10, 0, "MJRoBot"); display.setFont (ArialMT_Plain_16); display.drawString (0, 29, "Prueba del sensor UV"); display.setFont (ArialMT_Plain_10); display.drawString (0, 52, "SW Ver.:"); display.drawString (45, 52, SW_VERSION); display.display (); retraso (3000); } / * Leer sensor UV en mV y llamar al cálculo del índice UV * / void readSensorUV () {byte numOfReadings = 5; dataSensorUV = 0; para (int i = 0; i <numOfReadings; i ++) {dataSensorUV + = analogRead (sensorUVPin); retraso (200); } dataSensorUV / = numOfReadings; dataSensorUV = (dataSensorUV * (3.3 / 1023.0)) * 1000; Serial.println (dataSensorUV); indexCalculate (); } / * Cálculo del índice UV * / void indexCalculate () {if (dataSensorUV <227) indexUV = 0; de lo contrario si (227 <= dataSensorUV && dataSensorUV <318) indexUV = 1; de lo contrario si (318 <= dataSensorUV && dataSensorUV <408) indexUV = 2; de lo contrario, si (408 <= dataSensorUV && dataSensorUV <503) indexUV = 3; de lo contrario si (503 <= dataSensorUV && dataSensorUV <606) indexUV = 4; else if (606 <= dataSensorUV && dataSensorUV <696) indexUV = 5; si no (696 <= dataSensorUV && dataSensorUV <795) indexUV = 6; de lo contrario, si (795 <= dataSensorUV && dataSensorUV <881) indexUV = 7; else if (881 <= dataSensorUV && dataSensorUV <976) indexUV = 8; else if (976 <= dataSensorUV && dataSensorUV <1079) indexUV = 9; else if (1079 <= dataSensorUV && dataSensorUV <1170) indexUV = 10; si no indexUV = 11; } / * Mostrar valores UV en OLED local * / void displayUV () {display.clear (); display.setFont (ArialMT_Plain_16); display.drawString (20, 0, "Sensor UV"); display.drawString (0, 23, "UV (mV):"); display.drawString (80, 23, String (dataSensorUV)); display.drawString (0, 48, "Índice UV:"); display.setFont (ArialMT_Plain_24); display.drawString (82, 42, String (indexUV)); display.display (); }

El código anterior se puede descargar desde mi GitHun: NodeMCU_UV_Sensor_OLED.ino

Paso 5: Instalación de un DHT22 para mediciones de temperatura y humedad del aire

Uno de los sensores más utilizados para capturar datos meteorológicos es el DHT22 (o su hermano DHT11), un sensor digital de temperatura y humedad relativa. Utiliza un sensor de humedad capacitivo y un termistor para medir el aire circundante y escupe una señal digital en el pin de datos (no se necesitan pines de entrada analógica).

El sensor debe alimentarse entre 3.3V y 5V y funcionará desde -40oC a + 80oC con una precisión de +/- 0.5oC para temperatura y +/- 2% para humedad relativa. También es importante tener en cuenta que su período de detección es en promedio de 2 segundos (tiempo mínimo entre lecturas). El sitio de Adafruit proporciona mucha información sobre DHT22 y su hermano DHT11. Para obtener más detalles, visite la página del tutorial DHT22 / 11.

El DHT22 tiene 4 pines (mirando hacia el sensor, el pin 1 es el más a la izquierda):

1. VCC (nos conectaremos a 3.3V desde NodeMCU);
2. Salida de datos;
3. No conectado y
4. Suelo.

Una vez que, por lo general, usará el sensor en distancias inferiores a 20 m, se debe conectar una resistencia de 10K entre los pines Data y VCC. El pin de salida se conectará al pin D3 de NodeMCU (consulte el diagrama anterior). Una vez que el sensor esté instalado en nuestro módulo, descargue la biblioteca DHT del repositorio de Adafruit GitHub e instálela en su archivo de biblioteca de Arduino. Una vez que vuelva a cargar su IDE de Arduino, se debe instalar la "biblioteca de sensores DHT".

Al comienzo del código, debemos incluir las líneas:

/ * DHT22 * /

#incluya "DHT.h" #define DHTPIN D2 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); flotador zumbido = 0; temperatura de flotación = 0;

Se creará una nueva función para leer el sensor:

/ * Obtener datos DHT * /

void getDhtData (void) {float tempIni = temp; flotar humIni = zumbido; temp = dht.readTemperature (); hum = dht.readHumidity (); if (isnan (hum) || isnan (temp)) // Compruebe si alguna lectura falló y salga antes (para volver a intentarlo). {Serial.println ("¡Error al leer del sensor DHT!"); temp = tempIni; hum = humIni; regreso; }}

El código completo, incluidos los sensores UV y DHT, se puede descargar desde mi GitHub: NodeMCU_UV_DHT_Sensor_OLED

Paso 6: Envío de datos a ThingSpeak.com

Hasta ahora, solo hemos utilizado el NodeMCU ESP12-E como una placa Arduino normal y ordinaria. Por supuesto, solo hemos "arañado" el potencial real de este espectacular chip y ahora es el momento de despegar hacia el cielo. ¡O mejor a las estrellas! Ehr… ¡a la nube!;-)

¡Vamos a empezar!

1. Primero, debe tener una cuenta en ThinkSpeak.com
2. Sigue las instrucciones para crear un canal y toma nota de tu ID de canal y escribe la clave de API.
3. Actualice el siguiente código con su red WiFi y credenciales de Thinkspeak
4. Ejecute el programa en IDE

Comentemos las partes más importantes del código:

Primero, llamemos a la biblioteca ESP8266, definamos el cliente WiFi y definamos sus credenciales de enrutador local y Thinkspeak:

/ * ESP12-E y Thinkspeak * /

#incluir cliente WiFiClient; const char * MY_SSID = "SU ID SSD AQUÍ"; const char * MY_PWD = "SU CONTRASEÑA AQUÍ"; const char * TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "SU CANAL ESCRIBIR CLAVE API";

En segundo lugar, incluyamos una biblioteca muy importante para proyectos de IoT: SimpleTimer.h:

/* TEMPORIZADOR */

#incluir temporizador SimpleTimer;

En tercer lugar, durante la configuración (), iniciaremos la comunicación en serie, llamaremos a la función connectWiFi () y definiremos los temporizadores. Tenga en cuenta que la línea de código: timer.setInterval (60000L, sendDataTS); llamará a la función sendDataTS () cada 60 segundos, para cargar datos al canal ThinkSpeak.

configuración vacía ()

{… Serial.begin (115200); retraso (10); … ConnectWifi (); timer.setInterval (60000L, sendDataTS); …}

Por último, pero no menos importante, durante el bucle (), el único comando necesario es iniciar el temporizador y ¡listo!

bucle vacío ()

{… Timer.run (); // Inicia SimpleTimer}

A continuación, puede ver las dos funciones importantes que se utilizan para manejar la comunicación Thinkspeak:

Conexión ESP12-E con su red WiFi:

/***************************************************

* Conexión WiFi ******************************************** *** / void connectWifi () {Serial.print ("Conectando a" + * MY_SSID); WiFi.begin (MY_SSID, MY_PWD); while (WiFi.status ()! = WL_CONNECTED) {retraso (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi conectado"); Serial.println (""); }

ESP12-E enviando datos a ThinkSpeak:

/***************************************************

* Envío de datos al canal Thinkspeak ***************************************** ****** / void sendDataTS (void) {if (client.connect (TS_SERVER, 80)) {String postStr = TS_API_KEY; postStr + = "& campo1 ="; postStr + = String (dataSensorUV); postStr + = "& campo2 ="; postStr + = Cadena (indexUV); postStr + = "& field3 ="; postStr + = String (temp); postStr + = "& campo4 ="; postStr + = String (zumbido); postStr + = "\ r / n / r / n"; client.print ("POST / actualización HTTP / 1.1 / n"); client.print ("Host: api.thingspeak.com / n"); client.print ("Conexión: cerrar / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Tipo de contenido: aplicación / x-www-form-urlencoded / n"); client.print ("Content-Length:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); retraso (1000); } enviado ++; client.stop (); }

El código completo se puede encontrar en mi GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Una vez que haya cargado el código en su NodeMCU. Conectemos una batería externa y hagamos algunas mediciones bajo el sol. Pongo la estación remota en el techo y empiezo a capturar datos en ThingSpeak.com como se muestra en las fotos de arriba.

Paso 7: Conclusión

Como siempre, espero que este proyecto pueda ayudar a otros a encontrar su camino hacia el apasionante mundo de la electrónica.

Para obtener detalles y el código final, visite mi depósito de GitHub: RPi-NodeMCU-Weather-Station

Para más proyectos, visite mi blog: MJRoBot.org

¡Manténganse al tanto! En el siguiente tutorial enviaremos datos desde una estación meteorológica remota a una central, basada en un servidor web Raspberry Pi:

¡Saludos desde el sur del mundo!

¡Nos vemos en mi próximo instructable!

Gracias, Marcelo