Bollettino meteorologico utilizzando le applet ThingSpeak MQTT e IFTTT: 8 passaggi

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

introduzione

Un'applicazione meteo basata su cloud che fornisce bollettini meteorologici giornalieri come notifica e-mail. Questa applicazione web misura la temperatura e l'umidità utilizzando SHT25 e Adafruit Huzzah ESP8266. Ci fornisce dati di temperatura e umidità in tempo reale e analisi orarie. I dati vengono inviati utilizzando l'API ThingSpeak MQTT e in seguito forniamo una notifica e-mail all'utente ogni volta che la temperatura raggiunge la soglia assegnata utilizzando il protocollo IFTTT. SHT25 è un sensore di temperatura e umidità prodotto da Sensirion. L'SHT25 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.

Caratteristiche

• Fornisce analisi e statistiche in tempo reale utilizzando l'API MQTT di Thing Speak
• Una notifica e-mail viene fornita all'utente in un momento assegnato utilizzando IFTTT
• L'Utilità di pianificazione viene utilizzato per pianificare l'attività come il recupero dei dati dai sensori, la pubblicazione delle letture dei sensori, la sottoscrizione all'argomento MQTT
• Utilizza il protocollo I2C per recuperare la lettura del sensore che è più accurata, espandibile e scalabile
• modalità di sospensione quando il dispositivo è inattivo o non viene richiamata alcuna attività.
• un'efficace pianificazione delle attività garantisce un utilizzo senza problemi
• È ospitata una pagina Web separata in cui l'utente deve fornire le proprie credenziali utente per evitare di eseguire il flashing del dispositivo ogni volta che è raggiungibile da altre reti Wi-Fi

• SPIFFS viene utilizzato per memorizzare la nostra pagina Web per rendere il nostro codice leggibile e meno goffo

Passaggio 1: specifiche hardware e software

Specifiche hardware

• Adafruit esp8266 Tavola Huzzah
• Scudo da tavolo Huzzah
• SHT25 Modulo sensore
• Cavo I2C

Specifiche del software

• Arduino IDE
• IFTTT cosa parla
• API MQTT

Passaggio 2: memorizzazione delle credenziali dell'utente

Qui stiamo usando il sensore SHT25 I2C per leggere il valore in tempo reale di temperatura e umidità relativa e pubblicare questi valori nel cloud. Per ottenere di volta in volta il valore del sensore aggiornato e per pubblicare questi aggiornamenti contemporaneamente, stiamo utilizzando la libreria dell'utilità di pianificazione di Arduino. Per le operazioni cloud, utilizziamo l'API MQTT di ThingSpeak. Successivamente forniremo all'utente un bollettino meteorologico in tempo reale utilizzando le applet IFTTT. Puoi seguire questi passaggi per creare la tua stazione meteorologica. Quindi, fai da te.

Prima di procedere oltre. Dobbiamo salvare le credenziali dell'utente. A questo scopo, stiamo ospitando un server web a 192.169.1.4. Abbiamo memorizzato il nostro modulo web in SPIFFS. Una volta avviato, il dispositivo ospita un server Web per 60 secondi. L'utente deve seguire questi passaggi.

• Connettiti all'AP ESPuser, questo è elencato nell'elenco delle reti wifi disponibili. Connettiti a questo AP e inserisci la password "********"
• Una volta connesso, vai al tuo browser e inserisci l'IP 192.168.1.4.
• Inserisci l'SSID e la password del tuo WiFi locale nei campi di input e inserisci SUBMIT
• Queste credenziali verranno salvate in EEPROM
• Dopo 60 secondi il dispositivo si disconnetterà automaticamente dall'AP
• La prossima volta che accendi il dispositivo, l'utente non deve seguire questa procedura, il dispositivo recupererà automaticamente le credenziali dell'utente dalla EEPROM e continuerà a ottenere le letture del sensore dall'interfaccia I2C e a pubblicarle sul cloud

//--------- AP config------------// IPAddress ap_local_IP(192, 168, 1, 4); IPAddress ap_gateway(192, 168, 1, 254); IPAddress ap_subnet(255, 255, 255, 0);

Serial.print("Configurazione punto di accesso…");

WiFi.softAPConfig(ap_local_IP, ap_gateway, ap_subnet);

Serial.print("Impostazione credenziali utente");

WiFi.softAP(ssidAP, passAP);

server.on("/", handleRoot);

server.onNotFound(onHandleNotFound);

server.begin();

APTimer = millis();

while(millis()-APTimer <APInterval){

server.handleClient();

}

//**************************** MANIGLIA RADICE****************** *********//void handleRoot() {

if (server.hasArg("ssid")&& server.hasArg("password"))

{

//Se tutti i campi del modulo contengono chiamate dati

handelSubmit()

handleSubmit(); }

altro {

//Rivisualizza il modulo

//legge il file contenuto in spiffs

File file =SPIFFS.open("/webform.html", "r");

server.streamFile(file, "testo/html");

//non dimenticare di chiudere il file

file.close();

}}

