DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Ci sono una grande varietà di sensori di temperatura compatibili con Arduino, ESP32, ESP8266 e altre schede di sviluppo. Quindi, può essere difficile scegliere il sensore più adatto al tuo progetto. In questo articolo, confronteremo 6 sensori di temperatura ampiamente utilizzati: DHT11, DHT22, LM35, DS18B20, BME280 e BMP180.

Confronteremo i sensori in termini di protocollo di comunicazione, gamma di temperatura, precisione, facilità d’uso e molto altro.

Facciamo anche un semplice esperimento in cui abbiamo misurato la temperatura nello stesso ambiente utilizzando tutti i sensori di temperatura nel tempo. Con questo esperimento abbiamo potuto vedere come i sensori reagiscono ai cambiamenti di temperatura. Abbiamo eseguito questo esperimento per circa 36 ore e vi mostreremo i risultati più avanti in questo articolo.

Lettura consigliata: 9 sensori di temperatura compatibili con Arduino per i tuoi progetti di elettronica

Sensori di temperatura a confronto: DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Per un rapido confronto dei sensori, abbiamo messo insieme la seguente tabella che mostra le informazioni più importanti quando si tratta di selezionare un sensore di temperatura e cioè: protocollo di comunicazione, tensione di alimentazione, range di temperatura e precisione.

Nota: la tabella scorre orizzontalmente sia su computer desktop, tablet e mobile.

Sensore	DHT11	DHT22 (AM2302)	LM35	DS18B20	BME280	BMP180
Misure	Temperatura Umidità	Temperatura Umidità	Temperatura	Temperatura	Temperatura Umidità Pressione	Temperatura Pressione
Comunicazione protocollo	Unwire	One-wire	Analog	One-wire	I2C SPI	I2C
Supply voltage	3 to 5.5V DC	3 a 6V DC	4 a 30 V DC	3 a 5.5V DC	1.7 a 3.6V (per il chip) 3.3 a 5V per la scheda	1.8 a 3.6V (per il chip) 3.Da 3 a 5V per la scheda
Temperatura gamma	da 0 a 50ºC	-40 a 80ºC	-55 a 150ºC	-55 a 125ºC	-40 a 85ºC	0 a 65ºC
Precisione	+/- 2ºC (a 0 a 50ºC)	+/- 0.5ºC (a -40 a 80ºC)	+/-0.5ºC (a 25ºC)	+/-0.5ºC (a -10 a 85ºC)	+/-0.5ºC (a 25ºC)	+/-0.5ºC (a 25ºC)
Supporto (Arduino IDE)	Libreria DHT Adafruit Biblioteca sensori unificati Adafruit	Adafruit DHT Biblioteca Adafruit Unified Sensor Biblioteca	analogRead()	DallasTemperature OneWire	Adafruit BME280 library Adafruit Unified Sensor Library	Adafruit BME085 Adafruit Unified Sensor Library
Supporto (MicroPython)	modulo dht (incluso nel firmware MicroPython)	modulo dht (incluso nel firmware MicroPython)	da machine import ADC ADC().read	modulo ds18b20 (incluso nel firmware MicroPython)	BME280 Adafruit Library	modulo BMP180
Dove comprare?	Controlla i prezzi	Controlla i prezzi	Controlla i prezzi	Controlla i prezzi Controlla i prezzi (impermeabile)	Controlla i prezzi	Controlla i prezzi

DHT11 vs DHT22 (AM2302)

I DHT11 e DHT22 (AM2302) sono sensori di temperatura digitali che misurano temperatura e umidità. Sembrano molto simili e funzionano allo stesso modo, ma hanno specifiche diverse.

Entrambi i sensori possono essere alimentati con 3,3V o 5V. Quindi, puoi usarli facilmente nei tuoi progetti Arduino o ESP.

Il sensore DHT22 ha una risoluzione migliore e una gamma di misurazione di temperatura e umidità più ampia. Tuttavia, è un po’ più costoso e si possono richiedere solo letture con un intervallo di 2 secondi.

Il DHT11 è leggermente più economico, ha una gamma più piccola ed è meno preciso. Ma è possibile ottenere letture del sensore ogni secondo.

Nonostante le loro differenze, funzionano in modo simile, e si può usare lo stesso codice per leggere la temperatura e l’umidità. Devi solo selezionare nel codice il tipo di sensore che stai usando.

Quindi, se sei disposto a spendere un dollaro in più, ti consigliamo il DHT22 rispetto al DHT11.

Abbiamo diverse guide su come utilizzare i sensori DHT11 e DHT22:

• ESP32 (Arduino IDE) con sensore di temperatura e umidità DHT11/DHT22
• ESP8266 (Arduino IDE) DHT11/DHT22 Temperature and Humidity Web Server
• Arduino con DHT11/DHT22 Sensore di umidità e temperatura
• ESP32/ESP8266 (MicroPython) con DHT11/DHT22 Web Server

LM35, LM335 e LM34

L’LM35, LM335 e LM34 sono sensori di temperatura lineari che emettono una tensione proporzionale al valore della temperatura. L’LM35 viene calibrato in gradi Celsius, l’LM335 in Kelvin e l’LM34 in Fahrenheit. Quindi, a seconda delle unità di temperatura che utilizzerai nel tuo progetto, uno di questi sensori potrebbe essere più pratico dell’altro.

Si consiglia di utilizzare l’LM35 o l’LM34 invece dell’LM335, perché sottrarre un numero elevato alle misure dell’LM335 per convertire la temperatura da Kelvin può compromettere la precisione dei risultati.

Secondo il datasheet, i sensori LM35 e LM34 richiedono pochissima corrente per funzionare, circa 60uA. Questo si traduce in un auto-riscaldamento molto basso (circa 0,08ºC in aria ferma), il che significa che le misure di temperatura non saranno influenzate dal sensore stesso.

Per leggere la temperatura da questi sensori è sufficiente leggere la tensione di uscita del sensore utilizzando un pin analogico. Se si utilizza un Arduino, è sufficiente utilizzare la funzione analogRead() e si otterrà la lettura della temperatura con due punti decimali.

Quindi, se avete bisogno di un sensore economico e facile da usare per monitorare la temperatura, l’LM35 può essere una buona opzione. Inoltre, poiché consuma poca energia, è ottimo per progetti portatili, dove è richiesto un basso consumo energetico.

Impara come usare i sensori di temperatura LM35, LM335 e LM34 con Arduino:

• Guida per i sensori di temperatura LM35, LM335 e LM34 con Arduino

Sensore di temperatura DS18B20

Il sensore di temperatura DS18B20 è un sensore di temperatura digitale a un filo. Questo significa che richiede solo una linea dati (e GND) per comunicare con i vostri microcontrollori.

Può essere alimentato da un alimentatore esterno o può derivare l’alimentazione dalla linea dati (chiamata “modalità parassita”), che elimina la necessità di un alimentatore esterno.

Ogni sensore di temperatura DS18B20 ha un unico codice seriale a 64 bit. Questo vi permette di collegare più sensori allo stesso cavo dati. Quindi, è possibile ottenere la temperatura da più sensori utilizzando un singolo GPIO.

Inoltre, la risoluzione del sensore di temperatura può essere impostata a 9, 10, 11 o 12 bit che corrispondono a incrementi di 0,5°C, 0,25°C, 0,125°C e 0,0625°C, rispettivamente. La risoluzione predefinita all’accensione è di 12 bit.

Il sensore di temperatura DS18B20 è disponibile anche in versione impermeabile, ideale per progetti all’aperto o per misurare la temperatura dei liquidi.

Puoi seguire le nostre guide per imparare ad usare il sensore di temperatura DS18B20 con ESP32, ESP8266 e Arduino usando Arduino IDE o MicroPython:

• ESP32 (Arduino IDE) Sensore di temperatura DS18B20 (singolo, multiplo, web server)
• ESP8266 (Arduino IDE) Sensore di temperatura DS18B20 (singolo, multiplo, Web Server)
• ESP32 e ESP8266 (MicroPython) con sensore di temperatura DS18B20
• Arduino con sensore di temperatura DS18B20

BME280 vs BMP180

Il BME280 e il BMP180 sono sensori barometrici, cioè leggono la pressione atmosferica. Il BME280 è anche dotato di un sensore di temperatura e di umidità, e il BMP180 di un sensore di temperatura. Poiché la pressione cambia con l’altitudine, questi sensori possono essere utilizzati anche per stimare l’altitudine.

Per quanto riguarda la gamma di temperatura, il BME280 ha un range di misurazione più ampio: da -40 a 85ºC, mentre il BMP180 misura solo da 0 a 65ºC. Dovresti tenere a mente che il modulo BME280 si riscalda un po’, quindi le misure di temperatura possono essere 1 o 2 gradi sopra il valore reale della temperatura.

Il BME280 può usare sia il protocollo di comunicazione I2C o SPI, mentre il BMP180 può usare solo la comunicazione I2C.

Il sensore BME280 è più costoso ma ha più funzionalità. Per esempio, puoi costruire un progetto di stazione meteorologica con solo questo sensore. Ma se non ti interessa misurare la pressione o l’umidità, puoi prendere un sensore di temperatura più economico.

