THINGSPEAK TEMPERATURA ȘI UMIDITATEA APLICAȚIE FOLOSIND ESP8266: 9 pași

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

În timp ce lucrau cu lucrurile mele electronice, mi-a venit această idee să creez aplicații meteorologice bazate pe web. Această aplicație web utilizează senzorul SHT31 pentru obținerea datelor în timp real de temperatură și umiditate. Am implementat proiectul nostru pe modulul WiFi ESP8266. Online sau offline! Nu trebuie să vă faceți griji, indiferent dacă sunteți online sau offline, veți primi actualizările meteo de oriunde și oricând. Această aplicație web postează date pe serverul web local, precum și în cloud. Pentru operațiuni în cloud, folosim API-ul ThingSpeak. SHT31 folosește I2C pentru a obține datele de la senzor.

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. SHT 31
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 expiră, 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 calback Î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 expiră, 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.

void taskI2CCallback ();

void taskI2CDisable (); void taskAPCallback (); void taskAPDisable (); void taskWiFiCallback (); void taskWiFiDisable (); // 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 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
• Declarați acum 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 comunicare pe internet, Hypertext Transfer Protocol (HTTP) introduce 192.168.1.4 pe browserul tău web pentru pagina de introducere și 192.168.1.4/Value pentru pagina de citire a senzorului

// IP static pentru APIPAddress 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 pass for AP const char APssid = "********"; const char APpass = "********"; Server ESP8266WebServer (80); void setup {server.on ("/", onHandleDataRoot); server.on ("/ Value", onHandleDataFeed); server.onNotFound (onHandleNotFound);} void taskAPCallback () {Serial.println ("taskAP pornit"); 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: Configurare Thingspeak

ThingSpeak este o platformă IoT. ThingSpeak este un serviciu web gratuit care vă permite să colectați și să stocați datele senzorilor în cloud.

În acest pas, vă voi oferi o scurtă procedură pentru a vă configura contul Thing Speak

• Înscrieți-vă pentru un nou cont de utilizator în ThingSpeak
• Creați un canal nou selectând canale, canalele mele, apoi canal nou
• Editați-vă câmpurile
• Aceste câmpuri conțin datele senzorului
• Rețineți cheia de scriere API și ID-ul canalului
• Pe schița dvs. Arduino, puteți utiliza biblioteca ThingSpeak pentru Arduino sau puteți POST direct datele către ThingSpeak API
• următorul pas detaliază despre postarea conținutului în API-ul Thing Speak

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

id 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 8: Cod general

Codul general este disponibil în depozitul meu GitHub

Pasul 9: Credite

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