Stazione meteo IoT con RPi ed ESP8266: 10 passaggi

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

Nei tutorial precedenti, abbiamo giocato con NodeMCU, sensori e abbiamo appreso come acquisire e registrare dati su ThingSpeak (una piattaforma Internet of Things (IoT) che consente di raccogliere e archiviare i dati dei sensori nel cloud e sviluppare applicazioni IoT):

IOT RESO SEMPLICE: ACQUISIZIONE DEI DATI METEO DA REMOTO: UV E TEMPERATURA E UMIDITÀ DELL'ARIA

Con questo nuovo tutorial, impareremo come fare lo stesso, ma in questo momento, utilizzando un Raspberry Pi per acquisire dati da diversi sensori ed esplorando anche diversi modi di comunicare tra i dispositivi e il web:

Sensori e tipo di comunicazione:

• DHT22 (Temperatura e Umidità) ==> Comunicazione digitale
• BMP180 (Temperatura e Pressione) ==> Protocollo I2C
• DS18B20 (Temperatura) ==> Protocollo 1-Wire

Il diagramma a blocchi mostra cosa otterremo alla fine con questo progetto:

Fase 1: Distinta materiali - Distinta base

1. Raspberry Pi V3 - US$ 32,00
2. Sensore di temperatura e umidità relativa DHT22 - USD 9.95
3. Resistenza 4K7 ohm
4. Sensore di temperatura impermeabile DS18B20 - 5,95 USD
5. Resistenza 4K7 ohm
6. Sensore di pressione barometrica, temperatura e altitudine BMP180 - USD 6.99

Passaggio 2: installazione del sensore di temperatura e umidità

Il primo sensore da installare sarà il DHT22 per l'acquisizione dei dati di temperatura dell'aria e umidità relativa. Il sito ADAFRUIT fornisce ottime informazioni su questi sensori. Di seguito, alcune informazioni recuperate da lì:

Panoramica

I sensori di temperatura e umidità DHT a basso costo sono molto semplici e lenti, ma sono ottimi per gli hobbisti che vogliono eseguire alcune registrazioni di dati di base. I sensori DHT sono costituiti da due parti, un sensore di umidità capacitivo e un termistore. C'è anche un chip molto semplice all'interno che esegue una conversione da analogico a digitale e sputa un segnale digitale con la temperatura e l'umidità. Il segnale digitale è abbastanza facile da leggere utilizzando qualsiasi microcontrollore.

DHT22 Caratteristiche principali:

• Basso costo
• Alimentazione da 3 a 5 V e I/O
• Utilizzo corrente max 2,5 mA durante la conversione (durante la richiesta dei dati)
• Buono per letture di umidità 0-100% con una precisione del 2-5%
• Buono per letture di temperatura da -40 a 125 ° C ± 0,5 ° C di precisione
• Frequenza di campionamento non superiore a 0,5 Hz (una volta ogni 2 secondi)
• Dimensioni corpo 15,1 mm x 25 mm x 7,7 mm
• 4 pin con spaziatura di 0,1"

Una volta che di solito si utilizzerà il sensore su distanze inferiori a 20 m, è necessario collegare un resistore da 4K7 ohm tra i pin Data e VCC. Il pin dei dati di uscita DHT22 sarà collegato al Raspberry GPIO 16. Controllare lo schema elettrico sopra, collegando il sensore ai pin RPi come di seguito:

1. Pin 1 - Vcc ==> 3.3V
2. Pin 2 - Dati ==> GPIO 16
3. Pin 3 - Non connesso
4. Pin 4 - Gnd ==> Gnd

Non dimenticare di installare il resistore 4K7 ohm tra Vcc e pin dati

Una volta connesso il sensore, dobbiamo installare anche la sua libreria sul nostro RPi.

Installazione della libreria DHT:

Sul tuo Raspberry, partendo da /home, vai su /Documents

cd Documenti

Crea una directory per installare la libreria e spostati lì:

