DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Er is een breed scala aan temperatuursensoren die compatibel zijn met Arduino, ESP32, ESP8266 en andere ontwikkelboards. Het kan dus moeilijk zijn om de meest geschikte sensor voor je project te kiezen. In dit artikel vergelijken we 6 veelgebruikte temperatuursensoren: DHT11, DHT22, LM35, DS18B20, BME280 en BMP180.

We vergelijken de sensoren als het gaat om communicatieprotocol, temperatuurbereik, nauwkeurigheid, gebruiksgemak en nog veel meer.

We voeren ook een eenvoudig experiment uit waarbij we de temperatuur in dezelfde omgeving hebben gemeten met alle temperatuursensoren in de loop van de tijd. Met dit experiment konden we zien hoe de sensoren reageren op temperatuursveranderingen. We hebben dit experiment gedurende ongeveer 36 uur uitgevoerd en we zullen u de resultaten later in dit artikel laten zien.

Aanbevolen lectuur: 9 Arduino Compatibele Temperatuur Sensoren voor Uw Elektronica Projecten

Vergelijking Temperatuur Sensoren: DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Voor een snelle vergelijking van de sensoren hebben we de volgende tabel samengesteld met de belangrijkste informatie als het gaat om het selecteren van een temperatuursensor, namelijk: communicatieprotocol, voedingsspanning, temperatuurbereik en nauwkeurigheid.

Opmerking: de tabel scrollt horizontaal zowel op desktop computer, tablet en mobiel.

wire

Sensor	DHT11	DHT22 (AM2302)	LM35	DS18B20	BME280	BMP180
Metingen	Temperatuur Vochtigheid	Temperatuur Vochtigheid	Temperatuur	Temperatuur	Temperatuur Vochtigheid Druk	Temperatuur Druk
Communicatie protocol	Eén-draads	Temperatuur Vochtigheid	Temperatuur Druk	One-wire	Analog	One-wire	I2C SPI	I2C
Supply voltage	3 tot 5.5V DC	3 tot 6V DC	4 tot 30 V DC	3 tot 5,5V DC	1,7 tot 3,6V (voor de chip) 3,3 tot 5V voor de printplaat	1,8 tot 3,6V (voor de chip) 3..3 tot 5V voor de printplaat
Temperatuur	0 tot 50ºC	-40 tot 80ºC	-55 tot 150ºC	-55 tot 125ºC	-40 tot 85ºC	0 tot 65ºC
Nauwkeurigheid	+/- 2ºC (bij 0 tot 50ºC)	+/- 0.5ºC (bij -40 tot 80ºC)	+/-0,5ºC (bij 25ºC)	+/-0,5ºC (bij -10 tot 85ºC)	+/-0,5ºC (bij 25ºC)	+/-0.5ºC (bij 25ºC)
Support (Arduino IDE)	Adafruit DHT Library Adafruit Unified Sensor Library	Adafruit DHT Bibliotheek Adafruit Unified Sensor Library	analogRead()	DallasTemperature OneWire	Adafruit BME280 library Adafruit Unified Sensor Library	Adafruit BME085 Adafruit Unified Sensor Library
Support (MicroPython)	dht-module (opgenomen in MicroPython-firmware)	dht-module (opgenomen in MicroPython-firmware)	from machine import ADC ADC().read	ds18b20 module (opgenomen in MicroPython firmware)	BME280 Adafruit Library	BMP180 module
Waar te koop?	Check prices	Check prices	Check prices	Check prices Check prices (waterproof)	Check prices	Check prices

DHT11 vs DHT22 (AM2302)

De DHT11 en DHT22 (AM2302) zijn digitale temperatuursensoren die temperatuur en vochtigheid meten. Ze lijken erg op elkaar en werken op dezelfde manier, maar hebben verschillende specificaties.

Beide sensoren kunnen zowel met 3,3V als 5V worden gevoed. Je kunt ze dus gemakkelijk gebruiken in je Arduino of ESP projecten.

De DHT22 sensor heeft een betere resolutie en een groter temperatuur- en vochtigheidsmeetbereik. Hij is echter iets duurder en je kunt alleen metingen opvragen met een interval van 2 seconden.

De DHT11 is iets goedkoper, hij heeft een kleiner bereik en hij is minder nauwkeurig. Maar je kunt sensor metingen elke seconde krijgen.

Ondanks hun verschillen, werken ze op een vergelijkbare manier, en je kunt dezelfde code gebruiken om temperatuur en vochtigheid te lezen. Je hoeft alleen maar in de code te selecteren welk type sensor je gebruikt.

Dus, als je bereid bent een dollar extra uit te geven, raden we de DHT22 aan boven de DHT11.

We hebben diverse gidsen over het gebruik van de DHT11 en DHT22 sensoren:

• ESP32 (Arduino IDE) met DHT11/DHT22 temperatuur en vochtigheidssensor
• ESP8266 (Arduino IDE) DHT11/DHT22 temperatuur en vochtigheid Web Server
• Arduino met DHT11/DHT22 vochtigheids- en temperatuursensor
• ESP32/ESP8266 (MicroPython) met DHT11/DHT22 Web Server

