APP THINGSPEAK TEMPERATURA E UMIDITÀ UTILIZZANDO ESP8266: 9 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Mentre armeggiavo con la mia roba elettronica, mi è venuta l'idea di creare un'app meteo basata sul web. Questa app web utilizza il sensore SHT31 per ottenere i dati di temperatura e umidità in tempo reale. Abbiamo distribuito il nostro progetto sul modulo WiFi ESP8266. Online o offline! Non c'è bisogno di preoccuparsi, che tu sia online o offline riceverai gli aggiornamenti meteo da qualsiasi luogo e in qualsiasi momento. Questa app Web invia i dati al server Web locale e al cloud. Per le operazioni cloud, utilizziamo l'API ThingSpeak. SHT31 utilizza I2C per ottenere i dati dal sensore.

SHT 31 è un sensore di temperatura e umidità prodotto da Sensirion. L'SHT31 fornisce un alto livello di precisione intorno al ±2% di umidità relativa. Il suo intervallo di umidità è compreso tra 0 e 100% e l'intervallo di temperatura è compreso tra -40 e 125 °C. È molto più affidabile e veloce con 8 secondi di tempo di risposta del sensore. La sua funzionalità include elaborazione del segnale avanzata e compatibilità I2C. Ha diverse modalità di funzionamento che lo rendono efficiente dal punto di vista energetico.

In questo tutorial, abbiamo interfacciato SHT 31 con la scheda Adafruit Huzzah. Per la lettura dei valori di temperatura e umidità abbiamo utilizzato lo schermo ESP8266 I2C. Questo adattatore rende tutti i pin accessibili all'utente e offre un ambiente I2C user-friendly.

Passaggio 1: hardware richiesto

Hardware utilizzato per completare questa attività:

1. SHT 31
2. Adafruit Huzzah ESP8266
3. Adattatore I2C ESP8266
4. Cavo I2C

Passaggio 2: connessioni hardware

Questo passaggio include la guida al collegamento hardware. Questa sezione spiega fondamentalmente i collegamenti di cablaggio richiesti tra il sensore e ESP8266. I collegamenti sono i seguenti.

1. L'SHT31 funziona su I2C. L'immagine sopra mostra la connessione tra ESP8266 e il modulo SHT31. Stiamo usando il cavo I2C per questo o possiamo usare 4 ponticelli da F a F.
2. un filo viene utilizzato per Vcc, il secondo filo per GND e altri due rispettivamente per SDA e SCL
3. Secondo l'adattatore I2C, il pin2 e il pin 14 di una scheda ESP8266 vengono utilizzati rispettivamente come SDA e SCL

Passaggio 3: codice per la pianificazione delle attività

In questo tutorial, stiamo eseguendo tre operazioni

• Leggere i dati da SHT11 utilizzando il protocollo I2C
• ospitare il server web e pubblicare la lettura del sensore sulla pagina web
• posta le letture del sensore su ThingSpeak API

Per raggiungere questo obiettivo stiamo utilizzando la libreria TaskScheduler. Abbiamo programmato tre diverse attività riferite a tre diverse operazioni di controllo. questo è fatto come segue

• L'attività 1 serve per leggere il valore del sensore, questa attività viene eseguita per 1 secondo fino a raggiungere il timeout di 10 secondi.
• Quando Task1 raggiunge il timeout, l'attività 2 è abilitata e l'attività 1 è disabilitata.
• Ci colleghiamo ad AP in questo callback, vengono prese due variabili booleane per occuparsi del passaggio tra STA e AP
• Nell'attività 2 stiamo ospitando un server web a 192.168.1.4. Questa attività viene eseguita ogni 5 secondi fino a raggiungere il timeout che è di 50 secondi

• Quando l'attività 2 raggiunge il timeout, l'attività 3 è abilitata e l'attività 2 è disabilitata.

• Ci colleghiamo a STA (IP locale) in questo calbackIn Task 3 stiamo pubblicando la lettura del sensore sull'API ThingSpeak cloud
• L'attività 3 viene eseguita ogni cinque secondi fino al raggiungimento del timeout, ovvero 50 secondi
• Quando il Task3 raggiunge il suo timeout, il Task 1 viene abilitato di nuovo e il Task3 è disabilitato.
• Quando non viene chiamata alcuna richiamata o il dispositivo è inattivo, passa a Light Sleep risparmiando così energia.

