Informe meteorológico utilizando los subprogramas ThingSpeak MQTT e IFTTT: 8 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Introducción

Una aplicación meteorológica basada en la nube que proporciona informes meteorológicos diarios como notificación por correo electrónico. Esta aplicación web mide la temperatura y la humedad usando SHT25 y Adafruit Huzzah ESP8266. Nos proporciona datos de temperatura y humedad en tiempo real y análisis por hora. Los datos se envían utilizando la API ThingSpeak MQTT y luego proporcionamos una notificación por correo electrónico al usuario cada vez que la temperatura alcanza el umbral asignado mediante el protocolo IFTTT. SHT25 es un sensor de temperatura y humedad fabricado por Sensirion. El SHT25 proporciona un alto nivel de precisión alrededor de ± 2% RH. Su rango de humedad está entre 0 y 100% y el rango de temperatura está entre -40 y 125 ° C. Es mucho más confiable y rápido con 8 segundos de tiempo de respuesta del sensor.

Características

• Le proporciona estadísticas y análisis en tiempo real mediante la API de Thing Speak MQTT
• Se proporciona una notificación por correo electrónico al usuario en un momento asignado mediante IFTTT
• El Programador de tareas se utiliza para programar la tarea, como obtener datos de los sensores, publicar las lecturas de los sensores, suscribirse al tema MQTT
• Utiliza el protocolo I2C para obtener la lectura del sensor, que es más precisa, expandible y escalable.
• modo de suspensión cuando el dispositivo está inactivo o no se llama a ninguna tarea de devolución de llamada.
• la programación de tareas eficaz proporciona un uso sin problemas
• Se aloja una página web separada donde el usuario debe proporcionar sus credenciales de usuario para evitar que su dispositivo parpadee cada vez que se encuentre al alcance de otras redes wifi.

• SPIFFS se utiliza para almacenar nuestra página web para hacer nuestro código legible y menos torpe

Paso 1: Especificación de hardware y software

Especificación de hardware

• Tablero Adafruit esp8266 Huzzah
• Escudo de tablero de Huzzah
• Módulo sensor SHT25
• Cable I2C

Especificación de software

• IDE de Arduino
• IFTTT Thing Speak
• API de MQTT

Paso 2: almacenamiento de credenciales de usuario

Aquí estamos usando el sensor SHT25 I2C para leer el valor en tiempo real de la temperatura y la humedad relativa y publicar estos valores en la nube. Para obtener el valor del sensor actualizado de vez en cuando y publicar estas actualizaciones simultáneamente, estamos utilizando la biblioteca del programador de tareas de Arduino. Para las operaciones en la nube, utilizamos la API ThingSpeak MQTT. Más tarde, proporcionaremos informes meteorológicos en tiempo real al usuario mediante subprogramas IFTTT. Puedes seguir estos pasos para crear tu propia estación meteorológica. Entonces, bricolaje.

Antes de continuar. Necesitamos guardar las credenciales de usuario. Para este propósito, estamos alojando un servidor web en 192.169.1.4. Hemos almacenado nuestro formulario web en SPIFFS. Una vez que el dispositivo se inicia, aloja un servidor web durante 60 segundos. El usuario debe seguir estos pasos.

• Conéctese al AP ESPuser, que aparece en su lista de redes wifi disponibles. Conéctese a este AP e ingrese la contraseña "*******"
• Una vez que se conecte, vaya a su navegador ingrese la IP 192.168.1.4.
• Ingrese el SSID y la contraseña de su WiFi local en los campos de entrada e ingrese ENVIAR
• Estas credenciales se guardarán en EEPROM
• Después de 60 segundos, el dispositivo se desconectará automáticamente del AP
• La próxima vez que encienda el dispositivo, el usuario no tendrá que seguir este procedimiento, el dispositivo obtendrá automáticamente las credenciales de usuario de EEPROM y continuará obteniendo las lecturas del sensor de la interfaz I2C y publicando en la nube.