LM35, LM335 en LM34

De LM35, LM335 en LM34 zijn lineaire temperatuursensoren die een spanning afgeven die evenredig is met de temperatuurwaarde. De LM35 is gekalibreerd in graden Celsius, de LM335 in Kelvin en de LM34 in Fahrenheit. Dus, afhankelijk van de temperatuureenheden die u in uw project zult gebruiken, kan een van deze sensoren praktischer zijn dan de andere.

Wij raden aan de LM35 of LM34 te gebruiken in plaats van de LM335, omdat het aftrekken van een groot getal van de LM335 metingen om de temperatuur om te zetten van Kelvin de nauwkeurigheid van de resultaten in gevaar kan brengen.

Volgens de datasheet, hebben de LM35 en LM34 sensoren zeer weinig stroom nodig om te werken, ongeveer 60uA. Dit resulteert in een zeer lage zelfverwarming (ongeveer 0,08 ºC in stilstaande lucht), wat betekent dat de temperatuurmetingen niet zullen worden beïnvloed door de sensor zelf.

Om de temperatuur van deze sensoren af te lezen, hoeft u alleen maar de uitgangsspanning van de sensor af te lezen met behulp van een analoge pin. Als u een Arduino gebruikt, hoeft u alleen maar de analogRead() functie te gebruiken en u krijgt temperatuurmetingen met twee decimale punten.

Dus, als u een goedkope en eenvoudig te gebruiken sensor nodig hebt om de temperatuur te bewaken, kan de LM35 een goede optie zijn. Ook, omdat het verbruikt zeer weinig energie, het is geweldig voor draagbare projecten, waar een laag stroomverbruik is vereist.

Leer hoe u de LM35, LM335 en LM34 temperatuursensoren met Arduino kunt gebruiken:

• Gids voor LM35, LM335 en LM34 temperatuursensoren met Arduino

DS18B20 temperatuursensor

De DS18B20 temperatuursensor is een eendraadse digitale temperatuursensor. Dit betekent dat hij slechts één datalijn (en GND) nodig heeft om te communiceren met uw microcontrollers.

Hij kan worden gevoed door een externe voeding of hij kan stroom afnemen van de datalijn (de zogenaamde “parasietmodus”), waardoor er geen externe voeding nodig is.

Elke DS18B20-temperatuursensor heeft een unieke 64-bits seriële code. Dit laat u toe om meerdere sensoren op dezelfde datadraad aan te sluiten. Dus, u kunt de temperatuur van meerdere sensoren krijgen met behulp van een enkele GPIO.

Daarnaast kan de resolutie van de temperatuursensor worden ingesteld op 9, 10, 11 of 12 bits, wat overeenkomt met stappen van respectievelijk 0,5°C, 0,25°C, 0,125°C en 0,0625°C. De standaardresolutie bij het opstarten is 12 bits.

De DS18B20 temperatuursensor is ook beschikbaar in een waterdichte versie, ideaal voor buitenprojecten of om vloeistoftemperatuur te meten.

U kunt onze gidsen volgen om te leren hoe u de DS18B20 temperatuursensor kunt gebruiken met de ESP32, ESP8266 en Arduino met behulp van Arduino IDE of MicroPython:

• ESP32 (Arduino IDE) DS18B20 Temperatuursensor (Enkel, Meervoudig, Web Server)
• ESP8266 (Arduino IDE) DS18B20 Temperatuursensor (Enkelvoudig, Meervoudig, Web Server)
• ESP32 en ESP8266 (MicroPython) met DS18B20 Temperatuur Sensor
• Arduino met DS18B20 Temperatuur Sensor

BME280 vs BMP180

De BME280 en BMP180 zijn barometrische sensoren wat betekent dat ze de atmosferische druk aflezen. De BME280 is ook uitgerust met een temperatuur- en een vochtigheidssensor, en de BMP180 met een temperatuursensor. Omdat de druk verandert met de hoogte, kunnen deze sensoren ook worden gebruikt om de hoogte te schatten.

Wat het temperatuurbereik betreft, heeft de BME280 een groter meetbereik: -40 tot 85ºC, terwijl de BMP180 slechts van 0 tot 65ºC meet. Je moet er wel rekening mee houden dat de BME280 module zichzelf een beetje opwarmt, dus de temperatuur metingen kunnen 1 of 2 graden boven de echte temperatuur waarde liggen.

De BME280 kan zowel I2C als SPI communicatie protocol gebruiken, terwijl de BMP180 alleen I2C communicatie kan gebruiken.

De BME280 sensor is duurder, maar heeft meer functionaliteiten. Je kunt bijvoorbeeld een weerstation project bouwen met alleen deze sensor. Maar als je niet geïnteresseerd bent in het meten van druk of vochtigheid, kan je een goedkopere temperatuursensor nemen.

Interfacing van deze sensoren met Arduino, ESP8266 en ESP32 is zeer eenvoudig dankzij de Adafruit bibliotheken.

