Aplicació web Weather amb Esp8266: 7 passos

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

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

2. Adafruit Huzzah ESP8266

3. Adaptador ESP8266 I2C

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 s'activa 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 aquesta devolució de trucada
• A la tasca 3 publiquem la lectura del sensor a l'API ThingSpeak al 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 la tasca 3 arriba al seu temps d'espera, la tasca 1 es torna a activar i la tasca 3 es desactiva.
• Quan no es crida cap devolució de trucada o el dispositiu està inactiu, passa a Light Sleep per estalviar energia.

Programador ts;

// Tasques per a i2c, allotjament de servidors web i publicacions a Thingspeak

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.

// Devolució de trucada de tasca I2C 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 del vostre punt d'accés.
• connecteu-vos al punt d'accés des de qualsevol dispositiu STA
• allotjar el servidor al port 80, que és un port per defecte per al protocol de comunicació d’Internet, 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/Valor per a la pàgina web de lectura de sensors

// IP estàtica per a AP

Adreça IP ap_local_IP (192, 168, 1, 4);

Adreça IP ap_gateway (192, 168, 1, 254);

IPAddress ap_subnet (255, 255, 255, 0); // ssid i AP per WiFi local en mode STA

const char WiFissid = "*********";

const char WiFipass = "*********";

// ssid i passa per 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 == cert) {

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: 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:

• Crea el teu compte en cosa que parli
• Creeu 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

void 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 7: Codi general

El codi general està disponible al meu repositori de github

Crèdits:

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