// Controlla lo stato che ha gli argomenti ssid e password

//Quindi scrivi le credenziali nella ROM

ROMwrite(String(server.arg("ssid")), String(server.arg("password")))

Passaggio 3: configurazione del modulo web in SPIFFS

SPIFFS

Serial Peripheral Interface Flash File System, o SPIFFS in breve. È un file system leggero per microcontrollori con un chip flash SPI. Il chip flash integrato dell'ESP8266 ha molto spazio per le tue pagine web, specialmente se hai la versione da 1 MB, 2 MB o 4 MB. Abbiamo anche memorizzato la nostra pagina web in Flash System. Ci sono alcuni passaggi che dobbiamo seguire per caricare i dati su spiffs

1. Scarica lo strumento:
2. Nella directory dello sketchbook di Arduino, crea la directory degli strumenti se non esiste ancora
3. Decomprimi lo strumento nella directory degli strumenti (il percorso sarà simile a /Arduino/tools/ESP8266FS/tool/esp8266fs.jar)
4. Riavvia Arduino IDE
5. Apri uno schizzo (o creane uno nuovo e salvalo)
6. Vai alla directory degli schizzi (scegli Schizzo > Mostra cartella degli schizzi)
7. Crea una directory denominata data e tutti i file che desideri nel file system lì. Abbiamo caricato la nostra pagina HTML con il nome webform.html
8. Assicurati di aver selezionato una scheda, una porta e un monitor seriale chiuso
9. Selezionare Strumenti > Caricamento dati schizzo ESP8266. Questo dovrebbe iniziare a caricare i file nel file system flash ESP8266. Al termine, la barra di stato dell'IDE visualizzerà il messaggio SPIFFS Image Uploaded.

File file =SPIFFS.open("/webform.html", "r");

server.streamFile(file, "testo/html");

//non dimenticare di chiudere il file

file.close();

Passaggio 4: pianificazione delle attività

In questo tutorial, stiamo eseguendo due operazioni:

• Leggere i dati da SHT25 utilizzando il protocollo I2C
• Pubblica i dati aggiornati sul cloud utilizzando l'API MQTT di ThingSpeak

Per raggiungere questo obiettivo stiamo utilizzando la libreria TaskScheduler. Abbiamo programmato due diverse attività riferite a due 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 il Task1 raggiunge il timeout Ci stiamo connettendo al Wifi locale e al broker MQTT.
• Ora l'attività 2 è abilitata e stiamo disabilitando l'attività 1 L'attività 2 serve per pubblicare i dati del sensore sul broker Thing Speak MQTT questa attività viene eseguita per 20 secondi fino a raggiungere il timeout di 20 secondi
• Quando il Task2 raggiunge il suo timeout, il Task 1 viene abilitato di nuovo e il Task2 è disabilitato. anche qui, stiamo ottenendo il valore aggiornato e il processo continua
• quando non viene richiamata alcuna richiamata o il dispositivo è inattivo, passa a Light Sleep risparmiando così energia.

//---------prototipo per richiamata attività------------//

void taskI2CCallback();

void taskI2CDisable();

void taskWiFiCallback();

void taskWiFiDisable();

//---------Compiti------------//

Task tI2C(2 * TASK_SECOND, TASK_FOREVER, &taskI2CCallback, &ts, false, NULL, &taskI2CDisable);

Task tWiFi(20* TASK_SECOND, TASK_FOREVER, &taskWiFiCallback, &ts, false, NULL, &taskWiFiDisable);

//abilita tI2C tI2C.enable();

Passaggio 5: lettura dei valori di temperatura e umidità da SHT25

I2C è un'interfaccia a due fili che utilizza solo due fili per comunicare con il dispositivo master. Uno è SCL (Serial Clock) e l'altro è SDA (Serial Data). Ogni dispositivo slave ha un indirizzo univoco. SHT 25 ha anche un indirizzo a 8 bit ed è accessibile da un indirizzo 0x44. ha 8 bit dell'indirizzo in cui 7 bit sono l'indirizzo effettivo e mentre il bit 0 LSB più a destra viene utilizzato per segnalare la lettura o la scrittura sul dispositivo. Se il bit 0 è impostato a 1, il dispositivo master leggerà dal dispositivo I2C slave. I2C è molto più affidabile, scalabile e veloce e ha anche molte modalità di funzionamento che lo rendono molto più efficiente dal punto di vista energetico

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

Passaggio 6: pubblicazione di valori su ThingSpeak utilizzando l'API MQTT di ThingSpeak

Per pubblicare i nostri valori di temperatura e umidità sul cloud, utilizziamo l'API ThingSpeak MQTT. ThingSpeak è una piattaforma IoT. ThingSpeak è un servizio web gratuito che consente di raccogliere e archiviare i dati dei sensori nel cloud. MQTT è un protocollo comune utilizzato nei sistemi IoT per connettere dispositivi e sensori di basso livello. MQTT viene utilizzato per passare brevi messaggi da e verso un broker. ThingSpeak ha recentemente aggiunto un broker MQTT in modo che i dispositivi possano inviare messaggi a ThingSpeak. Puoi seguire la procedura per impostare ThingSpeak Channel da questo post

