THINGSPEAK APP DE TEMPERATURA I HUMITAT AMB ESP8266: 9 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:12

Mentre jugava amb les meves coses electròniques, vaig tenir aquesta idea per fer una aplicació meteorològica basada en web. Aquesta aplicació web utilitza el sensor SHT31 per obtenir les dades de temperatura i humitat en temps real. Hem desplegat el nostre projecte al mòdul WiFi ESP8266. En línia o fora de línia No us preocupeu, ja sigui en línia o fora de línia, rebrà les actualitzacions meteorològiques des de qualsevol lloc i en qualsevol moment. Aquesta aplicació web publica dades al servidor web local i al núvol. Per a operacions al núvol, fem servir l’API ThingSpeak. SHT31 utilitza I2C per obtenir les dades del sensor.

SHT 31 és un sensor de temperatura i humitat fabricat per Sensirion. El SHT31 proporciona un alt nivell de precisió al voltant del ± 2% d’HR. El seu rang d’humitat oscil·la entre el 0 i el 100% i el rang de temperatura entre -40 i 125 ° C. És molt més fiable i ràpid amb 8 segons de temps de resposta del sensor. La seva funcionalitat inclou processament de senyal millorat i compatibilitat I2C. Disposa de diferents modes d’operació que el fan eficient en l’energia.

En aquest tutorial, hem relacionat SHT 31 amb el tauler Adafruit Huzzah. Per llegir els valors de temperatura i humitat hem utilitzat un escut ESP8266 I2C. Aquest adaptador fa que tots els pins siguin accessibles a l'usuari i ofereix un entorn I2C fàcil d'utilitzar.

Pas 1: es requereix maquinari

Maquinari utilitzat per completar aquesta tasca:

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

Pas 2: connexions de maquinari

Aquest pas inclou la guia de connexió de maquinari. Aquesta secció explica bàsicament les connexions de cablejat necessàries entre el sensor i l’ESP8266. Les connexions són les següents.

1. El SHT31 funciona sobre I2C. La imatge anterior mostra la connexió entre el mòdul ESP8266 i SHT31. Estem utilitzant un cable I2C per fer-ho, ja que podem fer servir cables de pont de 4 a F.
2. un cable s'utilitza per a Vcc, el segon per a GND i altres dos per a SDA i SCL respectivament
3. Segons l’adaptador I2C, el pin2 i el pin 14 d’una placa ESP8266 s’utilitzen com SDA i SCL respectivament

Pas 3: Codi per a la programació de tasques

En aquest tutorial, estem realitzant tres operacions

• Llegiu les dades de SHT11 mitjançant el protocol I2C
• allotgeu el servidor web i publiqueu la lectura del sensor a la pàgina web
• publiqueu les lectures del sensor a l'API ThingSpeak

Per aconseguir-ho, estem utilitzant la biblioteca TaskScheduler. Hem programat tres tasques diferents referents a tres operacions de control diferents. es fa de la següent manera

• La tasca 1 serveix per llegir el valor del sensor que aquesta tasca s'executa durant 1 segon fins que arriba a un temps d'espera de 10 segons.
• Quan la tasca 1 arriba al seu temps d'espera, la tasca 2 està habilitada i la tasca 1 està desactivada.
• Ens connectem a AP en aquesta devolució de trucada. Es prenen dues variables booleanes per tenir cura del canvi entre STA i AP
• A la tasca 2, allotgem un servidor web al número 192.168.1.4. Aquesta tasca s’executa cada 5 segons fins que arriba al seu temps d’espera que és de 50 segons

• Quan la tasca 2 arriba al temps d'espera, la tasca 3 està habilitada i la tasca 2 està desactivada.

• Ens connectem a STA (IP local) en aquest calback A la tasca 3 publicem la lectura del sensor a l'API ThingSpeak del núvol
• La tasca 3 s'executa cada cinc segons fins que ha arribat al seu temps d'espera, és a dir, 50 segons
• Quan Task3 arriba al seu temps d'espera, la Task 1 es torna a activar i la Task3 es desactiva.
• Quan no es crida cap devolució de trucada o el dispositiu està inactiu, passa a Light Sleep per estalviar energia.

void taskI2CCallback ();