mkdir DHT22_Sensor

cd DHT22_Sensore

Sul tuo browser, vai su Adafruit GitHub:

github.com/adafruit/Adafruit_Python_DHT

Scarica la libreria facendo clic sul collegamento zip di download a destra e decomprimi l'archivio nella cartella Raspberry Pi creata di recente. Quindi vai nella directory della libreria (sottocartella che viene creata automaticamente quando hai decompresso il file) ed esegui il comando:

sudo python3 setup.py install

Apri un programma di test (DHT22_test.py) dal mio GITHUB

import Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 umidità, temperatura = Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) se l'umidità non è Nessuno e la temperatura non è Nessuno: print('Temp={0:0.1f}*C Humidity={1:0.1 f}%'.format(temperatura, umidità)) else: print('Impossibile leggere. Riprova!')

Eseguire il programma con il comando:

python3 DHT22_test.py

La schermata di stampa del terminale sottostante mostra il risultato.

Passaggio 3: installazione di DS18B20 - Sensore di temperatura

Panoramica del sensore:

Useremo in questo tutorial una versione impermeabilizzata del sensore DS18B20. È molto utile per la temperatura remota in condizioni umide, ad esempio su un terreno umido. Il sensore è isolato e può effettuare misurazioni fino a 125oC (Adafrut sconsiglia di utilizzarlo oltre i 100oC a causa della guaina in PVC del cavo).