void taskI2CCallback();

void taskI2CDisable(); void taskAPCallback(); void taskAPDisable(); void taskWiFiCallback(); void taskWiFiDisable(); //Attività per i2c, hosting del server web e post su thingspeak Attività tI2C(1 * TASK_SECOND, TASK_FOREVER, &taskI2CCallback, &ts, false, NULL, &taskI2CDisable); Task tI2C(1 * TASK_SECOND, TASK_FOREVER, &taskI2CCallback, &ts, false, NULL, &taskI2CDisable); Attività tAP(5*TASK_SECOND, TASK_FOREVER, &taskAPCallback, &ts, false, NULL, &taskAPDisable); Task tWiFi(5* TASK_SECOND, TASK_FOREVER, &taskWiFiCallback, &ts, false, NULL, &taskWiFiDisable); //timeout per le attività tI2C.setTimeout(10 * TASK_SECOND); tAP.setTimeout(50 * TASK_SECOND); tWiFi.setTimeout(50 * TASK_SECOND); //abilita il task I2C tI2C.enable();

Passaggio 4: codice per la lettura dei valori di temperatura e umidità

Usiamo la libreria Wire.h per leggere i valori di temperatura e umidità. Questa libreria facilita la comunicazione i2c tra il sensore e il dispositivo master. 0x44 è l'indirizzo I2C per SHT31.

SHT31 opera in una diversa modalità operativa. Puoi fare riferimento alla scheda tecnica per questo. Usiamo 0x2C e 0x06 rispettivamente come MSB e LSB per il funzionamento a colpo singolo.

//Richiamata attività I2C void taskI2CCallback(){ Serial.println("taskI2CStarted"); unsigned int root[6]; //inizia la trasmissione da 0x44; Wire.beginTransmission(Addr); //per una trasmissione one shot con elevata ripetibilità usiamo 0x2C(MSB) e 0x06(LSB) Wire.write(0x2C); Wire.write(0x06); //fine trasmissione Wire.endTransmission(); //richiede byte da 0x44 Wire.beginTransmission(Addr); Wire.endTransmission(); Wire.requestFrom(Addr, 6); if(Wire.available() == 6){ //data[0] and data[1] contiene 16 bit di temperatura. root[0] = Wire.read(); root[1] =Wire.read(); //data[2] contiene 8 bit di CRC root[2] = Wire.read(); //data[3] e data[4] contengono 16 bit di umidità root[3] = Wire.read(); root[4] = Wire.read(); //data[5] consiste di 8 bit CRC root[5] = Wire.read(); } int temp = (root[0] * 256) + root[1]; //sposta MSB di 8 bit aggiungi LSB float cTemp = -45.0 + (175.0 * temp / 65535.0); float fTemp = (cTemp * 1.8) + 32.0; //sposta l'MSB di 8 bit e aggiungi LSB ad esso devide per piena risoluzione e *100 per percentuale di umidità float = (100.0 * ((root[3] * 256,0) + root[4])) / 65535.0; tempC = cTemp; tempF = fTemp; umido = umidità; Serial.print("Temperatura in C:\t"); Serial.println(String(cTemp, 1)); Serial.print("Temperatura in F:\t"); Serial.println(String(fTemp, 1)); Serial.print("Umidità:\t "); Serial.println(Stringa(umidità, 1)); }

Passaggio 5: codice per l'hosting di un server Web

Abbiamo ospitato un server web dal nostro dispositivo su un IP statico.

La libreria ESP8266WebServer viene utilizzata per ospitare il server web

• Per prima cosa dobbiamo dichiarare l'indirizzo IP, il gateway e la subnet mask per creare il nostro IP statico
• Ora dichiara ssid e password per il tuo punto di accesso. Connettiti al punto di accesso da qualsiasi dispositivo STA
• ospitare il server sulla porta 80 che è una porta predefinita per il protocollo di comunicazione Internet, Hypertext Transfer Protocol (HTTP) immettere 192.168.1.4 sul browser Web per la pagina Web di introduzione e 192.168.1.4/Value per la pagina Web di lettura del sensore