// --------- Configuración AP ------------ // Dirección IP ap_local_IP (192, 168, 1, 4); Dirección IP ap_gateway (192, 168, 1, 254); IPAddress ap_subnet (255, 255, 255, 0);

Serial.print ("Configurando punto de acceso …");

WiFi.softAPConfig (ap_local_IP, ap_gateway, ap_subnet);

Serial.print ("Configuración de credenciales de usuario");

WiFi.softAP (ssidAP, passAP);

server.on ("/", handleRoot);

server.onNotFound (onHandleNotFound);

server.begin ();

APTimer = milis ();

while (millis () - APTimer <APInterval) {

server.handleClient ();

}

// **************************** HANDLE ROOT ****************** ********* // void handleRoot () {

if (server.hasArg ("ssid") && server.hasArg ("contraseña"))

{

// Si todos los campos del formulario contienen datos, llame

handelSubmit ()

handleSubmit (); }

demás {

// Vuelve a mostrar el formulario

// lee el archivo contenido en spiffs

Archivo archivo = SPIFFS.open ("/ webform.html", "r");

server.streamFile (archivo, "texto / html");

// no olvide cerrar el archivo

file.close ();

}}

// Verifica el estado que tiene los argumentos ssid y contraseña

// Luego escribe las credenciales en ROM

ROMwrite (String (server.arg ("ssid")), String (server.arg ("contraseña")))

Paso 3: Configuración de su formulario web en SPIFFS

SPIFFS

Serial Peripheral Interface Flash File System, o SPIFFS para abreviar. Es un sistema de archivos liviano para microcontroladores con un chip flash SPI. El chip flash integrado del ESP8266 tiene mucho espacio para sus páginas web, especialmente si tiene la versión de 1 MB, 2 MB o 4 MB. También hemos almacenado nuestra página web en Flash System. Hay algunos pasos que debemos seguir para cargar datos en spiffs

1. Descarga la herramienta:
2. En su directorio de cuaderno de bocetos de Arduino, cree un directorio de herramientas si aún no existe
3. Desempaquete la herramienta en el directorio de herramientas (la ruta se verá como /Arduino/tools/ESP8266FS/tool/esp8266fs.jar)
4. Reinicie Arduino IDE
5. Abra un boceto (o cree uno nuevo y guárdelo)
6. Vaya al directorio de bocetos (elija Boceto> Mostrar carpeta de bocetos)
7. Cree un directorio llamado datos y los archivos que desee en el sistema de archivos allí. Hemos subido nuestra página HTML con el nombre webform.html
8. Asegúrese de haber seleccionado una placa, un puerto y un monitor serial cerrado
9. Seleccione Herramientas> Carga de datos de croquis ESP8266. Esto debería comenzar a cargar los archivos en el sistema de archivos flash ESP8266. Cuando termine, la barra de estado IDE mostrará el mensaje SPIFFS Image Uploaded.

Archivo archivo = SPIFFS.open ("/ webform.html", "r");

server.streamFile (archivo, "texto / html");

// no olvide cerrar el archivo

file.close ();

Paso 4: programación de tareas

En este tutorial, estamos realizando dos operaciones:

• Leer los datos de SHT25 usando el protocolo I2C
• Publique los datos actualizados en la nube utilizando ThingSpeak MQTT API

Para lograr esto, estamos usando la biblioteca TaskScheduler. Hemos programado dos tareas diferentes referidas a dos operaciones de control diferentes. esto se hace de la siguiente manera