U kunt onze gidsen gebruiken om te leren hoe deze sensoren te gebruiken:

• BMP180:
  • Arduino met BMP180 Barometrische Sensor
  • ESP32 (Arduino IDE) met BMP180 Barometrische Sensor
• BME280:
  • ESP32 (Arduino IDE) met BME280 Sensor (Druk, Temperatuur, Vochtigheid)
  • ESP8266 (Arduino IDE) met BME280 (Druk, Temperatuur, Vochtigheid)
  • Arduino met BME280 Sensor(Druk, Temperatuur, Vochtigheid)

We hebben ook andere projecten met de BME280 die je misschien leuk vindt:

• 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

Dit experiment logde temperatuur lezingen van verschillende temperatuur sensoren in de tijd in de zelfde omstandigheden.

We hebben alle volgende temperatuursensoren aangesloten op een Arduino Mega:

• DHT11
• DHT22
• LM35
• 2x DS18B20 in dezelfde databus
• BME280
• BMP180

De gegevens werden opgenomen op een microSD-kaart met behulp van een microSD-kaartmodule. Het experiment duurde ongeveer 36 uur en de temperatuurmetingen werden elke 5 minuten gelogd.

We bedraadden de datapinnen van de temperatuursensoren met de volgende pinnen op Arduino Mega:

• DHT11: Pin 11
• DHT22: Pin 12
• DS18B20: Pin 14
• LM35: Pin A0
• BME280: software SPI op deze pinnen: Speld 4 (MISO), Speld 5 (CS), Speld 6 (SCK), Speld 7 (MOSI)
• BMP180: Pin 20 (SDA) en Pin 21 (CSL)

De microSD kaart module werd via hardware SPI aangesloten: Pin 51 (MOSI), Pin 50 (MISO), Pin 52 (SCK), Pin 53 (CS).

Dit is de code die draait in de 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);}

Bekijk ruwe code

Note: om deze code te compileren en uit te voeren, moet je in je Arduino IDE alle sensor libraries installeren die in de vergelijkingstabel aan het begin van dit artikel staan.

Resultaten: Temperatuurmetingen vergelijken

Na ongeveer 36 uur hebben we de microSD-kaart verwijderd en de resultaten naar een spreadsheet gekopieerd. We hebben alle metingen uitgezet om de metingen van de verschillende temperatuursensoren beter te kunnen vergelijken.

Deze grafiek heeft geen controlegroep (we hebben geen gekalibreerde temperatuursensor gebruikt), maar we hebben een idee over hoe deze sensoren zich gedragen.

Als je goed naar de grafieken kijkt, zie je dat de BME280 iets hogere waarden heeft gemeten dan de andere temperatuursensoren. Dit gedrag is normaal, en het staat beschreven in de datasheet. De module warmt zichzelf een beetje op en de temperatuur metingen kunnen 1 of 2 graden boven de werkelijke temperatuur waarde liggen.

De BME280 is echter ook de temperatuur sensor die stabielere temperatuur uitlezingen gaf zonder veel oscillaties tussen de uitlezingen. Dit heeft te maken met de resolutie van de sensor. Deze kan veranderingen detecteren tot 0.01ºC.

Bij de DS18B20 temperatuursensoren zien we wel wat oscillaties tussen de uitlezingen en het is ook merkbaar dat de resolutie niet zo goed is als die van de BME280. Bovendien was de DS18B20 temperatuursensor de enige die enkele “null” waarden gaf gedurende het experiment. We hebben twee DS18B20 temperatuursensoren in dezelfde datalijn gemeten en een van de sensoren heeft gedurende het experiment (gedurende 36 uur) 6 keer de temperatuur niet afgelezen.

De DHT22 en de BMP180 gedragen zich zeer gelijkaardig met weinig oscillaties. De DHT11 kon geen kleine temperatuurveranderingen detecteren, omdat zijn resolutie 1ºC is.

De LM35 temperatuursensor tenslotte detecteerde temperatuurveranderingen tussen 24ºC en 26ºC, maar met veel oscillaties tussen de metingen.

Deze grafiek die de verschillende temperatuursensoren vergelijkt, laat duidelijk zien hoe elke sensor verschilt van de andere. Het is gemakkelijker te begrijpen hoe ze werken en of ze geschikt zullen zijn voor de projecten die u wilt bouwen.

Wrapping Up

In dit artikel hebben we verschillende temperatuursensoren vergeleken die u kunt gebruiken met de ESP32, ESP8266, Arduino en andere ontwikkelborden. Deze sensoren meten allemaal temperatuur, maar ze gedragen zich verschillend wanneer ze in dezelfde omgeving op hetzelfde moment op de proef worden gesteld.

Wij hopen dat u dit artikel nuttig vond en dat het u helpt de beste temperatuursensor te kiezen voor uw project requirements.

U zou ook kunnen lezen:

• 9 Arduino-compatibele temperatuursensoren voor uw elektronica projecten
• ESP32/ESP8266 Plot Sensor metingen in real-time grafieken
• Inschrijven in onze elektronica cursussen en eBook