//IP statico per APIPAddress ap_local_IP(192, 168, 1, 4);IPAddress ap_gateway(192, 168, 1, 254); IPAddress ap_subnet(255, 255, 255, 0); //ssid e AP per WiFi locale in modalità STA const char WiFissid = "**********"; const char WiFipass = "**********"; //ssid e passa per 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 avviato"); server.handleClient(); } void onHandleDataRoot(){ server.send(200, "text/html", PAGE1); } void onHandleDataFeed(){ server.send(200, "text/html", PAGE2); } void onHandleNotFound(){ String message = "File Not Found\n\n"; messaggio += "URI: "; messaggio += server.uri(); messaggio += "\nMetodo: "; messaggio += (server.method() == HTTP_GET)?"GET":"POST"; messaggio += "\nArgomenti: "; messaggio += server.args(); messaggio += "\n"; server.send(404, "testo/normale", messaggio); } void reconnectAPWiFi(){ WiFi.mode(WIFI_AP_STA); ritardo(100); WiFi.disconnect(); stato booleano = WiFi.softAPConfig(ap_local_IP, ap_gateway, ap_subnet); if(status ==true){ Serial.print("Impostazione soft-AP … "); booleano ap = WiFi.softAP(APssid, APpass); if(ap==true){ Serial.print("connesso a:\t"); //IPAddress mioIP = WiFi.softAPIP(); Serial.println(WiFi.softAPIP()); } server.begin();

}

Passaggio 6: configurazione di Thingspeak

ThingSpeak è una piattaforma IoT. ThingSpeak è un servizio web gratuito che consente di raccogliere e archiviare i dati dei sensori nel cloud.

In questo passaggio, ti fornirò una breve procedura per configurare il tuo account Thing Speak

• Registrati per un nuovo account utente in ThingSpeak
• Crea un nuovo canale selezionando Canali, I miei canali e poi Nuovo canale
• Modifica i tuoi campi
• Questi campi contengono i dati del sensore
• Nota la chiave API di scrittura e l'ID canale
• Sul tuo schizzo Arduino, puoi utilizzare la libreria ThingSpeak per Arduino o puoi POST direttamente i dati all'API ThingSpeak
• il passaggio successivo approfondisce la pubblicazione del contenuto su Thing Speak API

Passaggio 7: codice per la pubblicazione di dati su Thing Speak

Qui pubblichiamo le letture del sensore su Thing Speak. i seguenti passaggi sono necessari per completare questa attività-

• Crea il tuo account in what speakCrea canali e campi per memorizzare i dati dei tuoi sensori
• possiamo ottenere e inviare i dati da ESP a thingSpeak e viceversa utilizzando le richieste GET e POST all'API.
• possiamo pubblicare i nostri dati su ThingSpeak come segue

id taskWiFiCallback(){ WiFiClient wifiClient; if(wifiClient.connect(hostId, 80)){ String postStr = apiKey; postStr +="&field1="; postStr += String(umido); postStr +="&field2="; postStr += String(tempC); postStr +="&field3="; postStr += String(tempF); postStr += "\r\n\r\n"; wifiClient.print("POST /update HTTP/1.1\n"); wifiClient.print("Host: api.thingspeak.com\n"); wifiClient.print("Connessione: chiudi\n"); wifiClient.print("X-THINGSPEAKAPIKEY: "+apiKey+"\n"); wifiClient.print("Content-Type: application/x-www-form-urlencoded\n"); wifiClient.print("Lunghezza contenuto: "); wifiClient.print(postStr.length()); wifiClient.print("\n\n"); wifiClient.print(postStr); } wifiClient.stop(); }

Passaggio 8: codice generale

Il codice complessivo è disponibile nel mio repository GitHub

Passaggio 9: crediti

• Arduino JSON
• ESP826WebServer
• Agenda
• SHT 31
• Scansione I2C
• Tutorial di istruzioni HIH6130
• Filo
• NCD.io