Aplicație meteo Web folosind Esp8266: 7 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

SHT 31 este un senzor de temperatură și umiditate realizat de Sensirion. SHT31 oferă un nivel ridicat de precizie în jur de ± 2% HR. Intervalul său de umiditate este cuprins între 0 și 100%, iar temperatura este între -40 și 125 ° C. Este mult mai fiabil și mai rapid cu 8 sec. De timp de răspuns al senzorului. Funcționalitatea sa include procesare îmbunătățită a semnalului și compatibilitate I2C. Are diferite moduri de operare, ceea ce îl face eficient din punct de vedere energetic.

În acest tutorial, am interfațat SHT 31 cu placa Adafruit Huzzah. Pentru citirea valorilor de temperatură și umiditate am folosit scutul ESP8266 I2C. Acest adaptor face ca toate pinii să fie accesibile utilizatorului și oferă un mediu I2C ușor de utilizat.

Pasul 1: hardware necesar

Hardware folosit pentru a finaliza această sarcină:

1. SHT31

2. Adafruit Huzzah ESP8266

3. Adaptor ESP8266 I2C

4. Cablu I2C

Pasul 2: Conexiuni hardware

Acest pas include ghidul de conectare hardware. Această secțiune explică practic conexiunile de cablare necesare între senzor și ESP8266. Conexiunile sunt după cum urmează.

1. SHT31 funcționează pe I2C. Imaginea de mai sus arată conexiunea dintre modulul ESP8266 și SHT31. Folosim cablu I2C pentru acesta fie putem folosi 4 fire jumper de la F la F.
2. un fir este utilizat pentru Vcc, al doilea fir pentru GND și alte două pentru SDA și respectiv SCL.
3. Conform adaptorului I2C pin2 și pinul 14 al unei plăci ESP8266 sunt utilizate ca SDA și respectiv SCL

Pasul 3: Cod pentru programarea sarcinilor

În acest tutorial, efectuăm trei operații

• Citiți datele de la SHT11 folosind protocolul I2C
• găzduiește serverul web și postează citirea senzorului pe pagina web
• postează citirile senzorilor în API-ul ThingSpeak

Pentru a realiza acest lucru, folosim biblioteca TaskScheduler. Am programat trei sarcini diferite referitoare la trei operațiuni de control diferite. acest lucru se face după cum urmează

• Sarcina 1 este pentru citirea valorii senzorului, această sarcină rulează timp de 1 secundă până când ajunge la expirarea de 10 secunde.
• Când Task1 își atinge expirarea, Task 2 este activat și Task1 este dezactivat.
• Ne conectăm la AP în acest apel invers, două variabile booleene sunt luate pentru a avea grijă de comutarea între STA și AP
• În Task 2 găzduim un server web la 192.168.1.4. Această sarcină se execută la fiecare 5 secunde până când atinge expirarea, care este de 50 sec
• Când Task 2 ajunge la timeout Task 3 este activat și Task2 este dezactivat.
• Ne conectăm la STA (IP local) în acest apel invers
• În Task 3 postăm citirea senzorului în cloud ThingSpeak API
• Activitatea 3 se execută la fiecare cinci secunde până când a atins expirarea, adică 50 sec
• Când Task3 își atinge expirarea, Task 1 este activat din nou și Task3 este dezactivat.
• Când nu se apelează niciun apel invers sau dispozitivul este inactiv, acesta trece la Light Sleep, economisind astfel energie.

Programator ts;

// Sarcini pentru i2c, găzduirea serverului web și postarea pe thingspeak

Task tI2C (1 * TASK_SECOND, TASK_FOREVER, & taskI2CCallback, & ts, false, NULL și & taskI2CDisable); Task tAP (5 * TASK_SECOND, TASK_FOREVER, & taskAPCallback, & ts, false, NULL și & taskAPDisable); Task tWiFi (5 * TASK_SECOND, TASK_FOREVER, & taskWiFiCallback, & ts, false, NULL și & taskWiFiDisable); // timeout pentru sarcini tI2C.setTimeout (10 * TASK_SECOND); tAP.setTimeout (50 * TASK_SECOND); tWiFi.setTimeout (50 * TASK_SECOND); // activate I2C task tI2C.enable ();

Pasul 4: Cod pentru citirea valorilor de temperatură și umiditate

Folosim biblioteca Wire.h pentru a citi valorile de temperatură și umiditate. Această bibliotecă facilitează comunicarea i2c între senzor și dispozitivul master. 0x44 este adresa I2C pentru SHT31.

SHT31 funcționează într-un mod diferit de operațiuni. Puteți consulta foaia de date pentru aceasta.

Folosim 0x2C și 0x06 ca MSB și, respectiv, LSB pentru operații cu o singură fotografie.

// I2C task callback void taskI2CCallback ()

