DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Es gibt eine große Auswahl an Temperatursensoren, die mit Arduino, ESP32, ESP8266 und anderen Entwicklungsboards kompatibel sind. Es kann also schwierig sein, den am besten geeigneten Sensor für Ihr Projekt auszuwählen. In diesem Artikel werden wir 6 weit verbreitete Temperatursensoren vergleichen: DHT11, DHT22, LM35, DS18B20, BME280 und BMP180.

Wir vergleichen die Sensoren in Bezug auf Kommunikationsprotokoll, Temperaturbereich, Genauigkeit, Benutzerfreundlichkeit und vieles mehr.

Wir führen auch ein einfaches Experiment durch, bei dem wir die Temperatur in derselben Umgebung mit allen Temperatursensoren im Laufe der Zeit gemessen haben. Mit diesem Experiment konnten wir sehen, wie die Sensoren auf Temperaturänderungen reagieren. Wir haben dieses Experiment etwa 36 Stunden lang laufen lassen und werden dir die Ergebnisse später in diesem Artikel zeigen.

Leseempfehlung: 9 Arduino-kompatible Temperatursensoren für deine Elektronikprojekte

Vergleich von Temperatursensoren: DHT11 vs. DHT22 vs. LM35 vs. DS18B20 vs. BME280 vs. BMP180

Für einen schnellen Vergleich der Sensoren haben wir die folgende Tabelle zusammengestellt, die die wichtigsten Informationen bei der Auswahl eines Temperatursensors zeigt, nämlich: Kommunikationsprotokoll, Versorgungsspannung, Temperaturbereich und Genauigkeit.

Hinweis: Die Tabelle scrollt horizontal sowohl auf dem Desktop-Computer, dem Tablet und dem Handy.

Sensor	DHT11	DHT22 (AM2302)	LM35	DS18B20	BME280	BMP180
Messungen	Temperatur Feuchte	Temperatur Feuchte	Temperatur	Temperatur	Temperatur Feuchte Druck	Temperatur Druck
Kommunikation Protokoll	Ein-Draht	Ein-Draht	Analog	Ein-Draht	I2C SPI	I2C
Versorgung Spannung	3 bis 5.5V DC	3 bis 6V DC	4 bis 30 V DC	3 bis 5,5V DC	1,7 bis 3,6V (für den Chip) 3,3 bis 5V für das Board	1,8 bis 3,6V (für den Chip) 3.3 bis 5V für die Platine
Temperatur bereich	0 bis 50ºC	-40 bis 80ºC	-55 bis 150ºC	-55 bis 125ºC	-40 bis 85ºC	0 bis 65ºC
Genauigkeit	+/- 2ºC (bei 0 bis 50ºC)	+/- 0.5ºC (bei -40 bis 80ºC)	+/-0.5ºC (bei 25ºC)	+/-0.5ºC (bei -10 bis 85ºC)	+/-0.5ºC (bei 25ºC)	+/-0.5ºC (bei 25ºC)
Unterstützung (Arduino IDE)	Adafruit DHT Bibliothek Adafruit Unified Sensor Bibliothek	Adafruit DHT Library Adafruit Unified Sensor Library	analogRead()	DallasTemperature OneWire	Adafruit BME280 library Adafruit Unified Sensor Library	Adafruit BME085 Adafruit Unified Sensor Library
Support (MicroPython)	dht module (included in MicroPython firmware)	dht module (included in MicroPython firmware)	from machine import ADC ADC().read	ds18b20 Modul (in MicroPython-Firmware enthalten)	BME280 Adafruit Library	BMP180 Modul
Wo kaufen?	Preise prüfen	Preise prüfen	Preise prüfen	Preise prüfen Preise prüfen (wasserdicht)	Preise prüfen	Preise prüfen

DHT11 vs DHT22 (AM2302)

Der DHT11 und der DHT22 (AM2302) sind digitale Temperatursensoren, die Temperatur und Feuchtigkeit messen. Sie sehen sehr ähnlich aus und funktionieren auf die gleiche Weise, haben aber unterschiedliche Spezifikationen.