ThingSpeak MQTT

MQTT è un'architettura di pubblicazione/sottoscrizione sviluppata principalmente per connettere dispositivi con limitazioni di larghezza di banda e alimentazione su reti wireless. È un protocollo semplice e leggero che funziona su socket TCP/IP o WebSocket. MQTT su WebSocket può essere protetto con SSL. L'architettura di pubblicazione/sottoscrizione consente di inviare messaggi ai dispositivi client senza che il dispositivo debba interrogare continuamente il server. Un client è qualsiasi dispositivo che si connette al broker e può pubblicare o sottoscrivere argomenti per accedere alle informazioni. Un argomento contiene le informazioni di instradamento per il broker. Ogni cliente che vuole inviare messaggi li pubblica su un certo argomento e ogni cliente che vuole ricevere messaggi si iscrive a un certo argomento

Pubblica e iscriviti utilizzando ThingSpeak MQTT

• Pubblicazione sui canali di feed del canale /publish/
• Pubblicazione su un particolare campo canali /pubblica/campi/campo/
• Iscriviti al campo canale canali /subscribe//
• Iscriviti ai canali feed del canale privato //subscribe/fields/field/
• Iscriviti a tutti i campi di un canale. canali// iscriviti/campi/campo /

void taskWiFiCallback()

{

Serial.println("taskWiFiCallbackStarted");

Serial.print("timeout per questa attività: \t");

Serial.println(tWiFi.getTimeout());

if(!mqttCli.connected())

{

Serial.println("Cliente non connesso");

reconnectMQTT();

}

String topicString ="channels/"+String(channelID)+"/publish/"+String(writeAPIKey);

int topicLength = topicString.length()+1;

char topicBuffer[topicLength];

topicString.toCharArray(topicBuffer, topicLength+1);

Serial.println(topicBuffer);

String dataString = String("field1="+ String(tempC, 1) + "&field2=" + String(tempF, 1) + "&field3=" + String(umido, 1));

int dataLength = dataString.length()+1;

byte dataBuffer[dataLength];

dataString.getBytes(dataBuffer, dataLength);

mqttCli.beginPublish(topicBuffer, dataLength, false);

Serial.println(mqttCli.write(dataBuffer, dataLength) ? "pubblicato": "pubblicato non riuscito");

mqttCli.endPublish();

//mqttCli.loop();

}

Passaggio 7: notifica e-mail del bollettino meteorologico

Stiamo utilizzando applet IFTTT per fornire all'utente un bollettino meteorologico in tempo reale. Quindi, l'abbiamo implementato tramite ThingSpeak. Stiamo facendo la media dei valori a 5 fay di temperatura e umidità. Ogni volta che il valore dell'ultima voce è maggiore del valore medio. Si attiverà una notifica e-mail "è una giornata calda". e quando è inferiore al valore medio. Si attiverà una notifica via e-mail "Che bella giornata". Ogni giorno intorno alle 10:00 (IST) riceveremo una notifica via e-mail

IDcanale= ******;

iftttURL='https://maker.ifttt.com/***************';

umiditàData=thingSpeakRead(channelID, 'Fields', 3, 'NumDays', 5); tempData = thingSpeakRead(channelID, 'Fields', 1, 'NumDays', 5);

perHumid=max(moistureData)-min(moistureData);

valore umido=0.1*perUmidità+min(dati umidità);

perTemp=max(tempData)-min(tempData);

tempValue=0.1*perTemp+min(tempData);

urlTemp=strcat('https://api.thingspeak.com/channels/', string(channelID), '/fields/1/last.txt');

urlHumid = strcat('https://api.thingspeak.com/channels/', string(channelID), '/fields/3/last.txt'); lastTempValue=str2num(webread(urlTemp)); lastHumidValue = str2num(webread(urlHumid));

if (lastTempValue

if (lastTempValue>tempValue || lastHumidValue>humidValue)

plantMessage=' È una giornata calda.'; webwrite(iftttURL, 'value1', plantMessage, 'value2', lastTempValue, 'value3', lastHumidValue); fine

Passaggio 8: codice generale

Codice generale

Il codice complessivo è disponibile in questo repository GitHub

Limitazioni

• Ci sono alcuni problemi con la pubblicazione dei dati usando publish a method per la grande massa di dati.per risolvere questo problema stiamo usando la funzione write()
• SPIFFS deve essere formattato prima di caricare i nuovi dati su SPIFFS.
• Non devi usare la funzione delay(). delay() ostacola l'operazione in background. Invece, crea ritardi usando millis() solo se è necessario

Titoli di coda

• ESP826WebServer
• Agenda
• SHT 25
• API MQTT di ThingSpeak
• IFTTT
• PubSubClient