Sul modulo breakout presentato in questo articolo sono presenti un sensore AHT20 e un sensore BMP280.
Il sensore AHT20 permette la misura della temperatura e umidità, mentre il sensore BMP280 permette la misura della pressione barometrica. Entrambi hanno un’uscita su bus I2C.
Indice
Descrizione
Il modulo Sensore AHT20+BMP280 non solo può misurare la temperatura e l’umidità, ma anche la pressione. Il collegamento è tramite il protocollo I2C e supporta l’accesso simultaneo a due sensori presenti sul PCB. Tensione di alimentazione da 2.8V a 5V.
Dimensione PCB: 15×15 mm.
Sensore AHT20 Sensore di temperatura e umidità digitale
Il sensore AHT20 (datasheet) è un sensore di temperatura e umidità economico performante, tale prodotto è stato realizzato dalla stessa equipe di ingegneri del sensore DHT22. Come altri sensori con AHT20 è possibile eseguire le letture della temperatura e utilizza il protocollo I2C standard e per tale motivo è molto semplice da utilizzare con qualsiasi board Arduino e raspberry.
Le principali caratteristiche del sensore ATH20 sono:
- Intervallo di temperatura: da -40 a 85 ° C (precisione di ±0,3 ° C);
- Intervallo di umidità relativa: da 0 a 100 RH% (±2% di precisione);
- Alimentazione: 3,3 – 5V
- Indirizzo I2C: 0x38
Il sensore rileva l’umidità relativa e la temperatura misurando la resistenza elettrica tra i due elettrodi. La conduttività tra gli elettrodi aumenta all’aumentare dell’umidità relativa.
Sensore BMP280 Sensore digitale di pressione
Il sensore BMP280 (datasheet) permette di misurare la pressione atmosferica con una precisione assoluta di ± 1 hPa, visto che la pressione atmosferica cambia con l’altitudine può anche essere utilizzato come altimetro con una precisione di ± 1 metro. Inoltre fornisce il valore di temperatura con una precisione di ± 1,0 °C . Il sensore viene alimentato con una tensione di 3,3 – 5V ed il segnale in uscita è disponibile su protocollo I2C.
Principali caratteristiche del sensore BMP280 sono:
- Campo di misura della pressione: da 300-1100hPa ± 0,12 hPa;
- Precisione relativa : (950 … 1050 hPa a 25°C) ±0,12 hPa, equiv. a ±1 m;
- Precisione assoluta tipica: (950 …1050 hPa, 0 …+40 °C) ±1 hPa;
- Campo di misura temperatura da -40 °C a +85 °C;
- Precisione temperatura: ± 1 °C;
- Alimentazione: 3,3 – 5V;
- Interfaccia: I2C e SPI (non utilizzata nel modulo);
- Indirizzo I2C: 0x77.
Comparazione con altri sensori
Oltre a questo sensore troviamo in commercio molti altri altri sensori di Temperatura/Umidità, come il modello ATH10, DHT11 e il DHT22.
Questi hanno hanno una forma diversa , il DHT11 ha la custodia di color blu mentre il DHT22 ha la custodia di color bianco. Il DHT11 è più economico del DHT22 a discapito però di una minore precisione.
Anche il tipo di interfaccia è diversa, single-bus per i tipi DHT e I2c per il tipo AHT10 e AHT20
 |
 |
 |
 |