{Serial.println ("taskI2CStarted"); rădăcină int nesemnată [6]; // începe transmisia de la 0x44; Wire.beginTransmission (Addr); // pentru transmisie cu o singură lovitură cu repetabilitate ridicată folosim 0x2C (MSB) și 0x06 (LSB) Wire.write (0x2C); Wire.write (0x06); // terminare transmisie Wire.endTransmission (); // solicitați octeți de la 0x44 Wire.beginTransmission (Addr); Wire.endTransmission (); Wire.requestFrom (Addr, 6); if (Wire.available () == 6) {// data [0] și data [1] conține 16 biți de temperatură. rădăcină [0] = Wire.read (); rădăcină [1] = Wire.read (); // date [2] conține 8 biți de rădăcină CRC [2] = Wire.read (); // datele [3] și datele [4] conțin 16 biți de umiditate rădăcină [3] = Wire.read (); rădăcină [4] = Wire.read (); // date [5] constă din rădăcină CRC pe 8 biți [5] = Wire.read (); } int temp = (rădăcină [0] * 256) + rădăcină [1]; // schimbați MSB cu 8 biți adăugați LSB float cTemp = -45,0 + (175,0 * temp / 65535.0); float fTemp = (cTemp * 1,8) + 32,0; // schimbați MSB cu 8 biți adăugați LSB la acesta împărțiți cu rezoluție completă și * 100 pentru procentul de umiditate float = (100.0 * ((rădăcină [3] * 256.0) + rădăcină [4])) / 65535.0;

tempC = cTemp;

tempF = fTemp; umed = umiditate; Serial.print ("Temperatura în C: / t"); Serial.println (String (cTemp, 1)); Serial.print ("Temperatura în F: / t"); Serial.println (String (fTemp, 1)); Serial.print ("Umiditate: / t"); Serial.println (String (umiditate, 1)); }

Pasul 5: Cod pentru găzduirea unui server Web

Am găzduit un server web de pe dispozitivul nostru pe un IP static.

• Biblioteca ESP8266WebServer este utilizată pentru a găzdui serverul web
• Mai întâi trebuie să declarăm adresa IP, gateway-ul și masca de subrețea pentru a crea IP-ul nostru static
• Acum declarați ssid și parola pentru punctul dvs. de acces.
• conectați-vă la punctul de acces de pe orice dispozitiv STA
• găzduiește serverul pe portul 80, care este un port implicit pentru protocolul de comunicații pe internet, Hypertext Transfer Protocol (HTTP)
• introduceți 192.168.1.4 pe browserul dvs. web pentru pagina web introductivă și 192.168.1.4/Value pentru pagina web care citește senzorul

// Ip static pentru AP

Adresa IP ap_local_IP (192, 168, 1, 4);

IPAddress ap_gateway (192, 168, 1, 254);

IPAddress ap_subnet (255, 255, 255, 0); // ssid și AP pentru WiFi local în modul STA

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

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

// ssid și treceți pentru AP

const char APssid = "********";

const char APpass = "********";

Server ESP8266WebServer (80);

configurare nulă {

server.on ("/", onHandleDataRoot);

server.on ("/ Value", onHandleDataFeed);

server.onNotFound (onHandleNotFound);

}

void taskAPCallback () {

Serial.println („taskAP a început”);

server.handleClient ();

}

void onHandleDataRoot () {server.send (200, "text / html", PAGE1); }

void onHandleDataFeed () {

server.send (200, "text / html", PAGE2); }

void onHandleNotFound () {

String message = "Fișierul nu a fost găsit / n / n";

mesaj + = "URI:";

mesaj + = server.uri ();

mesaj + = "\ nMetoda:";

mesaj + = (server.method () == HTTP_GET)? "GET": "POST";

mesaj + = "\ nArgumente:";

mesaj + = server.args ();

mesaj + = "\ n";

server.send (404, „text / simplu”, mesaj);}

void reconnectAPWiFi () {

WiFi.mode (WIFI_AP_STA);

întârziere (100);

WiFi.disconnect ();

starea booleană = WiFi.softAPConfig (ap_local_IP, ap_gateway, ap_subnet);

if (status == true) {

Serial.print („Setarea soft-AP …”);

boolean ap = WiFi.softAP (APssid, APpass);

if (ap == true) {

Serial.print ("conectat la: / t");

// IPAddress myIP = WiFi.softAPIP ();

Serial.println (WiFi.softAPIP ());

}

server.begin ();

}

}

Pasul 6: Cod pentru postarea de date la Thing Speak

Aici postăm citirile senzorilor la Thing Speak. următorii pași sunt necesari pentru a finaliza această sarcină-

• Creați-vă contul în chestii de vorbă
• Creați canale și câmpuri pentru a stoca datele senzorilor
• putem obține și posta datele de la ESP la thingSpeak și viceversa folosind solicitările GET și POST către API.
• ne putem posta datele pe ThingSpeak după cum urmează

void taskWiFiCallback () {

WiFiClient wifiClient; if (wifiClient.connect (hostId, 80)) {String postStr = apiKey; postStr + = "& field1 ="; postStr + = String (umed); postStr + = "& field2 ="; postStr + = String (tempC); postStr + = "& field3 ="; postStr + = String (tempF); postStr + = "\ r / n / r / n"; wifiClient.print ("POST / actualizare HTTP / 1.1 / n"); wifiClient.print ("Gazdă: api.thingspeak.com / n"); wifiClient.print ("Conexiune: închidere / n"); wifiClient.print ("X-THINGSPEAKAPIKEY:" + apiKey + "\ n"); wifiClient.print ("Content-Type: application / x-www-form-urlencoded / n"); wifiClient.print ("Lungime conținut:"); wifiClient.print (postStr.length ()); wifiClient.print ("\ n / n"); wifiClient.print (postStr); } wifiClient.stop (); }

Pasul 7: Cod general

Codul general este disponibil în depozitul meu github

Credite:

• Arduino JSON: ArduinoJson
• ESP826WebServer
• Planificator de sarcini
• SHT 31
• Scanare I2C
• HIH6130 tutorial instructabile
• Sârmă Arduino
• NCD.io