APLICACIÓN DE TEMPERATURA Y HUMEDAD THINGSPEAK UTILIZANDO ESP8266: 9 pasos

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

Mientras jugaba con mis cosas electrónicas, se me ocurrió la idea de hacer una aplicación meteorológica basada en la web. Esta aplicación web utiliza el sensor SHT31 para obtener datos de temperatura y humedad en tiempo real. Hemos implementado nuestro proyecto en el módulo WiFi ESP8266. ¡En línea o fuera de línea! No se preocupe, ya sea que esté en línea o fuera de línea, obtendrá las actualizaciones del clima desde cualquier lugar y en cualquier momento. Esta aplicación web publica datos en el servidor web local y en la nube. Para las operaciones en la nube, utilizamos la API ThingSpeak. SHT31 usa I2C para obtener los datos del sensor.

SHT 31 es un sensor de temperatura y humedad fabricado por Sensirion. El SHT31 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. Su funcionalidad incluye procesamiento de señal mejorado y compatibilidad I2C. Tiene diferentes modos de funcionamiento lo que lo hace energéticamente eficiente.

En este tutorial, hemos interconectado SHT 31 con la placa Adafruit Huzzah. Para leer los valores de temperatura y humedad, hemos utilizado el escudo ESP8266 I2C. Este adaptador hace que todos los pines sean accesibles para el usuario y ofrece un entorno I2C fácil de usar.

Paso 1: Hardware requerido

Hardware utilizado para completar esta tarea:

1. SHT 31
2. Adafruit Huzzah ESP8266
3. Adaptador ESP8266 I2C
4. Cable I2C

Paso 2: Conexiones de hardware

Este paso incluye la guía de conexión de hardware. Esta sección explica básicamente las conexiones de cableado necesarias entre el sensor y el ESP8266. Las conexiones son las siguientes.

1. El SHT31 funciona sobre I2C. La imagen de arriba muestra la conexión entre ESP8266 y el módulo SHT31. Estamos usando un cable I2C para ello o podemos usar cables de puente de 4 F a F.
2. un cable se usa para Vcc, el segundo cable para GND y otros dos para SDA y SCL respectivamente
3. Según el adaptador I2C, el pin 2 y el pin 14 de una placa ESP8266 se utilizan como SDA y SCL respectivamente

Paso 3: código para la programación de tareas

En este tutorial, estamos realizando tres operaciones

• Leer los datos de SHT11 usando el protocolo I2C
• alojar el servidor web y publicar la lectura del sensor en la página web
• publicar las lecturas del sensor en ThingSpeak API

Para lograr esto, estamos usando la biblioteca TaskScheduler. Hemos programado tres tareas diferentes referidas a tres 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 la Tarea1 alcanza su tiempo de espera, la Tarea 2 está habilitada y la Tarea1 está deshabilitada.
• Nos conectamos a AP en esta devolución de llamada, se toman dos variables booleanas para encargarse del cambio entre STA y AP
• En la Tarea 2, estamos alojando un servidor web en 192.168.1.4. Esta tarea se ejecuta cada 5 segundos hasta que alcanza su tiempo de espera, que es de 50 segundos.

• Cuando la Tarea 2 alcanza el tiempo de espera, la Tarea 3 está habilitada y la Tarea2 está deshabilitada.

• Nos conectamos a STA (IP local) en esta llamada En la Tarea 3 estamos publicando la lectura del sensor en la nube ThingSpeak API
• La tarea 3 se ejecuta cada cinco segundos hasta que alcanza su tiempo de espera, es decir, 50 segundos
• Cuando la Tarea 3 alcanza su tiempo de espera, la Tarea 1 se habilita de nuevo y la Tarea 3 se deshabilita.
• Cuando no se realiza ninguna devolución de llamada o el dispositivo está inactivo, entra en modo de suspensión ligera, lo que ahorra energía.

void taskI2CCallback ();

