App meteo web utilizzando Esp8266: 7 passaggi

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

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

2. Adafruit Huzzah ESP8266

3. Adattatore ESP8266 I2C

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 gli 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 suo timeout, Task 2 è abilitato e Task1 è disabilitato.
• 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 questa richiamata
• Nell'attività 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.

Programmatore ts;

//Compiti per i2c, hosting di server web e post su thingspeak

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.
• connettersi all'Access Point 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 AP

IPAddress 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);

configurazione nulla{

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, "testo/html", PAGINA2); }

void onHandleNotFound(){

String message = "File non trovato\n\n";

messaggio += "URI: ";

messaggio += server.uri();

messaggio += "\nMetodo: ";

messaggio += (server.method() ==

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(stato ==vero){

Serial.print("Impostazione soft-AP … ");

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

if(ap==vero){

Serial.print("connesso a:\t");

//IPAddress mioIP = WiFi.softAPIP();

Serial.println(WiFi.softAPIP());

}

server.begin();

}

}

Passaggio 6: 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 speak
• Crea canali e campi per memorizzare i dati del tuo sensore
• 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

void taskWiFiCallback(){

Wi-FiClient Wi-FiClient; 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 7: codice generale

Il codice generale è disponibile nel mio repository github

Titoli di coda:

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