void taskI2CDisable (); void taskAPCallback (); void taskAPDisable (); void taskWiFiCallback (); void taskWiFiDisable (); // Tasques per a i2c, allotjament de servidor web i publicació a thingspeak Tasca tI2C (1 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL i & taskI2CDisable); Tasca tI2C (1 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL i & taskI2CDisable); Tasca tAP (5 * TASK_SECOND, TASK_FOREVER, & taskAPCallback, & ts, false, NULL i & taskAPDisable); Tasca tWiFi (5 * TASK_SECOND, TASK_FOREVER i & taskWiFiCallback, & ts, false, NULL i & taskWiFiDisable); // temps d'espera per a tasques tI2C.setTimeout (10 * TASK_SECOND); tAP.setTimeout (50 * TASC_SECOND); tWiFi.setTimeout (50 * TASK_SECOND); // habilitar la tasca I2C tI2C.enable ();

Pas 4: Codi de lectura de valors de temperatura i humitat

Estem utilitzant la biblioteca Wire.h per llegir els valors de temperatura i humitat. Aquesta biblioteca facilita la comunicació i2c entre el sensor i el dispositiu mestre. 0x44 és l'adreça I2C de SHT31.

SHT31 funciona en un mode d’operacions diferent. Podeu consultar el full de dades per a això. Estem utilitzant 0x2C i 0x06 com a MSB i LSB respectivament per a operacions de tir únic.

// I2C devolució de trucada de la tasca void taskI2CCallback () {Serial.println ("taskI2CStarted"); arrel int sense signar [6]; // comença la transmissió a partir de 0x44; Wire.beginTransmission (Addr); // per a una transmissió d'un tret amb alta repetibilitat, fem servir 0x2C (MSB) i 0x06 (LSB) Wire.write (0x2C); Wire.write (0x06); // finalitzar la transmissió Wire.endTransmission (); // sol·licita bytes de 0x44 Wire.beginTransmission (Addr); Wire.endTransmission (); Wire.requestFrom (Addr, 6); if (Wire.available () == 6) {// data [0] i data [1] conté 16 bits de temperatura. arrel [0] = Wire.read (); arrel [1] = Wire.read (); // dades [2] conté 8 bits d’arrel CRC [2] = Wire.read (); // dades [3] i dades [4] contenen 16 bits d’arrel d’humitat [3] = Wire.read (); arrel [4] = Wire.read (); // dades [5] consisteix en arrel CRC de 8 bits [5] = Wire.read (); } int temp = (arrel [0] * 256) + arrel [1]; // canvia MSB per 8 bits afegeix LSB float cTemp = -45,0 + (175,0 * temp / 65535.0); float fTemp = (cTemp * 1,8) + 32,0; // canvieu el MSB per 8 bits, afegiu-hi LSB per la resolució màxima i * 100 per percentatge d'humitat flotant = (100.0 * ((root [3] * 256.0) + root [4])) / 65535.0; tempC = cTemp; tempF = fTemp; humit = humitat; Serial.print ("Temperatura en C: / t"); Serial.println (String (cTemp, 1)); Serial.print ("Temperatura en F: / t"); Serial.println (String (fTemp, 1)); Serial.print ("Humitat: / t"); Serial.println (cadena (humitat, 1)); }

Pas 5: codi per allotjar un servidor web

Hem allotjat un servidor web des del nostre dispositiu en una adreça IP estàtica.

La biblioteca ESP8266WebServer s’utilitza per allotjar el servidor web

• Primer, hem de declarar l'adreça IP, la passarel·la i la màscara de subxarxa per crear la nostra IP estàtica
• Ara declareu ssid i contrasenya per al vostre punt d'accés. Connecteu-vos al punt d'accés des de qualsevol dispositiu STA
• allotgeu el servidor al port 80 que és un port per defecte per al protocol de comunicació d’Internet, el protocol de transferència d’hipertext (HTTP) introduïu 192.168.1.4 al navegador web per a la pàgina web d’introducció i 192.168.1.4/Value per a la pàgina web de lectura de sensors