| AHT20 | AHT10 | DHT11 | DHT22 |
Di seguito una tabella con i margini di operabilità dei quattro sensori a confronto
| AHT10 | AHT20 | DHT11 | DHT22 | |
|---|---|---|---|---|
| Intervallo di temperatura | -40- 85 °C | -40- 85 °C | 0-50 °C | -40-80 °C |
| Precisione della temperatura | ±0.3% °C | ±0.3% °C | ±2% °C | ±0.5% °C |
| Intervallo di umidità | 0-100% RH | 0-100% RH | 20-90% RH | 0-100% RH |
| Precisione dell'umidità | ±2% RH | ±2% RH | ±5% RH | ±2% RH |
| Tensione di funzionamento | 3.3V-6V | 3.3V-6V | 3.3V- 5.5V | 3.3V-6V |
| Tipo di comunicazione | I2C | I2C | single-bus | single-bus |
Dove trovare il modulo AHT20+BMP280
Il sensore AHT20+BMP280 potrà essere acquistato online per esempio sul sito AliExpress a questo link
Il modulo è inviato all’interno di una busta antistatica, contenete anche un pin-strip maschio che deve essere saldata a vostra cura.
Libreria di gestione dei sensori
Libreria per sensore AHT20
Per facilitare l’uso del sensore è disponibile l’apposita libreria, basterà inserire nel campo di ricerca “Adafruit AHTx0“. Insieme alla libreria sarà richiesto di caricare delle dipendenze per questa libreria, accettare e installare tutto.
Vedete anche l’articolo Arduino – Tutorial, come installare una libreria
Libreria per sensore BMP280
Anche in questo caso, per facilitare l’uso del sensore è disponibile l’apposita libreria, basterà inserire nel campo di ricerca “Adafruit BMP280“. Insieme alla libreria sarà richiesto di caricare delle dipendenze per questa libreria, accettare e installare tutto.
Test base del modulo sensore AHT20+BMP280 con Arduino
Materiale occorrente
Per testare il funzionamento del modulo sensore monteremo un semplice circuito, il materiale occorrente è:
 |
|
| Arduino UNO o suo clone | Modulo sensore AHT20+BMP280 |
 |
 |