void taskI2CDisable (); void taskAPCallback (); void taskAPDisable (); void taskWiFiCallback (); void taskWiFiDisable (); // Tareas para i2c, servidor web de alojamiento y publicación en thingspeak Tarea tI2C (1 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL, & taskI2CDisable); Tarea tI2C (1 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL, & taskI2CDisable); Task tAP (5 * TASK_SECOND, TASK_FOREVER, & taskAPCallback, & ts, false, NULL y taskAPDisable); Tarea tWiFi (5 * TASK_SECOND, TASK_FOREVER, & taskWiFiCallback, & ts, false, NULL y taskWiFiDisable); // tiempo de espera para las tareas tI2C.setTimeout (10 * TASK_SECOND); tAP.setTimeout (50 * TASK_SECOND); tWiFi.setTimeout (50 * TASK_SECOND); // habilitar la tarea I2C tI2C.enable ();

Paso 4: Código para leer valores de temperatura y humedad

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 SHT31.

SHT31 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.

// Devolución de llamada de tarea I2C void taskI2CCallback () {Serial.println ("taskI2CStarted"); raíz int sin firmar [6]; // comenzar la transmisión desde 0x44; Wire.beginTransmission (Addr); // para una transmisión de un disparo con alta repetibilidad usamos 0x2C (MSB) y 0x06 (LSB) Wire.write (0x2C); Wire.write (0x06); // finalizar la transmisión Wire.endTransmission (); // solicitar bytes de 0x44 Wire.beginTransmission (Addr); Wire.endTransmission (); Wire.requestFrom (Dirección, 6); if (Wire.available () == 6) {// data [0] y data [1] contienen 16 bits de temperatura. root [0] = Wire.read (); root [1] = Wire.read (); // los datos [2] contienen 8 bits de la raíz CRC [2] = Wire.read (); // datos [3] y datos [4] contienen 16 bits de raíz de humedad [3] = Wire.read (); root [4] = Wire.read (); // los datos [5] constan de una raíz CRC de 8 bits [5] = Wire.read (); } int temp = (raíz [0] * 256) + raíz [1]; // desplazar MSB en 8 bits agregar LSB float cTemp = -45.0 + (175.0 * temp / 65535.0); float fTemp = (cTemp * 1.8) + 32.0; // cambia el MSB en 8 bits, agrega LSB a él dividido en resolución completa y * 100 para el porcentaje de humedad flotante = (100.0 * ((root [3] * 256.0) + root [4])) / 65535.0; tempC = cTemp; tempF = fTemp; húmedo = humedad; Serial.print ("Temperatura en C: / t"); Serial.println (String (cTemp, 1)); Serial.print ("Temperatura en F: / t"); Serial.println (String (fTemp, 1)); Serial.print ("Humedad: / t"); Serial.println (String (humedad, 1)); }

Paso 5: código para alojar un servidor web

Hemos alojado un servidor web desde nuestro dispositivo en una IP estática.

La biblioteca ESP8266WebServer se utiliza para alojar el servidor web

• Primero debemos declarar la dirección IP, la puerta de enlace y la máscara de subred para crear nuestra IP estática
• Ahora declare ssid y contraseña para su punto de acceso. Conéctese al punto de acceso desde cualquier dispositivo STA
• aloje el servidor en el puerto 80, que es un puerto predeterminado para el protocolo de comunicación de Internet, el Protocolo de transferencia de hipertexto (HTTP) ingrese 192.168.1.4 en su navegador web para la página web de introducción y 192.168.1.4/Value para la página web de lectura del sensor