Interfacendo questi sensori con Arduino, ESP8266 e ESP32 è molto facile grazie alle librerie Adafruit.

Puoi usare le nostre guide per imparare ad usare questi sensori:

• BMP180:
  • Arduino con sensore barometrico BMP180
  • ESP32 (Arduino IDE) con sensore barometrico BMP180
• BME280:
  • ESP32 (Arduino IDE) con sensore BME280 (pressione, temperatura, umidità)
  • ESP8266 (Arduino IDE) con BME280 (pressione, temperatura, umidità)
  • Arduino con sensore BME280 (pressione, temperatura, umidità)

Abbiamo anche altri progetti con il BME280 che ti possono piacere:

• Low Power Weather Station Datalogger using ESP8266 and BME280 with MicroPython
• ESP32 Web Server with BME280 – Mini Weather Station
• ESP32/ESP8266 Insert Data into MySQL Database using PHP and Arduino IDE

Testing All Temperature Sensors

This experiment logged temperature readings from different temperature sensors over time in the same conditions.

Abbiamo collegato tutti i seguenti sensori di temperatura ad un Arduino Mega:

• DHT11
• DHT22
• LM35
• 2x DS18B20 nello stesso bus dati
• BME280
• BMP180

I dati sono stati registrati su una scheda microSD utilizzando un modulo per schede microSD. L’esperimento è durato circa 36 ore e le letture della temperatura sono state registrate ogni 5 minuti.

Abbiamo collegato i pin dati dei sensori di temperatura ai seguenti pin di Arduino Mega:

• DHT11: Pin 11
• DHT22: Pin 12
• DS18B20: Pin 14
• LM35: Pin A0
• BME280: software SPI su questi pin: Pin 4 (MISO), Pin 5 (CS), Pin 6 (SCK), Pin 7 (MOSI)
• BMP180: Pin 20 (SDA) e Pin 21 (CSL)

Il modulo della scheda microSD è stato collegato tramite SPI hardware: Pin 51 (MOSI), Pin 50 (MISO), Pin 52 (SCK), Pin 53 (CS).

Questo è il codice che gira nell’Arduino Mega.

/* * Rui Santos * Complete Project Details https://RandomNerdTutorials.com */#include "DHT.h"#include <OneWire.h>#include <DallasTemperature.h>#include <Wire.h>#include <SPI.h>#include <Adafruit_Sensor.h>#include <Adafruit_BME280.h>#include <Wire.h>#include <Adafruit_BMP085.h>#include <SD.h> // for the SD cardconst int DHT11sensorPin = 11; const int DHT22sensorPin = 12; DHT dht11(DHT11sensorPin, DHT11);DHT dht22(DHT22sensorPin, DHT22);float DHT11temperature;float DHT22temperature;const int DS18B20sensorPin = 14;OneWire oneWire(DS18B20sensorPin);DallasTemperature ds18b20(&oneWire);float DS18B20temperature1;float DS18B20temperature2;const int BME_SCK = 6;const int BME_MISO = 4;const int BME_MOSI = 7;const int BME_CS = 5;Adafruit_BME280 bme280(BME_CS, BME_MOSI, BME_MISO, BME_SCK);Adafruit_BMP085 bmp180; const int LM35sensorPin = A0; float LM35sensorValue;float LM35voltageOut;float LM35temperature;const int chipSelectSDCard = 53; File myFile;void setup() { Serial.begin(9600); dht11.begin(); delay(2000); dht22.begin(); ds18b20.begin(); bme280.begin(); bmp180.begin(); pinMode(LM35sensorPin, INPUT); if(!SD.begin(chipSelectSDCard)) { Serial.println("SD card initialization failed!"); return; } Serial.println("SD card initialization done."); myFile=SD.open("DATA.txt", FILE_WRITE); if (myFile) { Serial.println("File opened ok"); // print the headings for our data myFile.println("DHT11,DHT22,DS18B20-1,DS18B20-2,BME280,BMP180,LM35"); } myFile.close(); }void loop() { /*-------------------------------------------------------*/ //DHT11 DHT11temperature = dht11.readTemperature(); if (isnan(DHT11temperature)) { Serial.println("Failed to read from DHT11 sensor!"); return; } Serial.print("Temperature DHT11(ºC): "); Serial.println(DHT11temperature); /*-------------------------------------------------------*/ //DHT22 DHT22temperature = dht22.readTemperature(); if (isnan(DHT22temperature)) { Serial.println("Failed to read from DHT22 sensor!"); return; } Serial.print("Temperature DHT22(ºC): "); Serial.println(DHT22temperature);/*-------------------------------------------------*/ //DS18B20 ds18b20.requestTemperatures(); DS18B20temperature1 = ds18b20.getTempCByIndex(0); DS18B20temperature2 = ds18b20.getTempCByIndex(1); Serial.print("Temperature DS18B20-1(ºC): "); Serial.println(DS18B20temperature1); Serial.print("Temperature DS18B20-2(ºC): "); Serial.println(DS18B20temperature2);/*-------------------------------------------------*///BME280 Serial.print("Temperature BME280(ºC): "); Serial.println(bme280.readTemperature());/*-------------------------------------------------*///BMP180 Serial.print("Temperature BMP180(ºC): "); Serial.println(bmp180.readTemperature());/*-------------------------------------------------*/ //LM35 SENSOR LM35sensorValue = analogRead(LM35sensorPin); LM35voltageOut = (LM35sensorValue * 5000) / 1024; // calculate temperature for LM35 (LM35DZ) LM35temperature = LM35voltageOut / 10; Serial.print("Temperature LM35(ºC): "); Serial.println(LM35temperature); Serial.println(""); myFile = SD.open("DATA.txt", FILE_WRITE); if (myFile) { Serial.println("File open with success"); myFile.print(DHT11temperature); myFile.print(","); myFile.print(DHT22temperature); myFile.print(","); myFile.print(DS18B20temperature1); myFile.print(","); myFile.print(DS18B20temperature2); myFile.print(","); myFile.print(bme280.readTemperature()); myFile.print(","); myFile.print(bmp180.readTemperature()); myFile.print(","); myFile.print(LM35temperature); myFile.println(","); } myFile.close(); delay(6000);}

