IoT semplificato: acquisizione di dati meteorologici remoti: UV e temperatura e umidità dell'aria: 7 passaggi

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

In questo tutorial, cattureremo dati remoti come UV (radiazioni ultraviolette), temperatura e umidità dell'aria. Questi dati saranno molto importanti e verranno utilizzati in una futura stazione meteorologica completa.

Il diagramma a blocchi mostra cosa otterremo alla fine.

Passaggio 1: Distinta base - Distinta base

NodeMCU (ESP8266-12E) - 9,00 USD

Sensore di umidità e temperatura (DHT22) - USD 10.00

Sensore UV - USD 4.00

OLED 12,00 USD

Tagliere - USD1.00

Passaggio 2: il sensore UV analogico

Questo sensore UV genera un'uscita analogica proporzionale alla radiazione ultravioletta trovata nello spettro di rilevamento della luce. Utilizza un fotodiodo UV (basato sul nitruro di gallio), in grado di rilevare la gamma di luce 240-370 nm (che copre gli UVB e la maggior parte dello spettro UVA). Il livello del segnale dal fotodiodo è molto piccolo, nel livello del nano-ampere, quindi il modulo ha incorporato un amplificatore operazionale per amplificare il segnale a un livello di volt più leggibile (da 0 a 1V).

Il sensore e l'amplificatore operazionale possono essere alimentati, collegando VCC a 3,3 V CC (o 5 V CC) e GND a massa di alimentazione. Il segnale analogico può essere ottenuto dal pin OUT.

La sua uscita sarà in millivolt e verrà letta dall'ingresso analogico del nostro NodeMCU. Una volta letto, dovremmo "convertirlo" (o "mapparlo") affinché i valori siano gestiti meglio dal codice. Possiamo farlo con la funzione readSensorUV():

/* Legge il sensore UV in mV e chiama il calcolo dell'indice UV */

void readSensorUV() { byte numOfReadings = 5; dataSensorUV = 0; for (int i=0; i< numOfReadings; i++) { dataSensorUV += analogRead(sensorUVPin); ritardo (200); } dataSensorUV /= numOfReadings; dataSensorUV = (dataSensorUV * (3.3 / 1023.0))*1000; Serial.println(dataSensorUV); indexCalculate(); }

Una volta che abbiamo i dati UV, possiamo facilmente calcolare l'indice UV come definito nella tabella sopra. La funzione indexCalculate() lo farà per noi:

/* Calcolo dell'Indice UV */

void indexCalculate() { if (dataSensorUV < 227) indexUV = 0; else if (227 <= dataSensorUV && dataSensorUV < 318) indexUV = 1; else if (318 <= dataSensorUV && dataSensorUV < 408) indexUV = 2; else if (408 <= dataSensorUV && dataSensorUV < 503) indexUV = 3; else if (503 <= dataSensorUV && dataSensorUV < 606) indexUV = 4; else if (606 <= dataSensorUV && dataSensorUV < 696) indexUV = 5; else if (696 <= dataSensorUV && dataSensorUV < 795) indexUV = 6; else if (795 <= dataSensorUV && dataSensorUV < 881) indexUV = 7; else if (881 <= dataSensorUV && dataSensorUV < 976) indexUV = 8; else if (976 <= dataSensorUV && dataSensorUV < 1079) indexUV = 9; else if (1079 <= dataSensorUV && dataSensorUV < 1170) indexUV = 10; altrimenti indiceUV = 11; }

Passaggio 3: installazione di un display: OLED

A scopo di test, includeremo un OLED sul nostro misuratore UV (questo passaggio è completamente facoltativo).

Durante i test va bene utilizzare il monitor seriale, ma cosa succede quando si utilizzano i prototipi lontano dal PC in modalità stand-alone? Per questo, installiamo un display OLED, l'SSD1306, le cui caratteristiche principali sono:

• Dimensioni dello schermo: 0,96"
• Seriale I2C IIC SPI
• 128X64
• LED LCD OLED bianco

Segui lo schema elettrico e collega i 4 pin del nostro OLED:

• VCC va a 3.3V
• GND va a terra
• SCL va a NodeMCU (GPIO 2) ==>D4
• SDA va a NodeMCU (GPIO 0) ==>D3

Una volta collegato il display, scarichiamo e installiamo la sua libreria sul nostro IDE Arduino: il "Driver ESP8266 OLED per display SSD1306" sviluppato da Daniel Eichhorn (assicurati di utilizzare la versione 3.0.0 o superiore!).

Installa la libreria sul tuo IDE Arduino, che puoi trovare su SSD1306Wire.h