// IP estático para APIPAddress ap_local_IP (192, 168, 1, 4); IPAddress ap_gateway (192, 168, 1, 254); IPAddress ap_subnet (255, 255, 255, 0); // ssid y AP para WiFi local en modo STA const char WiFissid = "*********"; const char WiFipass = "*********"; // ssid y pase para AP const char APssid = "********"; const char APpass = "********"; Servidor ESP8266WebServer (80); configuración vacía {server.on ("/", onHandleDataRoot); server.on ("/ Value", onHandleDataFeed); server.onNotFound (onHandleNotFound);} void taskAPCallback () {Serial.println ("taskAP iniciado"); server.handleClient (); } void onHandleDataRoot () {server.send (200, "texto / html", PAGE1); } void onHandleDataFeed () {server.send (200, "texto / html", PAGE2); } void onHandleNotFound () {String message = "Archivo no encontrado / n / n"; mensaje + = "URI:"; mensaje + = servidor.uri (); mensaje + = "\ nMétodo:"; mensaje + = (server.method () == HTTP_GET)? "GET": "POST"; mensaje + = "\ nArgumentos:"; mensaje + = servidor.args (); mensaje + = "\ n"; server.send (404, "texto / plano", mensaje); } void reconnectAPWiFi () {WiFi.mode (WIFI_AP_STA); retraso (100); WiFi.disconnect (); estado booleano = WiFi.softAPConfig (ap_local_IP, ap_gateway, ap_subnet); if (status == true) {Serial.print ("Configurando soft-AP…"); boolean ap = WiFi.softAP (APssid, APpass); if (ap == true) {Serial.print ("conectado a: / t"); // Dirección IP myIP = WiFi.softAPIP (); Serial.println (WiFi.softAPIP ()); } servidor.begin ();

}

Paso 6: Configuración de Thingspeak

ThingSpeak es una plataforma de IoT. ThingSpeak es un servicio web gratuito que le permite recopilar y almacenar datos de sensores en la nube.

En este paso, le daré un breve procedimiento para configurar su cuenta de Thing Speak

• Regístrese para obtener una nueva cuenta de usuario en ThingSpeak
• Cree un nuevo canal seleccionando Canales, Mis canales y luego Nuevo canal
• Edita tus campos
• Estos campos contienen los datos de su sensor
• Tenga en cuenta la clave de API de escritura y el ID de canal
• En su boceto de Arduino, puede usar la biblioteca ThingSpeak para Arduino o puede PUBLICAR directamente los datos en la API de ThingSpeak
• el siguiente paso explica cómo publicar el contenido en la API Thing Speak

Paso 7: Código para publicar datos en Thing Speak

Aquí estamos publicando las lecturas del sensor en Thing Speak. Se necesitan los siguientes pasos para completar esta tarea:

• Crea tu cuenta en thing speakCrea canales y campos para almacenar los datos de tus sensores
• podemos obtener y publicar los datos de ESP en thingSpeak y viceversa usando solicitudes GET y POST a la API.
• podemos publicar nuestros datos en ThingSpeak de la siguiente manera

id taskWiFiCallback () {WiFiClient wifiClient; if (wifiClient.connect (hostId, 80)) {String postStr = apiKey; postStr + = "& campo1 ="; postStr + = String (húmedo); postStr + = "& campo2 ="; postStr + = String (tempC); postStr + = "& field3 ="; postStr + = String (tempF); postStr + = "\ r / n / r / n"; wifiClient.print ("POST / actualización HTTP / 1.1 / n"); wifiClient.print ("Host: api.thingspeak.com / n"); wifiClient.print ("Conexión: cerrar / n"); wifiClient.print ("X-THINGSPEAKAPIKEY:" + apiKey + "\ n"); wifiClient.print ("Tipo de contenido: aplicación / x-www-form-urlencoded / n"); wifiClient.print ("Contenido-Longitud:"); wifiClient.print (postStr.length ()); wifiClient.print ("\ n / n"); wifiClient.print (postStr); } wifiClient.stop (); }

Paso 8: Código general

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

Paso 9: Créditos

• Arduino JSON
• ESP826WebServer
• Programador de tareas
• SHT 31
• Escaneo I2C
• Tutorial de instructables HIH6130
• Cable
• NCD.io