Vedi il codice grezzo

Nota: per compilare ed eseguire questo codice, devi installare nel tuo IDE Arduino tutte le librerie di sensori menzionate nella tabella di confronto all’inizio di questo articolo.

Risultati: Confronto delle letture di temperatura

Dopo circa 36 ore, abbiamo rimosso la scheda microSD e copiato i risultati in un foglio di calcolo. Abbiamo tracciato tutte le letture per confrontare meglio le misure dei diversi sensori di temperatura.

Questo grafico non ha un gruppo di controllo (non abbiamo usato un sensore di temperatura calibrato), ma abbiamo un’idea di come si comportano questi sensori.

Se guardate bene i grafici, il BME280 ha misurato valori leggermente più alti degli altri sensori di temperatura. Questo comportamento è normale, ed è descritto nel datasheet. Il modulo si autoriscalda un po’ e le misure di temperatura possono essere di 1 o 2 gradi al di sopra del valore reale della temperatura.

Tuttavia, il BME280 è anche il sensore di temperatura che ha dato letture di temperatura più stabili senza molte oscillazioni tra le letture. Questo ha a che fare con la risoluzione del sensore. Può rilevare cambiamenti fino a 0,01ºC.

Nel caso dei sensori di temperatura DS18B20, possiamo vedere alcune oscillazioni tra le letture ed è anche evidente che la risoluzione non è buona come quella del BME280. Inoltre, il sensore di temperatura DS18B20 è stato l’unico a dare alcune letture “nulle” durante l’esperimento. Abbiamo misurato due sensori di temperatura DS18B20 nella stessa linea di dati e uno dei sensori non è riuscito a leggere la temperatura 6 volte durante l’esperimento (durante 36 ore).

Il DHT22 e il BMP180 si comportano in modo molto simile con poche oscillazioni. Il DHT11 non poteva rilevare piccoli cambiamenti di temperatura, perché la sua risoluzione è di 1ºC.

Infine, il sensore di temperatura LM35 ha rilevato cambiamenti di temperatura tra 24ºC e 26ºC ma con molte oscillazioni tra le misurazioni.

Questo grafico che confronta i diversi sensori di temperatura mostra chiaramente come ogni sensore differisce dagli altri. È più facile capire come funzionano e se saranno adatti ai progetti che vuoi costruire.

In questo articolo abbiamo confrontato diversi sensori di temperatura che puoi usare con ESP32, ESP8266, Arduino e altre schede di sviluppo. Questi sensori misurano tutti la temperatura, ma si comportano in modo diverso quando vengono messi alla prova nello stesso ambiente allo stesso tempo.

Speriamo che tu abbia trovato utile questo articolo e che ti aiuti a scegliere il miglior sensore di temperatura per i requisiti del tuo progetto.

Ti potrebbe anche piacere leggere:

• 9 sensori di temperatura compatibili con Arduino per i tuoi progetti di elettronica
• ESP32/ESP8266 Plot Sensor Readings in Real Time Charts
• Enroll in our electronics Courses and eBook