• La tarea 1 es para leer el valor del sensor, esta tarea se ejecuta durante 1 segundo hasta que alcanza el tiempo de espera de 10 segundos.
• Cuando Task1 llega a su tiempo de espera, nos estamos conectando a Wifi local y al broker MQTT.
• Ahora la Tarea 2 está habilitada y estamos deshabilitando la Tarea 1 La Tarea 2 es para publicar los datos del sensor en el corredor Thing Speak MQTT, esta tarea se ejecuta durante 20 segundos hasta que alcanza el tiempo de espera de 20 segundos
• Cuando la Tarea 2 alcanza su tiempo de espera, la Tarea 1 se habilita nuevamente y la Tarea 2 se deshabilita. aquí nuevamente, estamos obteniendo el valor actualizado y el proceso continúa
• cuando no se llama a ninguna devolución de llamada o el dispositivo está inactivo, entra en modo de suspensión ligera, lo que ahorra energía.

// --------- prototipo para devolución de llamada de tarea ------------ //

void taskI2CCallback ();

void taskI2CDisable ();

void taskWiFiCallback ();

void taskWiFiDisable ();

//---------Tareas------------//

Tarea tI2C (2 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL, & taskI2CDisable);

Tarea tWiFi (20 * TASK_SECOND, TASK_FOREVER, & taskWiFiCallback, & ts, false, NULL y taskWiFiDisable);

// habilitar tI2C tI2C.enable ();

Paso 5: Lectura de los valores de temperatura y humedad de SHT25

I2C es una interfaz de dos cables que solo usa dos cables para comunicarse con el dispositivo maestro. Uno es SCL (Serial Clock) y el otro es SDA (Serial Data). Cada dispositivo esclavo tiene una dirección única. SHT 25 también tiene una dirección de 8 bits y se puede acceder a él mediante una dirección 0x44. tiene 8 bits de la dirección donde 7 bits son la dirección real y mientras que el bit 0 del LSB más a la derecha se usa para señalar la lectura o escritura en el dispositivo. Si el bit 0 se establece en 1, el dispositivo maestro leerá del dispositivo I2C esclavo. I2C es mucho más confiable, escalable y rápido e incluso tiene muchos modos de operación lo que lo hace mucho más eficiente energéticamente.

Estamos usando la biblioteca Wire.h para leer los valores de temperatura y humedad. Esta biblioteca facilita la comunicación i2c entre el sensor y el dispositivo maestro. 0x44 es la dirección I2C para SHT25. SHT25 opera en un modo de operación diferente. Puede consultar la hoja de datos para eso. Estamos usando 0x2C y 0x06 como MSB y LSB respectivamente para operación de disparo único

Paso 6: Publicar valores en ThingSpeak mediante la API de ThingSpeak MQTT

Para publicar nuestros valores de temperatura y humedad en la nube, utilizamos la API ThingSpeak MQTT. ThingSpeak es una plataforma de IoT. ThingSpeak es un servicio web gratuito que le permite recopilar y almacenar datos de sensores en la nube. MQTT es un protocolo común utilizado en los sistemas de IoT para conectar dispositivos y sensores de bajo nivel. MQTT se utiliza para pasar mensajes cortos hacia y desde un intermediario. ThingSpeak ha agregado recientemente un agente MQTT para que los dispositivos puedan enviar mensajes a ThingSpeak. Puede seguir el procedimiento para configurar el canal ThingSpeak de esta publicación

ThingSpeak MQTT

MQTT es una arquitectura de publicación / suscripción que se desarrolló principalmente para conectar dispositivos con ancho de banda y con limitaciones de energía a través de redes inalámbricas. Es un protocolo simple y liviano que se ejecuta sobre sockets TCP / IP o WebSockets. MQTT sobre WebSockets se puede proteger con SSL. La arquitectura de publicación / suscripción permite que los mensajes se envíen a los dispositivos del cliente sin que el dispositivo tenga que sondear continuamente el servidor. Un cliente es cualquier dispositivo que se conecta al corredor y puede publicar o suscribirse a temas para acceder a la información. Un tema contiene la información de enrutamiento del intermediario. Cada cliente que quiere enviar mensajes los publica sobre un tema determinado, y cada cliente que quiere recibir mensajes se suscribe a un tema determinado.

Publicar y suscribirse con ThingSpeak MQTT