Beide Sensoren können entweder mit 3,3V oder 5V betrieben werden. Du kannst sie also problemlos in deinen Arduino- oder ESP-Projekten verwenden.

Der DHT22-Sensor hat eine bessere Auflösung und einen größeren Temperatur- und Feuchtigkeitsmessbereich. Allerdings ist er etwas teurer und man kann nur Messwerte mit einem Intervall von 2 Sekunden abfragen.

Der DHT11 ist etwas günstiger, hat einen kleineren Bereich und ist weniger genau. Aber man kann jede Sekunde Sensormesswerte erhalten.

Trotz ihrer Unterschiede funktionieren sie ähnlich, und man kann denselben Code verwenden, um Temperatur und Luftfeuchtigkeit zu messen. Sie müssen nur im Code den Sensortyp auswählen, den Sie verwenden.

Wenn Sie also bereit sind, einen zusätzlichen Dollar auszugeben, empfehlen wir den DHT22 gegenüber dem DHT11.

Wir haben mehrere Anleitungen zur Verwendung der Sensoren DHT11 und DHT22:

• ESP32 (Arduino IDE) mit DHT11/DHT22 Temperatur- und Luftfeuchtigkeitssensor
• ESP8266 (Arduino IDE) DHT11/DHT22 Temperatur- und Luftfeuchtigkeitsweb Server
• Arduino mit DHT11/DHT22 Feuchte- und Temperatursensor
• ESP32/ESP8266 (MicroPython) mit DHT11/DHT22 Web Server

LM35, LM335 und LM34

Die LM35, LM335 und LM34 sind lineare Temperatursensoren, die eine Spannung proportional zum Temperaturwert ausgeben. Der LM35 wird in Celsius-Graden kalibriert, der LM335 in Kelvin und der LM34 in Fahrenheit. Abhängig von den Temperatureinheiten, die Sie in Ihrem Projekt verwenden, könnte einer dieser Sensoren praktischer sein als der andere.

Wir empfehlen, den LM35 oder LM34 anstelle des LM335 zu verwenden, da die Subtraktion einer großen Zahl von den LM335-Messungen, um die Temperatur von Kelvin umzuwandeln, die Genauigkeit der Ergebnisse beeinträchtigen kann.

Nach dem Datenblatt benötigen die LM35- und LM34-Sensoren nur einen sehr geringen Betriebsstrom, etwa 60uA. Dies führt zu einer sehr geringen Selbsterwärmung (ca. 0,08ºC in ruhender Luft), was bedeutet, dass die Temperaturmessungen nicht durch den Sensor selbst beeinträchtigt werden.

Um die Temperatur von diesen Sensoren zu lesen, müssen Sie nur die Ausgangsspannung des Sensors mit einem analogen Pin lesen. Wenn du einen Arduino verwendest, brauchst du nur die Funktion analogRead() zu verwenden, und du erhältst Temperaturwerte mit zwei Dezimalstellen.

Wenn du also einen billigen und einfach zu verwendenden Sensor zur Temperaturüberwachung brauchst, kann der LM35 eine gute Option sein. Da er sehr wenig Energie verbraucht, eignet er sich auch hervorragend für tragbare Projekte, bei denen ein geringer Stromverbrauch erforderlich ist.

Lernen Sie, wie man die LM35, LM335 und LM34 Temperatursensoren mit Arduino verwendet:

• Anleitung für LM35, LM335 und LM34 Temperatursensoren mit Arduino

DS18B20 Temperatursensor

Der DS18B20 Temperatursensor ist ein digitaler Ein-Draht-Temperatursensor. Das bedeutet, dass er nur eine Datenleitung (und GND) benötigt, um mit Ihren Mikrocontrollern zu kommunizieren.

Er kann von einer externen Stromversorgung gespeist werden oder er kann Strom von der Datenleitung ableiten (genannt „parasitärer Modus“), wodurch die Notwendigkeit einer externen Stromversorgung entfällt.

Jeder DS18B20-Temperatursensor hat einen einzigartigen 64-Bit-Seriencode. Dies ermöglicht es Ihnen, mehrere Sensoren an dieselbe Datenleitung anzuschließen. So können Sie die Temperatur von mehreren Sensoren über einen einzigen GPIO abrufen.