Una volta riavviato l'IDE, la libreria dovrebbe essere già installata.

La libreria supporta il protocollo I2C per accedere al display OLED utilizzando la libreria Wire.h integrata:

/* OLED */

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Display filo (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);

Elenchiamo alcune importanti API che verranno utilizzate con il nostro display OLED. L'elenco completo può essere trovato presso il GITHub fornito sopra.

A. Controllo del display:

void init(); // Inizializza il display

void displayOn(void); // Attiva il display void displayOff(void); // Spegne il display void clear(void); // Cancella il buffer dei pixel locali void flipScreenVerticalmente(); // Capovolge il display

B. Operazioni di testo:

void drawString(int16_t x, int16_t y, String text); // (xpos, ypos, "Testo")

void setFont(const char* fontData); // Imposta il carattere corrente.

Caratteri predefiniti disponibili:

• ArialMT_Plain_10,

• ArialMT_Plain_16,

• ArialMT_Plain_24

Una volta installati sia l'OLED stesso che la sua libreria, scriviamo un semplice programma per testarlo. Inserisci con il codice seguente sul tuo IDE, il risultato dovrebbe essere un display come mostrato nella foto sopra:

* OLED */

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Display filo (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); void setup() { Serial.begin(115200); displaySetup(); } void loop() { } /* Avvia e visualizza i dati di configurazione su OLED */ void displaySetup() { display.init(); // inizializza display display.clear(); // Cancella display display.flipScreenVerticalmente(); // Capovolge il display display.display(); // Mette i dati sul display Serial.println("Initiating Display Test"); display.setFont(ArialMT_Plain_24); display.drawString(30, 0, "OLED"); // (xpos, ypos, "Testo") display.setFont(ArialMT_Plain_16); display.drawString(18, 29, "Test avviato"); display.setFont(ArialMT_Plain_10); display.drawString(10, 52, "Serial BaudRate:"); display.drawString(90, 52, String(11500)); display.display(); // Mette i dati sul ritardo di visualizzazione (3000); }

Il programma sopra può essere scaricato dal mio GitHub:

NodeMCU_OLED_Test

Passaggio 4: un misuratore UV locale

Ora, con il display OLED installato, possiamo collegare una batteria e fare dei test a distanza utilizzando il nostro "UV Meter"

#define SW_VERSION "UV_Sensor_V.1"

/* Sensore UV */ #define sensorUVPin A0 int dataSensorUV = 0; int indiceUV = 0; /* OLED */ #include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Display filo (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); void setup() { Serial.begin(115200); displaySetup(); } void loop() { readSensorUV(); displayUV(); ritardo (1000); } /* Avvia e visualizza i dati di configurazione su OLED */ void displaySetup() { display.init(); // inizializza display display.clear(); // Cancella display display.flipScreenVerticalmente(); // Capovolge il display display.display(); // Mette i dati sul display Serial.println("Initiating UV Sensor Test"); display.setFont(ArialMT_Plain_24); display.drawString(10, 0, "MJRoBot"); display.setFont(ArialMT_Plain_16); display.drawString(0, 29, "Test sensore UV"); display.setFont(ArialMT_Plain_10); display.drawString(0, 52, "Ver. SW:"); display.drawString(45, 52, SW_VERSION); display.display(); ritardo (3000); } /* Legge il sensore UV in mV e chiama il calcolo dell'indice UV */ void readSensorUV() { byte numOfReadings = 5; dataSensorUV = 0; for (int i=0; i< numOfReadings; i++) { dataSensorUV += analogRead(sensorUVPin); ritardo (200); } dataSensorUV /= numOfReadings; dataSensorUV = (dataSensorUV * (3.3 / 1023.0))*1000; Serial.println(dataSensorUV); indexCalculate(); } /* Calcolo dell'indice UV */ void indexCalculate() { if (dataSensorUV < 227) indexUV = 0; else if (227 <= dataSensorUV && dataSensorUV < 318) indexUV = 1; else if (318 <= dataSensorUV && dataSensorUV < 408) indexUV = 2; else if (408 <= dataSensorUV && dataSensorUV < 503) indexUV = 3; else if (503 <= dataSensorUV && dataSensorUV < 606) indexUV = 4; else if (606 <= dataSensorUV && dataSensorUV < 696) indexUV = 5; else if (696 <= dataSensorUV && dataSensorUV < 795) indexUV = 6; else if (795 <= dataSensorUV && dataSensorUV < 881) indexUV = 7; else if (881 <= dataSensorUV && dataSensorUV < 976) indexUV = 8; else if (976 <= dataSensorUV && dataSensorUV < 1079) indexUV = 9; else if (1079 <= dataSensorUV && dataSensorUV < 1170) indexUV = 10; altrimenti indiceUV = 11; } /* Visualizza i valori UV sull'OLED locale*/ void displayUV() { display.clear(); display.setFont(ArialMT_Plain_16); display.drawString(20, 0, "Sensore UV"); display.drawString(0, 23, "UV (mV):"); display.drawString(80, 23, String(dataSensorUV)); display.drawString(0, 48, "Indice UV:"); display.setFont(ArialMT_Plain_24); display.drawString(82, 42, String(indexUV)); display.display(); }

Il codice sopra può essere scaricato dal mio GitHun: NodeMCU_UV_Sensor_OLED.ino

Passaggio 5: installazione di un DHT22 per misurazioni della temperatura e dell'umidità dell'aria

Uno dei sensori più utilizzati per l'acquisizione dei dati meteorologici è il DHT22 (o il fratello DHT11), un sensore digitale di umidità relativa e temperatura. Utilizza un sensore di umidità capacitivo e un termistore per misurare l'aria circostante e sputa un segnale digitale sul pin dati (non sono necessari pin di ingresso analogico).

Il sensore deve essere alimentato tra 3,3 V e 5 V e funzionerà da -40 oC a +80 oC con una precisione di +/- 0,5 oC per la temperatura e +/- 2% per l'umidità relativa. È anche importante tenere presente che il suo periodo di rilevamento è in media di 2 secondi (tempo minimo tra le letture). Il sito di Adafruit fornisce molte informazioni su entrambi, DHT22 e suo fratello DHT11. Per maggiori dettagli, visitare la pagina Tutorial DHT22/11.

Il DHT22 ha 4 pin (di fronte al sensore, il pin 1 è il più a sinistra):

1. VCC (ci collegheremo a 3.3V da NodeMCU);
2. Dati in uscita;
3. Non connesso e
4. Terreno.

Una volta che di solito si utilizzerà il sensore su distanze inferiori a 20 m, è necessario collegare un resistore da 10K tra i pin Data e VCC. Il pin di uscita sarà collegato al pin D3 di NodeMCU (vedere lo schema sopra). Una volta installato il sensore sul nostro modulo, scarica la libreria DHT dal repository GitHub di Adafruit e installala nel file della libreria di Arduino. Una volta ricaricato l'IDE Arduino, dovrebbe essere installata la "libreria di sensori DHT".

All'inizio del codice, dobbiamo includere le righe:

/* DHT22*/

#include "DHT.h" #define DHTPIN D2 #define DHTTYPE DHT22 DHT dht(DHTPIN, DHTTYPE); ronzio galleggiante = 0; temperatura galleggiante = 0;

Verrà creata una nuova funzione per leggere il sensore:

/* Ottieni dati DHT */

void getDhtData(void) { float tempIni = temp; float humIni = ronzio; temp = dht.readTemperature(); ronzio = dht.readHumidity(); if (isnan(hum) || isnan(temp)) // Controlla se qualche lettura ha avuto esito negativo ed esci prima (per riprovare). { Serial.println("Impossibile leggere dal sensore DHT!"); temp = tempIni; ronzio = humIni; Restituzione; } }

Il codice completo che include i sensori UV e DHT può essere scaricato dal mio GitHub: NodeMCU_UV_DHT_Sensor_OLED

Passaggio 6: invio di dati a ThingSpeak.com

Finora abbiamo utilizzato il NodeMCU ESP12-E solo come una normale scheda Arduino. Certo, abbiamo solo "grattato" il vero potenziale di questo spettacolare chip e ora è il momento di decollare per il paradiso! O meglio alle stelle! Ehm… alla nuvola!;-)

Cominciamo!

1. Innanzitutto, devi avere un account su ThinkSpeak.com
2. Segui le istruzioni per creare un canale e prendi nota del tuo ID canale e della chiave API di scrittura
3. Aggiorna il codice seguente con la tua rete WiFi e le credenziali Thinkspeak
4. Esegui il programma su IDE

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:

/* ESP12-E e Thinkspeak*/

#include client WiFiClient; const char* MY_SSID = "IL TUO ID SSD QUI"; const char* MY_PWD = "QUI LA TUA PASSWORD"; const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY ="CHIAVE API DI SCRITTURA DEL TUO CANALE";

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 += "&field1="; postStr += String(dataSensorUV); postStr += "&field2="; postStr += String(indexUV); postStr += "&field3="; postStr += String(temp); postStr += "&field4="; postStr += String(ronzio); 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 7: 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