• Publicar en canales de alimentación de canal / publicar /
• Publicar en un campo en particular canales / publicar / campos / campo /
• Suscríbete al campo del canal canales / suscríbete //
• Suscríbete a los canales de noticias del canal privado // subscribe / fields / field /
• Suscríbete a todos los campos de un canal. canales // suscribirse / campos / feild /

void taskWiFiCallback ()

{

Serial.println ("taskWiFiCallbackStarted");

Serial.print ("tiempo de espera para esta tarea: / t");

Serial.println (tWiFi.getTimeout ());

si (! mqttCli.connected ())

{

Serial.println ("Cliente no conectado");

reconnectMQTT ();

}

String topicString = "canales /" + String (channelID) + "/ publish /" + String (writeAPIKey);

int topicLength = topicString.length () + 1;

char topicBuffer [topicLength];

topicString.toCharArray (topicBuffer, topicLength + 1);

Serial.println (topicBuffer);

String dataString = String ("campo1 =" + String (tempC, 1) + "& field2 =" + String (tempF, 1) + "& field3 =" + String (húmedo, 1));

int dataLength = dataString.length () + 1;

byte dataBuffer [dataLength];

dataString.getBytes (dataBuffer, dataLength);

mqttCli.beginPublish (topicBuffer, dataLength, false);

Serial.println (mqttCli.write (dataBuffer, dataLength)? "Publicado": "publicado fallido");

mqttCli.endPublish ();

//mqttCli.loop ();

}

Paso 7: Notificación por correo electrónico del informe meteorológico

Estamos utilizando subprogramas IFTTT para enviar notificaciones por correo electrónico al usuario con un informe meteorológico en tiempo real. Entonces, lo hemos implementado a través de ThingSpeak. Estamos promediando los valores de temperatura y humedad de 5 fay. Siempre que el valor de la última entrada sea mayor que el valor medio. Activará una notificación por correo electrónico "es un día caluroso". y cuando es menor que el valor medio. Activará una notificación por correo electrónico "Qué hermoso día". Todos los días alrededor de las 10:00 a.m. (IST) recibiremos una notificación por correo electrónico

channelID = ******;

iftttURL = 'https://maker.ifttt.com/**************';

humedadData = thingSpeakRead (channelID, 'Campos', 3, 'NumDays', 5); tempData = thingSpeakRead (channelID, 'Campos', 1, 'NumDays', 5);

perHumid = max (datos de humedad) -min (datos de humedad);

humidValue = 0.1 * perHumid + min (datos de humedad);

perTemp = max (tempData) -min (tempData);

tempValue = 0.1 * perTemp + min (tempData);

urlTemp = strcat ('https://api.thingspeak.com/channels/', cadena (ID de canal), '/fields/1/last.txt');

urlHumid = strcat ('https://api.thingspeak.com/channels/', cadena (ID de canal), '/fields/3/last.txt'); lastTempValue = str2num (webread (urlTemp)); lastHumidValue = str2num (webread (urlHumid));

si (lastTempValue

if (lastTempValue> tempValue || lastHumidValue> humidValue)

plantMessage = 'Es un día caluroso.'; webwrite (iftttURL, 'value1', plantMessage, 'value2', lastTempValue, 'value3', lastHumidValue); fin

Paso 8: Código general

Código general

El código general está disponible en este repositorio de GitHub

Limitaciones

• Hay algunos problemas con la publicación de los datos mediante la publicación de un método para la mayor parte de los datos. Para resolver este problema, estamos usando la función write ()
• SPIFFS debe formatearse antes de cargar los nuevos datos en SPIFFS.
• No debe utilizar la función delay (). delay () dificulta la operación en segundo plano. En su lugar, cree retrasos usando millis () solo si es necesario

Créditos

• ESP826WebServer
• Programador de tareas
• SHT 25
• API ThingSpeak MQTT
• IFTTT
• PubSubClient