// IP estàtica per a APIPAddress ap_local_IP (192, 168, 1, 4); IPAddress ap_gateway (192, 168, 1, 254); Adreça IP ap_subnet (255, 255, 255, 0); // ssid i AP per WiFi local en mode STA const char WiFissid = "*********"; const char WiFipass = "*********"; // ssid and pass for AP const char APssid = "********"; const char APpass = "********"; Servidor ESP8266WebServer (80); configuració nul·la {server.on ("/", onHandleDataRoot); server.on ("/ Value", onHandleDataFeed); server.onNotFound (onHandleNotFound);} void taskAPCallback () {Serial.println ("taskAP iniciat"); server.handleClient (); } void onHandleDataRoot () {server.send (200, "text / html", PÀGINA1); } void onHandleDataFeed () {server.send (200, "text / html", PÀGINA2); } void onHandleNotFound () {String message = "No s'ha trobat el fitxer / n / n"; missatge + = "URI:"; missatge + = server.uri (); missatge + = "\ nMètode:"; missatge + = (server.method () == HTTP_GET)? "GET": "POST"; missatge + = "\ nArguments:"; missatge + = server.args (); missatge + = "\ n"; server.send (404, "text / normal", missatge); } void reconnectAPWiFi () {WiFi.mode (WIFI_AP_STA); retard (100); WiFi.disconnect (); estat booleà = WiFi.softAPConfig (ap_local_IP, ap_gateway, ap_subnet); if (estat == true) {Serial.print ("Configuració de soft-AP …"); ap boolean = WiFi.softAP (APssid, APpass); if (ap == true) {Serial.print ("connectat a: / t"); // IPAddress myIP = WiFi.softAPIP (); Serial.println (WiFi.softAPIP ()); } server.begin ();

}

Pas 6: Configuració de Thingspeak

ThingSpeak és una plataforma IoT. ThingSpeak és un servei web gratuït que us permet recopilar i emmagatzemar dades del sensor al núvol.

En aquest pas, us faré un breu procediment per configurar el vostre compte de Thing Speak

• Registreu-vos per obtenir un nou compte d'usuari a ThingSpeak
• Per crear un canal nou, seleccioneu Canals, Els meus canals i, a continuació, Canal nou
• Editeu els vostres camps
• Aquests camps contenen les dades del sensor
• Tingueu en compte la clau d'API d'escriptura i l'identificador de canal
• Al vostre esbós Arduino, podeu utilitzar la biblioteca ThingSpeak per Arduino o podeu POSTAR directament les dades a l'API ThingSpeak
• el següent pas es detalla sobre la publicació del contingut a l'API Thing Speak

Pas 7: Codi per publicar dades a Thing Speak

Aquí publiquem les lectures del sensor a Thing Speak. cal completar aquesta tasca amb els passos següents:

• Creeu el vostre compte en cosa SpeakCreateu canals i camps per emmagatzemar les dades del sensor
• podem obtenir i publicar les dades des d’ESP a thingSpeak i viceversa mitjançant peticions GET i POST a l’API.
• podem publicar les nostres dades a ThingSpeak de la següent manera

id taskWiFiCallback () {WiFiClient wifiClient; if (wifiClient.connect (hostId, 80)) {String postStr = apiKey; postStr + = "& field1 ="; postStr + = Cadena (humida); postStr + = "& field2 ="; postStr + = Cadena (tempC); postStr + = "& field3 ="; postStr + = Cadena (tempF); postStr + = "\ r / n / r / n"; wifiClient.print ("POST / actualització HTTP / 1.1 / n"); wifiClient.print ("Amfitrió: api.thingspeak.com / n"); wifiClient.print ("Connexió: tancar / n"); wifiClient.print ("X-THINGSPEAKAPIKEY:" + apiKey + "\ n"); wifiClient.print ("Tipus de contingut: application / x-www-form-urlencoded / n"); wifiClient.print ("Longitud del contingut:"); wifiClient.print (postStr.length ()); wifiClient.print ("\ n / n"); wifiClient.print (postStr); } wifiClient.stop (); }

Pas 8: Codi general

El codi general està disponible al meu dipòsit de GitHub

Pas 9: Crèdits

• Arduino JSON
• ESP826WebServer
• Planificador de tasques
• SHT 31
• Escaneig I2C
• Tutorial instructiu HIH6130
• Filferro
• NCD.io