| Cavi di collegamento M/F | Bread board (opzionale) |
Schema dei collegamenti
I collegamenti sono mostrati nella figura sottostante.
Nota: nel prototipo è stata utilizzata al posto della scheda Arduino UNO, una scheda KS0486 Keyestudio PLUS completamente compatibile con l’ambiente di sviluppo Arduino IDE. Contiene tutte le funzioni della scheda Arduino UNO R3 e alcuni miglioramenti che ne rafforzano notevolmente la funzione.
Sulla scheda sono presenti del connettori per collegare direttamente i moduli.
Programma di test del sensore solo ATH20
Una volta caricato lo sketch si dovrà attivare il monitor seriale dell’IDE, a questo punto si dovrebbero leggere i valori della temperatura e dell’umidità letti dal sensore ATH20 che si aggiorneranno ogni secondo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
/********* Lettura sensore ATH20 https://www.adrirobot.it/ *********/ #include <Adafruit_AHTX0.h> Adafruit_AHTX0 aht; void setup() { Serial.begin(115200); Serial.println("Test lettura sensore AHT20"); if (!aht.begin()) { Serial.println("Impossibile trovare il sensore AHT20, controllare il cablaggio"); while (1) delay(10); } Serial.println("Sensore AHT20 trovato"); Serial.println("---------------------"); } void loop() { sensors_event_t humidity, temp; aht.getEvent(&humidity, &temp); // lettura dati aggiornati Serial.print("Temperatura: "); Serial.print(temp.temperature); Serial.println(" *C"); Serial.print("Umidità: "); Serial.print(humidity.relative_humidity); Serial.println("% rH"); Serial.println(); delay(1000); } |
Nel caso fosse riportato la scritta “Impossibile trovare il sensore”, controllare che il modulo sia correttamente alimentato, e che non siano invertiti i cavi SDA e SCL.
Sotto l’esempio dell’output tramite il monitor seriale.
Programma di test del sensore del solo BMP280
Anche in questo caso, una volta caricato lo sketch si dovrà attivare il monitor seriale dell’IDE, a questo punto si dovrebbero leggere i valori della temperatura, pressione atmosferica e altitudine approssimativa letti dal sensore BMP280. Valori aggiornati ogni due secondi.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
/********* Lettura sensore BMP280 https://www.adrirobot.it/ *********/ #include <Wire.h> #include <SPI.h> #include <Adafruit_BMP280.h> Adafruit_BMP280 bmp; // I2C void setup() { Serial.begin(115200); while (!Serial) delay(100); // attesa collegamento USB Serial.println(F("Test lettura sensore BMP280")); unsigned status; status = bmp.begin(); if (!status) { Serial.println(F("Impossibile trovare il sensore BMP280, controllare il cablaggio o " " cablaggio o usare un diverso indirizzo!")); Serial.print("L'ID sensore era: 0x"); Serial.println(bmp.sensorID(), 16); Serial.print(" ID of 0xFF indirizzo errato, un BMP 180 o BMP 085\n"); Serial.print(" ID of 0x56-0x58 rappresenta un BMP 280,\n"); Serial.print(" ID of 0x60 rappresenta un BME 280.\n"); Serial.print(" ID of 0x61 rappresenta un BME 680.\n"); while (1) delay(10); } Serial.println("Sensore BMP280 trovato"); Serial.println("----------------------"); /* Default settings from datasheet. */ bmp.setSampling(Adafruit_BMP280::MODE_NORMAL, /* Operating Mode. */ Adafruit_BMP280::SAMPLING_X2, /* Temp. oversampling */ Adafruit_BMP280::SAMPLING_X16, /* Pressure oversampling */ Adafruit_BMP280::FILTER_X16, /* Filtering. */ Adafruit_BMP280::STANDBY_MS_500); /* Standby time. */ } void loop() { Serial.print(F("Temperatura = ")); Serial.print(bmp.readTemperature()); Serial.println(" *C"); Serial.print(F("Pressione = ")); Serial.print(bmp.readPressure()); Serial.println(" Pa"); Serial.print(F("Altitude approssimativa = ")); Serial.print(bmp.readAltitude(1013.25)); /* Adjusted to local forecast! */ Serial.println(" m"); Serial.println(); delay(2000); } |
Sotto l’esempio dell’output tramite il monitor seriale.
Programma per Stazione Meteo con Sensori AHT20-BMP280
Negli esempi precedenti abbiamo visto come leggere separatamente i dati dei due sensori.
Ora realizzeremo una semplice Stazione Meteo, useremo per questo un programma che leggerà i dati forniti dai due sensori.
in particolare utilizzeremo i valori della temperatura e dell’umidità misurati dal sensore AHT20 e il valore della pressione atmosferica misurato dal sensore BMP280.
Nota: utilizzeremo il valore della temperatura fornito dal sensore ATH20 in quanto più preciso di quello fornito dal sensore BMP280.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
/********* Stazione meteo con sensori ATH20+BMP280 https://www.adrirobot.it/ *********/ #include <Wire.h> #include <Adafruit_BMP280.h> #include <Adafruit_AHTX0.h> Adafruit_BMP280 bmp; Adafruit_AHTX0 aht; void setup() { Serial.begin(115200); Serial.println(F("Stazione meteo con AHT20+BMP280")); //verifica collegamento con ATH20 if (!aht.begin()) { Serial.println("Sensore ATH20 non trovato"); while (1) delay(10); } Serial.println("Sensore AHT20 trovato"); //verifica collegamento con BMP280 if (!bmp.begin()) { Serial.println(F("Sensore BMP 280 non trovato")); while (1) ; } Serial.println("Sensore BMP280 trovato"); Serial.println("----------------------"); /* Default settings from datasheet. */ bmp.setSampling(Adafruit_BMP280::MODE_NORMAL, /* Operating Mode. */ Adafruit_BMP280::SAMPLING_X2, /* Temp. oversampling */ Adafruit_BMP280::SAMPLING_X16, /* Pressure oversampling */ Adafruit_BMP280::FILTER_X16, /* Filtering. */ Adafruit_BMP280::STANDBY_MS_500); /* Standby time. */ } void loop() { sensors_event_t humidity, temp; aht.getEvent(&humidity, &temp); // aggiornamento dati Serial.print("Temperatura: "); // da Sensore ATH20 Serial.print(temp.temperature, 1); Serial.println(" *C"); Serial.print("Humidita': "); // da sensore ATH20 Serial.print(humidity.relative_humidity); Serial.println("% rH"); Serial.print("Pressione: "); // da sensore BMP280 Serial.print(bmp.readPressure()); Serial.println("Pa"); Serial.println(); delay(2000); } |
Sotto l’esempio dell’output tramite il monitor seriale.
Lettura valori tramite server WEB
Un’altra possibilità di utilizzo è quella di visualizzare i dati letti dal sensore ATH20+BMP80 presenti sul modulo su una pagina web ospitata sul modulo Lolin ESP32-C3 pico utilizzato come punto di accesso.
Sotto il materiale per realizzare il progetto.
Per informazioni sul modulo ESP32-C3 pico vedere l’articolo Wemos LOLIN C3 Pico con ESP32-C3
Materiale occorrente
 |