Zusätzlich kann die Auflösung des Temperatursensors auf 9, 10, 11 oder 12 Bit eingestellt werden, was einer Schrittweite von 0,5°C, 0,25°C, 0,125°C bzw. 0,0625°C entspricht. Die Standardauflösung beim Einschalten ist 12 Bit.

Der Temperatursensor DS18B20 ist auch in wasserdichter Ausführung erhältlich, ideal für Projekte im Freien oder zur Messung der Temperatur von Flüssigkeiten.

Sie können unseren Anleitungen folgen, um zu lernen, wie man den DS18B20 Temperatursensor mit dem ESP32, ESP8266 und Arduino mit Arduino IDE oder MicroPython verwendet:

• ESP32 (Arduino IDE) DS18B20 Temperatursensor (Single, Multiple, Web Server)
• ESP8266 (Arduino IDE) DS18B20 Temperatursensor (Single, Multiple, Web Server)
• ESP32 und ESP8266 (MicroPython) mit DS18B20 Temperatursensor
• Arduino mit DS18B20 Temperatursensor

BME280 vs BMP180

Der BME280 und der BMP180 sind barometrische Sensoren, das heißt, sie messen den atmosphärischen Druck. Der BME280 ist außerdem mit einem Temperatur- und einem Feuchtigkeitssensor ausgestattet, der BMP180 mit einem Temperatursensor. Da sich der Druck mit der Höhe ändert, können diese Sensoren auch zur Schätzung der Höhe verwendet werden.

Was den Temperaturbereich angeht, so hat der BME280 einen größeren Messbereich: -40 bis 85ºC, während der BMP180 nur von 0 bis 65ºC misst. Sie sollten bedenken, dass sich das BME280-Modul ein wenig selbst erwärmt, so dass die Temperaturmessungen 1 oder 2 Grad über dem tatsächlichen Temperaturwert liegen können.

Der BME280 kann entweder das I2C- oder das SPI-Kommunikationsprotokoll verwenden, während der BMP180 nur die I2C-Kommunikation nutzen kann.

Der BME280-Sensor ist teurer, aber er hat mehr Funktionen. Sie können zum Beispiel ein Wetterstationsprojekt nur mit diesem Sensor bauen. Aber wenn Sie nicht daran interessiert sind, den Druck oder die Luftfeuchtigkeit zu messen, können Sie einen billigeren Temperatursensor bekommen.

Die Anbindung dieser Sensoren an Arduino, ESP8266 und ESP32 ist dank der Adafruit-Bibliotheken sehr einfach.

Sie können unsere Anleitungen verwenden, um zu lernen, wie man diese Sensoren verwendet:

• BMP180:
  • Arduino mit BMP180 Barometric Sensor
  • ESP32 (Arduino IDE) mit BMP180 Barometric Sensor
• BME280:
  • ESP32 (Arduino IDE) mit BME280 Sensor (Druck, Temperatur, Luftfeuchtigkeit)
  • ESP8266 (Arduino IDE) mit BME280 (Druck, Temperatur, Luftfeuchtigkeit)
  • Arduino mit BME280 Sensor(Druck, Temperatur, Luftfeuchtigkeit)

Wir haben auch andere Projekte mit dem BME280, die Ihnen gefallen könnten:

• 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

Dieses Experiment protokolliert Temperaturmesswerte von verschiedenen Temperatursensoren über die Zeit unter den gleichen Bedingungen.

Wir haben alle folgenden Temperatursensoren mit einem Arduino Mega verkabelt:

• DHT11
• DHT22
• LM35
• 2x DS18B20 im gleichen Datenbus
• BME280
• BMP180

Die Daten wurden auf einer microSD-Karte aufgezeichnet. Das Experiment lief etwa 36 Stunden lang, und die Temperaturmesswerte wurden alle 5 Minuten aufgezeichnet.

Wir haben die Datenpins der Temperatursensoren mit den folgenden Pins des Arduino Mega verdrahtet:

• DHT11: Pin 11
• DHT22: Pin 12
• DS18B20: Pin 14
• LM35: Pin A0
• BME280: Software-SPI an diesen Pins: Pin 4 (MISO), Pin 5 (CS), Pin 6 (SCK), Pin 7 (MOSI)
• BMP180: Pin 20 (SDA) und Pin 21 (CSL)

Das microSD-Kartenmodul wurde über Hardware SPI angeschlossen: Pin 51 (MOSI), Pin 50 (MISO), Pin 52 (SCK), Pin 53 (CS).

Dies ist der Code, der im Arduino Mega läuft.

/* * 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);}

Rohcode ansehen

Hinweis: Um diesen Code zu kompilieren und auszuführen, müssen Sie in Ihrer Arduino-IDE alle Sensorbibliotheken installieren, die in der Vergleichstabelle am Anfang dieses Artikels erwähnt werden.

Ergebnisse: Vergleich der Temperaturmesswerte

Nach etwa 36 Stunden haben wir die microSD-Karte entfernt und die Ergebnisse in eine Tabellenkalkulation kopiert. Wir haben alle Messwerte aufgezeichnet, um die Messungen der verschiedenen Temperatursensoren besser vergleichen zu können.

Diese Tabelle hat keine Kontrollgruppe (wir haben keinen kalibrierten Temperatursensor verwendet), aber wir haben eine Vorstellung davon, wie sich diese Sensoren verhalten.

Wenn man sich die Diagramme genauer ansieht, misst der BME280 etwas höhere Werte als die anderen Temperatursensoren. Dieses Verhalten ist normal und wird auch im Datenblatt beschrieben. Das Modul erwärmt sich ein wenig selbst und die Temperaturmessungen können 1 bis 2 Grad über dem tatsächlichen Temperaturwert liegen.

Der BME280 ist aber auch der Temperatursensor, der stabilere Temperaturwerte ohne große Schwankungen zwischen den Messwerten liefert. Das hat mit der Auflösung des Sensors zu tun. Er kann Änderungen bis zu 0,01 ºC erkennen.

Bei den DS18B20-Temperatursensoren können wir einige Schwankungen zwischen den Messwerten feststellen, und es ist auch auffällig, dass die Auflösung nicht so gut ist wie beim BME280. Außerdem war der DS18B20-Temperatursensor der einzige, der während des gesamten Experiments einige „Null“-Messwerte lieferte. Wir haben zwei DS18B20-Temperatursensoren in derselben Datenleitung gemessen, und einer der Sensoren hat während des gesamten Versuchs (innerhalb von 36 Stunden) 6 Mal die Temperatur nicht gemessen.

Der DHT22 und der BMP180 verhalten sich sehr ähnlich und zeigen nur geringe Schwankungen. Der DHT11 konnte kleine Temperaturänderungen nicht erkennen, da seine Auflösung bei 1 ºC liegt.

Der LM35-Temperatursensor schließlich erkannte Temperaturänderungen zwischen 24 ºC und 26 ºC, aber mit vielen Schwankungen zwischen den Messungen.

Dieses Diagramm, das die verschiedenen Temperatursensoren vergleicht, zeigt deutlich, wie sich jeder Sensor von den anderen unterscheidet. Es ist einfacher zu verstehen, wie sie funktionieren und ob sie für die Projekte, die du bauen willst, geeignet sind.

Wrapping Up

In diesem Artikel haben wir verschiedene Temperatursensoren verglichen, die du mit dem ESP32, ESP8266, Arduino und anderen Entwicklungsboards verwenden kannst. Diese Sensoren messen alle die Temperatur, aber sie verhalten sich unterschiedlich, wenn sie in der gleichen Umgebung zur gleichen Zeit getestet werden.

Wir hoffen, dass Sie diesen Artikel nützlich gefunden haben und dass er Ihnen hilft, den besten Temperatursensor für Ihre Projektanforderungen auszuwählen.

Das könnte Ihnen auch gefallen:

• 9 Arduino-kompatible Temperatursensoren für Ihre Elektronikprojekte
• ESP32/ESP8266 Plotten Sie Sensormesswerte in Echtzeitdiagrammen
• Melden Sie sich für unsere Elektronikkurse und unser eBook an