Il DS18B20 è un sensore digitale che lo rende buono da usare anche su lunghe distanze! Questi sensori di temperatura digitali a 1 filo sono abbastanza precisi (±0,5°C su gran parte dell'intervallo) e possono fornire fino a 12 bit di precisione dal convertitore digitale-analogico integrato. Funzionano alla grande con NodeMCU utilizzando un singolo pin digitale e puoi persino collegarne più di uno allo stesso pin, ognuno ha un ID univoco a 64 bit stampato in fabbrica per differenziarli.

Il sensore funziona da 3.0 a 5.0V, il che significa che può essere alimentato direttamente dai 3.3V forniti da uno dei pin Raspberry (1 o 17).

Il sensore ha 3 fili:

• Nero: GND
• Rosso: VCC
• Giallo: dati a 1 filo

Qui puoi trovare i dati completi: Scheda tecnica DS18B20

Installazione del sensore:

Seguire lo schema sopra ed effettuare i collegamenti:

• Vcc ==> 3.3V
• Gnd ==> Gnd
• Dati ==> GPIO 4 (predefinito per la libreria)

Installazione della libreria Python:

Successivamente, installiamo la libreria Python che gestirà il sensore:

sudo pip3 install w1thermsensor

Prima di eseguire lo script per testare il sensore, controlla se l'interfaccia "1-Wire" è abilitata nel tuo RPi (vedi schermata di stampa sopra)

Non dimenticare di riavviare il tuo RPi, dopo averne modificato la configurazione

Test del sensore:

Per testare il sensore è possibile utilizzare un semplice script Python:

tempo di importazione

from w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor() while True: temperature = ds18b20Sensor.get_temperature() print("La temperatura è %s celsius" %temperatura) time.sleep(1)

Passaggio 4: installazione del BMP180

Panoramica del sensore:

Il BMP180 è il successore del BMP085, una nuova generazione di sensori di pressione digitali ad alta precisione per applicazioni consumer. L'elettronica a bassissima potenza e bassa tensione del BMP180 è ottimizzata per l'uso in telefoni cellulari, PDA, dispositivi di navigazione GPS e apparecchiature per esterni. Con un rumore a bassa quota di soli 0,25 m in tempi di conversione rapidi, il BMP180 offre prestazioni superiori. L'interfaccia I2C consente una facile integrazione del sistema con un microcontrollore. Il BMP180 si basa sulla tecnologia piezo-resistiva per la robustezza EMC, l'elevata precisione e linearità, nonché la stabilità a lungo termine.

La scheda tecnica completa BMP può essere trovata qui: BMP180 - Sensore di pressione digitale

Installazione del sensore: seguire lo schema sopra ed effettuare i collegamenti:

• Vin ==> 3.3V
• GND ==> GND
• SCL ==> GPIO 3
• SDA ==> GPIO 2

Abilitazione dell'interfaccia I2C

Vai a Configurazione RPi e conferma che l'interfaccia I2C è abilitata. In caso contrario, abilitalo e riavvia RPi.

Utilizzo del BMP180

Se tutto è stato installato correttamente e tutto è stato collegato correttamente, ora sei pronto per accendere il tuo Pi e iniziare a vedere cosa ti sta dicendo il BMP180 sul mondo che ti circonda.

La prima cosa da fare è controllare se il Pi vede il tuo BMP180. Prova quanto segue in una finestra di terminale:

sudo i2cdetect -y 1

Se il comando ha funzionato, dovresti vedere qualcosa di simile nella schermata di stampa del terminale sopra, che mostra che il BMP180 è sul canale '77'.

Installazione della libreria BMP180:

Crea una directory per installare la libreria:

mkdir BMP180_Sensorcd BMP180_Sensor

Sul tuo browser, vai su Adafruit GITHub:

github.com/adafruit/Adafruit_Python_BMP

Scarica la libreria facendo clic sul collegamento zip di download a destra e decomprimi l'archivio nella cartella creata da Raspberry Pi. Quindi vai nella sottocartella creata ed esegui il seguente comando nella directory della libreria:

sudo python3 setup.py install

Apri il tuo IDE Python e crea un programma di test e chiamalo, ad esempio BMP180Test.py

import Adafruit_BMP. BMP085 as BMP085sensor = BMP085. BMP085() print('Temp = {0:0.2f} *C'.format(sensor.read_temperature())) print('Pressure = {0:0.2f} Pa'. format(sensor.read_pressure())) print('Altitude = {0:0.2f} m'.format(sensor.read_altitude())) print('Sealevel Pressure = {0:0.2f} Pa'.format(sensor.read_sealevel_pression()))

Eseguire il programma di prova:

python3 BMP180Test.py

La schermata di stampa del terminale sopra mostra il risultato.

Notare che quella pressione è presentata in Pa (Pascal). Vedi il prossimo passo per capire meglio su questa unità.

Passaggio 5: misurazione del tempo e dell'altitudine con BMP180

Prendiamoci un po' di tempo per capire un po' di più su cosa otterremo, con le letture BMP. Puoi saltare questa parte del tutorial o tornare più tardi.

Se vuoi saperne di più sulle letture del sensore, vai a questo fantastico tutorial:

Il BMP180 è stato progettato per misurare con precisione la pressione atmosferica. La pressione atmosferica varia sia con il tempo che con l'altitudine.

Cos'è la pressione atmosferica?

La definizione di pressione atmosferica è una forza che l'aria intorno a te sta esercitando su tutto. Il peso dei gas nell'atmosfera crea la pressione atmosferica. Un'unità comune di pressione è "libbre per pollice quadrato" o psi. Useremo qui la notazione internazionale, cioè newton per metro quadrato, che sono chiamati pascal (Pa).

Se prendessi una colonna d'aria larga 1 cm peserebbe circa 1 kg

Questo peso, premendo sull'impronta di quella colonna, crea la pressione atmosferica che possiamo misurare con sensori come il BMP180. Poiché quella colonna d'aria larga cm pesa circa 1Kg, ne consegue che la pressione media al livello del mare è di circa 101325 pascal, o meglio, 1013,25 hPa (1 hPa è anche conosciuto come milibar - mbar). Questo diminuirà di circa il 4% per ogni 300 metri di salita. Più in alto ottieni, meno pressione vedrai, perché la colonna alla sommità dell'atmosfera è molto più corta e quindi pesa di meno. Questo è utile da sapere, perché misurando la pressione e facendo un po' di matematica, puoi determinare la tua altitudine.

La pressione dell'aria a 3.810 metri è solo la metà di quella al livello del mare.

Il BMP180 emette la pressione assoluta in pascal (Pa). Un pascal è una quantità molto piccola di pressione, approssimativamente la quantità che eserciterà un foglio di carta appoggiato su un tavolo. Vedrai più spesso misurazioni in ettopascal (1 hPa = 100 Pa). La libreria utilizzata qui fornisce valori in virgola mobile in uscita in hPa, che è anche uguale a un millibar (mbar).

Ecco alcune conversioni ad altre unità di pressione:

• 1 hPa = 100 Pa = 1 mbar = 0,001 bar
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0,01450377 psi (libbre per pollice quadrato)
• 1 hPa = 0,02953337 inHg (pollici di mercurio)
• 1 hpa = 0,00098692 atm (atmosfere standard)

Effetti della temperatura

Poiché la temperatura influisce sulla densità di un gas e la densità influisce sulla massa di un gas e la massa influisce sulla pressione (wow), la pressione atmosferica cambierà drasticamente con la temperatura. I piloti lo conoscono come "altitudine di densità", che rende più facile il decollo in una giornata fredda che in una calda perché l'aria è più densa e ha un maggiore effetto aerodinamico. Per compensare la temperatura, il BMP180 include un sensore di temperatura piuttosto buono e un sensore di pressione.

Per eseguire una lettura della pressione, si esegue prima una lettura della temperatura, quindi la si combina con una lettura della pressione grezza per ottenere una misurazione della pressione compensata dalla temperatura finale. (La biblioteca rende tutto questo molto semplice.)

Misurazione della pressione assoluta

Se la tua applicazione richiede la misurazione della pressione assoluta, tutto ciò che devi fare è ottenere una lettura della temperatura, quindi eseguire una lettura della pressione (vedi lo schizzo di esempio per i dettagli). La lettura finale della pressione sarà in hPa = mbar. Se lo desideri, puoi convertirlo in un'unità diversa utilizzando i fattori di conversione sopra.

Nota che la pressione assoluta dell'atmosfera varierà sia con la tua altitudine che con le condizioni meteorologiche attuali, entrambe cose utili da misurare.

Osservazioni meteorologiche

La pressione atmosferica in qualsiasi luogo sulla terra (o ovunque con un'atmosfera) non è costante. La complessa interazione tra la rotazione terrestre, l'inclinazione dell'asse e molti altri fattori determina lo spostamento di aree di pressione più alta e più bassa, che a loro volta causano le variazioni meteorologiche che vediamo ogni giorno. Osservando i cambiamenti di pressione, puoi prevedere i cambiamenti a breve termine del tempo. Ad esempio, un calo della pressione di solito significa che il tempo piovoso o una tempesta si sta avvicinando (un sistema a bassa pressione si sta muovendo). L'aumento della pressione di solito significa che il tempo sereno si sta avvicinando (un sistema ad alta pressione sta attraversando). Ma ricorda che la pressione atmosferica varia anche con l'altitudine. La pressione assoluta a casa mia, Lo Barnechea in Cile (altitudine 950 m) sarà sempre inferiore alla pressione assoluta a San Francisco per esempio (meno di 2 metri, quasi sul livello del mare). Se le stazioni meteorologiche riportassero semplicemente la loro pressione assoluta, sarebbe difficile confrontare direttamente le misurazioni della pressione da un luogo all'altro (e le previsioni meteorologiche su larga scala dipendono dalle misurazioni del maggior numero possibile di stazioni).

Per risolvere questo problema, le stazioni meteorologiche rimuovono sempre gli effetti dell'altitudine dalle loro letture di pressione riportate aggiungendo matematicamente la pressione fissa equivalente per far sembrare che la lettura sia stata effettuata a livello del mare. Quando lo fai, una lettura più alta a San Francisco rispetto a Lo Barnechea sarà sempre dovuta ai modelli meteorologici e non all'altitudine.

Per fare ciò, c'è una funzione nella libreria chiamata livello del mare(P, A). Questo prende la pressione assoluta (P) in hPa e l'altitudine attuale della stazione (A) in metri e rimuove gli effetti dell'altitudine dalla pressione. Puoi utilizzare l'output di questa funzione per confrontare direttamente le tue letture meteorologiche con altre stazioni in tutto il mondo.

Determinazione dell'altitudine

Poiché la pressione varia con l'altitudine, è possibile utilizzare un sensore di pressione per misurare l'altitudine (con alcune avvertenze). La pressione media dell'atmosfera a livello del mare è 1013,25 hPa (o mbar). Questo scende a zero mentre ti arrampichi verso il vuoto dello spazio. Poiché la curva di questo calo è ben compresa, è possibile calcolare la differenza di altitudine tra due misurazioni di pressione (p e p0) utilizzando un'equazione specifica.

Se si utilizza la pressione al livello del mare (1013,25 hPa) come pressione di base (p0), l'output dell'equazione sarà l'altitudine attuale sul livello del mare. C'è una funzione nella libreria chiamata altitudine (P, P0) che ti consente di ottenere l'"altitudine calcolata".

La spiegazione di cui sopra è stata estratta dal tutorial BMP 180 Sparkfun.

Passaggio 6: l'hardware completo

Passaggio 7: invio di dati a ThingSpeak

A questo punto abbiamo imparato a preparare l'RPi per acquisire i dati da tutti e 3 i sensori, stampandoli sul terminale. Ora è il momento di vedere come inviare quei dati alla nostra piattaforma IoT, ThingSpeak.

Cominciamo!

Innanzitutto, devi avere un account su ThinkSpeak.com

Segui le istruzioni per creare un canale e prendi nota del tuo ID canale e della chiave API di scrittura

Scarica lo script Python dal mio GitHub: localData ToTS_v1_EXT.py

Commentiamo le parti più importanti del codice:

Innanzitutto, importiamo la libreria ThingSpeak, definiamo il client WiFi e definiamo il router locale e le credenziali Thinkspeak:

import thingspeak

Esistono diversi modi per comunicare con ThingSpeak, il modo più semplice sarebbe utilizzare la libreria client per l'API di thingspeak.com sviluppata da Mikolaj Chwaliz e Keith Ellis.

La libreria può essere scaricata da https://github.com/mchwalisz/thingspeak o utilizzare PIP sul terminale:

sudo pip3 installa thingspeak

Successivamente, all'interno dello script, aggiorna le credenziali del canale ThingSpeak

chId = 9999999 # Inserisci con il tuo ID canale

tsKey='INSERIRE CON LA CHIAVE DI SCRITTURA DEL CANALE' tsUrl='https://api.thingspeak.com/update' ts = thingspeak. Channel(chId, tsUrl, tsKey)

Ora inizializziamo i 3 sensori:

# DS18B20 Libreria 1-Wire

from w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor() # Per impostazione predefinita GPIO 4 è utilizzato dalla libreria # DHT22 Library import Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 library import Adafruit_BMP. BMP085 as BMP085 BMP1805Sensor() Dovresti definire l'altitudine reale in cui si trova la tua stazione meteorologica, aggiornando la variabile globale "altReal". Nel mio caso, la mia stazione si trova a 950m sopra il livello del mare

altReal globale

altReale = 950

Una volta entrati con l'altitudine reale della stazione come input, possiamo ottenere la pressione assoluta, la pressione al livello del mare, la temperatura e l'altitudine utilizzando la funzione bmp180GetData(altitude):

def bmp180GetData(altitudine):

temp = bmp180Sensor.read_temperature() pres = bmp180Sensor.read_pressure() alt=bmp180Sensor.read_altitude() presSeaLevel = pres / pow(1.0 - altitudine/44330.0, 5.255) temp = round (temp, 1) pres = round (pres/100, 2) # pressione assoluta in hPa (o mbar) alt=round (alt) presSeaLevel = round (presSeaLevel/100, 2) # pressione assoluta in hPa (o mbar) temp di ritorno, pres, alt, presSeaLevel

La funzione getLocalData(), restituirà tutti i dati locali catturati dalla nostra stazione:

def getLocalData():

global timeString globale humLab globale tempExt globale tempLab globale presSL globale altLab globale presAbs # Ottieni ora di lettura ora = datetime.datetime.now() timeString = now.strftime("%Y-%m-%d %H:%M") # Leggi temperatura esterna (distanza 1 metro) tempExt = round(ds18b20Sensor.get_temperature(), 1) tempLab, presAbs, altLab, presSL = bmp180GetData(altReal) humDHT, tempDHT = Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) se humDHT non è Nessuno e tempDHT non è Nessuno: humLab = round (humDHT

Una volta acquisiti tutti i dati dalle funzioni di cui sopra, è necessario inviarli a ThingSpeak. Lo farai usando la funzione sendDataTs():

def sendDataTs():

data = { "field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab } ts.update(data) print ("[INFO] Dati inviati per 5 campi: ", tempLab, tempExt, humLab, pressSL, altLab)

Con i dati del tuo canale aggiornati, salva lo script ed eseguilo sul tuo terminale:

sudo Python3 localData_ToTs_v1_EXT.py

Informazioni sui protocolli di comunicazione

Si noti che utilizzando la "libreria thingsspeak", viene importata la "libreria richieste", ovvero una libreria HTTP con licenza Apache2, scritta in Python. La documentazione ufficiale della richiesta di installazione può essere trovata qui:

docs.python-requests.org/en/latest/user/install/

Se necessario, prima di eseguire lo script, puoi verificare se la libreria delle richieste è installata:

sudo pip3 richieste di installazione

Facoltativamente, puoi utilizzare MTTQ come metodo per inviare dati a ThingSpeak. MQTT è diverso da HTTP, una volta che è specificamente progettato per essere leggero e destinato a dispositivi embedded con poca RAM e prestazioni della CPU. Inoltre, nella maggior parte dei casi, MQTT utilizza meno larghezza di banda.

Fare riferimento a questo tutorial: Aggiorna un canale ThingSpeak utilizzando MQTT su un Raspberry Pi per maggiori dettagli.

Passaggio 8: invio di dati remoti a ThingSpeak utilizzando ESP8266

Per questo passaggio, utilizzeremo lo stesso HW spiegato in molti tutorial:

IOT RESO SEMPLICE: ACQUISIZIONE DEI DATI METEO DA REMOTO: UV E TEMPERATURA E UMIDITÀ DELL'ARIA

Il codice che useremo qui è fondamentalmente lo stesso usato in quel tutorial. Commentiamo le parti più importanti del codice:

Innanzitutto, chiamiamo la libreria ESP8266, definiamo il client WiFi e definiamo il router locale e le credenziali Thinkspeak:

/* NodeMCU ESP12-E */

#include client WiFiClient; const char* MY_SSID = "INSERIRE CON IL TUO SSDID"; const char* MY_PWD = "ENTRA CON LA TUA PASSWORD"; /* Thinkspeak */ const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY ="INVIO CON LA TUA CHIAVE DI SCRITTURA";

In secondo luogo, includiamo una libreria molto importante per i progetti IoT: SimpleTimer.h:

/* TIMER */

#include timer SimpleTimer;

Terzo, durante setup(), avvieremo la comunicazione seriale, chiameremo la funzione connectWiFi() e definiremo i timer. Nota che la riga di codice: timer.setInterval(60000L, sendDataTS); chiamerà la funzione sendDataTS() ogni 60 secondi, per caricare i dati sul canale ThinkSpeak.

configurazione nulla()

{ … Serial.begin(115200); ritardo(10); …connettiWifi(); timer.setInterval(60000L, sendDataTS); … }

Infine, ma non meno importante, durante il loop(), l'unico comando necessario è avviare il timer e il gioco è fatto!

ciclo vuoto()

{ … timer.run(); // Avvia SimpleTimer }

Di seguito, puoi vedere le due importanti funzioni utilizzate per gestire la comunicazione Thinkspeak:

Connessione ESP12-E con la tua rete WiFi:

/***************************************************

* Connessione Wi-Fi ********************************************* ***/ void connectWifi() { Serial.print("Connessione a "+ *MY_SSID); WiFi.begin(MY_SSID, MY_PWD); while (WiFi.status() != WL_CONNECTED) { ritardo(1000); Serial.print("."); } Serial.println(""); Serial.println("WiFi connesso"); Serial.println(""); }

ESP12-E invia dati a ThinkSpeak:

***************************************************

* Invio di dati al canale Thinkspeak ******************************************* ******/ void sendDataTS(void) { if (client.connect(TS_SERVER, 80)) { String postStr = TS_API_KEY; postStr += "&field6="; postStr += String(temp); postStr += "&field7="; postStr += String(ronzio); postStr += "&field8="; postStr += String(dataSensorUV); postStr += "\r\n\r\n"; client.print("POST /update HTTP/1.1\n"); client.print("Host: api.thingspeak.com\n"); client.print("Connessione: chiudi\n"); client.print("X-THINGSPEAKAPIKEY: " + TS_API_KEY + "\n"); client.print("Content-Type: application/x-www-form-urlencoded\n"); client.print("Lunghezza contenuto: "); client.print(postStr.length()); client.print("\n\n"); client.print(postStr); ritardo(1000); } inviato++; cliente.stop(); }

Il codice completo può essere trovato sul mio GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Una volta caricato il codice sul tuo NodeMCU. Colleghiamo una batteria esterna e facciamo qualche misurazione sotto il sole. Metto la Remote Station sul tetto e inizio a catturare i dati su ThingSpeak.com come mostrato nelle foto sopra.

Passaggio 9: note finali

Lo scopo principale di questo tutorial era mostrare come collegare il Raspberry Pi a ThingSpeak. Questo è ottimo per acquisire dati e registrarli su una piattaforma IoT.

Sfruttando l'opportunità abbiamo anche inviato i dati a quel canale specifico, catturandoli da una stazione remota utilizzando un ESP8266. Questo approccio è OK, ma non è il migliore. Poiché abbiamo un'operazione "asincrona", a volte, entrambi, RPi ed ESP8266 cercano di registrare contemporaneamente (o con un piccolo intervallo) ciò che viene confutato da ThingSpeak. L'ideale sarebbe che ESP8266 invii dati localmente a Raspberry Pi e l'ultimo sia responsabile della gestione di tutti i dati. In questo modo, la "Stazione principale" (Raspberry Pi), potrebbe fare 3 cose:

• Registra tutti i dati su un database locale
• Presentare tutti i dati su una pagina Web locale (usando Flask come mostrato nella foto sopra)
• Invio di tutti i dati a ThingSpeak contemporaneamente.

In un futuro tutorial, esploreremo queste opzioni.

Passaggio 10: conclusione

Come sempre, spero che questo progetto possa aiutare gli altri a trovare la loro strada nell'eccitante mondo dell'elettronica!

Per i dettagli e il codice finale, visita il mio deposito GitHub: RPi-NodeMCU-Weather-Station

Per altri progetti, visita il mio blog: MJRoBot.org

Rimani sintonizzato! Il prossimo tutorial invieremo i dati da una stazione meteorologica remota a una centrale, basata su un server Web Raspberry Pi:

Saludos dal sud del mondo!

Ci vediamo nel mio prossimo istruibile!

Grazie, Marcelo