|
| Modulo Lolin ESP32-C3 pico | Modulo sensore AHT20+BMP280 |
|
|
| Cavi colorati M/M |
Schema dei collegamenti
Sotto è riportato lo schema dei collegamenti
Piedinatura del Modulo Wemos LOLIN C3 Pico con ESP32-C3
Prima di trasferire lo sketch nel modulo ESP32, occorrerà inserire le credenziali del proprio router
|
1 2 3 |
//Sostituisci con le tue credenziali di rete const char* ssid = "xxx"; const char* password = "xxx"; |
Per accedere al server web, una volta lanciato il programma, si dovrà prendere nota dell’indirizzo IP che sarà assegnato al nostro dispositivo
Questo IP andrà inserito nel proprio browser, a questo punto dovreste vedere la pagina seguente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 |
/********* Lettura sensore ATH20+BMP80 tramite serwer-web - Lolin C3-pico https://www.adrirobot.it/ *********/ #include <WiFi.h> #include <WebServer.h> #include <Adafruit_AHTX0.h> #include <Adafruit_BMP280.h> //Sostituisci con le tue credenziali di rete const char* ssid = "xxxxx"; const char* password = "xxxx"; WebServer server(80); Adafruit_BMP280 bmp; // I2C Adafruit_AHTX0 aht; Adafruit_Sensor *aht_humidity, *aht_temp; void handleRoot() { // Get sensor readings sensors_event_t humidity; sensors_event_t temp; aht_humidity->getEvent(&humidity); aht_temp->getEvent(&temp); // Create HTML page with sensor data String html = "<html><body>"; html += "<h2><b>Lettura sensori ATH20+BMP280</b></h2>"; html += "<h2>www.adrirobot.it</h2>"; html += "<p>Temperatura: " + String(temp.temperature) + " *C</p>"; html += "<p>Umidita': " + String(humidity.relative_humidity) + " % rH</p>"; html += "<p>Pressione : " + String(bmp.readPressure()) + " Pa</p>"; html += "</body></html>"; server.send(200, "text/html", html); } void setup() { Serial.begin(115200); while (!Serial) delay(100); // wait for native usb Serial.println(F("Test sensori AHT20+BMP280")); unsigned status; //status = bmp.begin(BMP280_ADDRESS_ALT, BMP280_CHIPID); status = bmp.begin(); if (!status) { Serial.println(F("Impossibile trovare un sensore BMP280 valido, controllare il cablaggio o " "provare un indirizzo diverso!")); Serial.print("SensorID was: 0x"); Serial.println(bmp.sensorID(), 16); Serial.print(" ID of 0xFF probably means a bad address, a BMP 180 or BMP 085\n"); Serial.print(" ID of 0x56-0x58 represents a BMP 280,\n"); Serial.print(" ID of 0x60 represents a BME 280.\n"); Serial.print(" ID of 0x61 represents a BME 680.\n"); while (1) delay(10); } // Connessione alla rete Wi-Fi WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.println("Connessione al Wi-Fi..."); } Serial.println("Connesso al WiFi"); // Initialize AHT sensor if (!aht.begin()) { Serial.println("Impossibile trovare il chip AHT20"); while (1) { delay(10); } } Serial.println("Sensore AHT20 trovato!"); aht_temp = aht.getTemperatureSensor(); aht_temp->printSensorDetails(); aht_humidity = aht.getHumiditySensor(); aht_humidity->printSensorDetails(); // Start web server server.on("/", handleRoot); server.begin(); Serial.println("Il server Web è stato avviato"); Serial.println("Indirizzo IP: "); Serial.println(WiFi.localIP()); } void loop() { server.handleClient(); } |
Sensore AHT10 Umidità/temperatura
E’ disponibile anche un modulo con un sensore tipo AHT10 (datasheet) , del tutto simile come funzionamento al tipo AHT20 che permette la misura della temperatura e umidità con uscita dati digitali su bus I2C.
Raccolta di sensori di temperatura e umidità
Per altri modelli di sensore potete visitare la Raccolta di sensori di temperatura e umidità. Sono presenti sensori: misuratori di sola temperatura di tipo analogico o con uscita digitale, misuratori di temperatura IR, sensori di sola umidità, dispositivi che possono misurare sia la temperatura che l’umidità, altri ancora misurano anche altri parametri.
