DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Der findes et bredt udvalg af temperatursensorer, der er kompatible med Arduino, ESP32, ESP8266 og andre udviklingskort. Så det kan være svært at vælge den bedst egnede sensor til dit projekt. I denne artikel sammenligner vi 6 almindeligt anvendte temperatursensorer: DHT11, DHT22, LM35, DS18B20, BME280 og BMP180.

Vi sammenligner sensorerne, når det kommer til kommunikationsprotokol, temperaturområde, nøjagtighed, brugervenlighed og meget mere.

Vi kører også et simpelt eksperiment, hvor vi måler temperaturen i det samme miljø ved hjælp af alle temperatursensorer over tid. Med dette eksperiment kunne vi se, hvordan sensorerne reagerer på temperaturændringer. Vi har kørt dette eksperiment i ca. 36 timer, og vi vil vise dig resultaterne senere i denne artikel.

Anbefalet læsning: 9 Arduino-kompatible temperatursensorer til dine elektronikprojekter

Sammenligning af temperatursensorer: For en hurtig sammenligning af sensorerne har vi sammensat følgende tabel, der viser de vigtigste oplysninger, når det kommer til at vælge en temperatursensor, nemlig: kommunikationsprotokol, forsyningsspænding, temperaturområde og nøjagtighed.

Bemærk: Tabellen ruller vandret både på stationær computer, tablet og mobil.

Sensor	DHT11	DHT22 (AM2302)	LM35	DS18B20	BME280	BMP180
Måler	Temperatur Fugtighed	Temperatur Fugtighed	Temperatur	Temperatur	Temperatur	Temperatur Fugtighed Tryk	Temperatur Tryk	Temperatur Tryk
Kommunikation protokol	En-wire	En-tråd	Analog	En-tråd	I2C SPI	I2C
Forsyning Spænding	3 til 5.5V DC	3 til 6V DC	4 til 30 V DC	3 til 5,5V DC	1,7 til 3,6V (til chippen) 3,3 til 5V til kortet	1,8 til 3,6V (til chippen) 3.3 til 5V til kortet
Temperatur interval	0 til 50ºC	-40 til 80ºC	-55 til 150ºC	-55 til 125 ºC	-40 til 85 ºC	0 til 65 ºC
Nøjagtighed	+/- 2 ºC (ved 0 til 50 ºC)	+/- 0.5ºC (ved -40 til 80ºC)	+/-0,5ºC (ved 25ºC)	+/-0,5ºC (ved -10 til 85ºC)	+/-0,5ºC (ved 25ºC)	+/-0,5ºC (ved 25ºC)	+/-0.5ºC (ved 25ºC)
Support (Arduino IDE)	Adafruit DHT Library Adafruit Unified Sensor Library	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-modul (indgår i MicroPython-firmware)	dht-modul (indgår i MicroPython-firmware)	from machine import ADC ADC().read	ds18b20 modul (indgår i MicroPython firmware)	BME280 Adafruit Library	BMP180 modul
Hvor kan jeg købe?	Tjek priser	Tjek priser	Tjek priser	Tjek priser	Tjek priser Tjek priser (vandtæt)	Tjek priser	Tjek priser

DHT11 vs DHT22 (AM2302)

DHT11 og DHT22 (AM2302) er digitale temperatursensorer, der måler temperatur og luftfugtighed. De ser meget ens ud og fungerer på samme måde, men har forskellige specifikationer.

Både sensorer kan forsynes med strøm enten med 3,3 V eller 5 V. Så du kan nemt bruge dem i dine Arduino- eller ESP-projekter.

DTHT22-sensoren har en bedre opløsning og et bredere temperatur- og fugtighedsmåleområde. Den er dog lidt dyrere, og du kan kun anmode om aflæsninger med 2 sekunders interval.

DTHT11 er lidt billigere, den har et mindre område, og den er mindre præcis. Men du kan få sensoraflæsninger hvert sekund.

Trods deres forskelle fungerer de på samme måde, og du kan bruge den samme kode til at aflæse temperatur og luftfugtighed. Du skal blot i koden vælge den sensortype, du bruger.

Så hvis du er villig til at bruge en ekstra dollar, anbefaler vi DHT22 frem for DHT11.

Vi har flere vejledninger om, hvordan du bruger DHT11- og DHT22-sensorerne:

• ESP32 (Arduino IDE) med DHT11/DHT22 temperatur- og fugtighedssensor
• ESP8266 (Arduino IDE) DHT11/DHT22 temperatur- og fugtighedssensor
• ESP8266 (Arduino IDE) DHT11/DHT22 temperatur- og fugtighedsweb Server
• Arduino med DHT11/DHT22 Fugt- og temperatursensor
• ESP32/ESP8266 (MicroPython) med DHT11/DHT22 Webserver

LM35, LM335 og LM34

LM35, LM335 og LM34 er lineære temperatursensorer, der udsender en spænding, der er proportional med temperaturværdien. LM35 leveres kalibreret i Celsius-grader, LM335 i Kelvin og LM34 i Fahrenheit. Så afhængigt af de temperaturenheder, du vil bruge i dit projekt, kan en af disse sensorer være mere praktisk end den anden.

Vi anbefaler at bruge LM35 eller LM34 i stedet for LM335, fordi det at trække et stort tal fra LM335-målingerne for at konvertere temperaturen fra Kelvin kan gå ud over resultaternes nøjagtighed.

I henhold til databladet kræver LM35- og LM34-sensorerne meget lidt strøm for at fungere, ca. 60uA. Dette resulterer i meget lav selvopvarmning (ca. 0,08ºC i stillestående luft), hvilket betyder, at temperaturmålingerne ikke vil blive påvirket af selve sensoren.

For at aflæse temperaturen fra disse sensorer skal du blot aflæse sensorens udgangsspænding ved hjælp af en analog pin. Hvis du bruger en Arduino, skal du blot bruge funktionen analogRead(), og du får temperaturmålinger med to decimaler.

Så hvis du har brug for en billig og let anvendelig sensor til at overvåge temperaturen, kan LM35 være et godt alternativ. Fordi den bruger meget lidt energi, er den også god til bærbare projekter, hvor der kræves et lavt strømforbrug.

Lær hvordan du bruger LM35, LM335 og LM34 temperatursensorerne med Arduino:

• Guide til LM35, LM335 og LM34 temperatursensorer med Arduino

DS18B20 temperatursensor

Den DS18B20 temperatursensor er en digital temperaturføler med én ledning. Det betyder, at den kun har brug for én datalinje (og GND) for at kommunikere med dine mikrocontrollere.

Den kan forsynes med strøm fra en ekstern strømforsyning, eller den kan få strøm fra datalinjen (kaldet “parasittilstand”), hvilket eliminerer behovet for en ekstern strømforsyning.

Hver DS18B20-temperatursensor har en unik 64-bit seriel kode. Dette giver dig mulighed for at tilslutte flere sensorer til den samme dataledning. Så du kan få temperatur fra flere sensorer ved hjælp af en enkelt GPIO.

Dertil kommer, at opløsningen af temperatursensoren kan indstilles til 9, 10, 11 eller 12 bit, hvilket svarer til intervaller på henholdsvis 0,5 °C, 0,25 °C, 0,125 °C og 0,0625 °C. Standardopløsningen ved opstart er 12 bit.

Des DS18B20-temperatursensor fås også i vandtæt version, der er ideel til udendørs projekter eller til måling af væsketemperatur.

Du kan følge vores vejledninger for at lære, hvordan du bruger DS18B20-temperatursensoren sammen med ESP32, ESP8266 og Arduino ved hjælp af Arduino IDE eller MicroPython:

• ESP32 (Arduino IDE) DS18B20 Temperatursensor (enkelt, flere, webserver)
• ESP8266 (Arduino IDE) DS18B20 Temperatursensor (enkelt, flere, webserver)
• ESP8266 (Arduino IDE) DS18B20 Temperatursensor (enkelt, flere, Webserver)
• ESP32 og ESP8266 (MicroPython) med DS18B20 Temperatursensor
• Arduino med DS18B20 Temperatursensor

BME280 vs. BMP180

BME280 og BMP180 er barometriske sensorer, hvilket betyder, at de aflæser atmosfærisk tryk. BME280 er også udstyret med en temperatur- og en fugtighedssensor, og BMP180 er udstyret med en temperatursensor. Da trykket ændrer sig med højden, kan disse sensorer også bruges til at estimere højden.

Når det kommer til temperaturområdet, har BME280 et større måleområde: -40 til 85ºC, mens BMP180 kun måler fra 0 til 65ºC. Du skal huske på, at BME280-modulet selvopvarmer en smule, så temperaturmålingerne kan ligge 1 eller 2 grader over den reelle temperaturværdi.

BME280 kan bruge enten I2C- eller SPI-kommunikationsprotokol, mens BMP180 kun kan bruge I2C-kommunikation.

BME280-sensoren er dyrere, men den har flere funktionaliteter. Du kan f.eks. bygge et vejrstationsprojekt med kun denne sensor. Men hvis du ikke er interesseret i at måle tryk eller luftfugtighed, kan du få en billigere temperatursensor.

Interfacering af disse sensorer med Arduino, ESP8266 og ESP32 er meget let takket være Adafruit-bibliotekerne.

Du kan bruge vores vejledninger til at lære at bruge disse sensorer:

• BMP180:
  • Arduino med BMP180 barometrisk sensor
  • ESP32 (Arduino IDE) med BMP180 barometrisk sensor
• BME280:
  • ESP32 (Arduino IDE) med BME280-sensor (tryk, temperatur, fugtighed)
  • ESP8266 (Arduino IDE) med BME280 (tryk, temperatur, fugtighed)
  • Arduino med BME280-sensor(tryk, temperatur, fugtighed)

Vi har også andre projekter med BME280, som du måske vil kunne lide:

• 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

Dette eksperiment loggede temperaturmålinger fra forskellige temperatursensorer over tid under de samme forhold.

Vi koblede alle følgende temperatursensorer til en Arduino Mega:

• DHT11
• DHT22
• LM35
• 2x DS18B20 i samme databus
• BME280
• BMP180

Dataene blev optaget på et microSD-kort ved hjælp af et microSD-kortmodul. Forsøget kørte i ca. 36 timer, og temperaturmålingerne blev logget hvert 5. minut.

Vi tilsluttede temperatursensorernes datastifter til følgende stifter på Arduino Mega:

• DHT11: Stift 11
• DHT22: Stift 12
• DS18B20: Stift 14
• LM35: Stift A0
• BME280: software SPI på disse stifter: Pin 4 (MISO), Pin 5 (CS), Pin 6 (SCK), Pin 7 (MOSI)
• BMP180: Pin 4 (MISO), Pin 5 (CS), Pin 6 (SCK), Pin 7 (MOSI)
• BMP180: Pin 4 (MISO), Pin 5 (CS), Pin 6 (SCK), Pin 7 (MOSI): Pin 20 (SDA) og Pin 21 (CSL)

MicroSD-kortmodulet blev tilsluttet via hardware-SPI: Pin 51 (MOSI), Pin 50 (MISO), Pin 52 (SCK), Pin 53 (CS).

Dette er koden, der kører i 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);}

Se råkode

Bemærk: For at kunne kompilere og køre denne kode skal du installere alle de sensorbiblioteker, der er nævnt i sammenligningstabellen i begyndelsen af denne artikel, i dit Arduino IDE.

Resultater:

Resultater:: For at kunne kompilere og køre denne kode skal du installere alle de sensorbiblioteker, der er nævnt i sammenligningstabellen i starten af denne artikel, i dit Arduino IDE.

Sammenligning af temperaturmålinger

Efter ca. 36 timer fjernede vi microSD-kortet og kopierede resultaterne til et regneark. Vi har plottet alle aflæsninger for bedre at kunne sammenligne målingerne fra de forskellige temperatursensorer.

Dette diagram har ikke en kontrolgruppe (vi har ikke brugt en kalibreret temperatursensor), men vi har en idé om, hvordan disse sensorer opfører sig.

Hvis man kigger nærmere på diagrammerne, målte BME280 lidt højere værdier end de andre temperatursensorer. Denne adfærd er normal, og det er beskrevet i databladet. Modulet selvopvarmer en smule, og temperaturmålingerne kan ligge 1 ou 2 grader over den reelle temperaturværdi.

BME280 er imidlertid også den temperatursensor, der gav mere stabile temperaturmålinger uden mange svingninger mellem målingerne. Dette har at gøre med opløsningen af sensoren. Den kan registrere ændringer på op til 0,01ºC.

For DS18B20-temperatursensorerne kan vi se nogle svingninger mellem aflæsningerne, og det er også mærkbart, at opløsningen ikke er lige så god som BME280’s. Desuden var DS18B20-temperatursensoren den eneste, der gav nogle “nul”-aflæsninger i hele forsøget. Vi har målt to DS18B20-temperatursensorer i den samme datalinje, og den ene af sensorerne undlod at aflæse temperaturen 6 gange i løbet af forsøget (i løbet af 36 timer).

DHT22 og BMP180 opfører sig meget ens med få svingninger. DHT11 kunne ikke registrere små temperaturændringer, fordi dens opløsning er på 1ºC.

Til sidst registrerede LM35-temperatursensoren ændringer i temperaturen mellem 24ºC og 26ºC, men med mange svingninger mellem målingerne.

Dette diagram, der sammenligner de forskellige temperatursensorer, viser tydeligt, hvordan hver sensor adskiller sig fra de andre. Det er lettere at forstå, hvordan de fungerer, og om de vil være velegnede til de projekter, du ønsker at bygge.

Afslutning

I denne artikel har vi sammenlignet flere temperatursensorer, som du kan bruge sammen med ESP32, ESP8266, Arduino og andre udviklingskort. Disse sensorer måler alle temperatur, men de opfører sig forskelligt, når de sættes på prøve i det samme miljø på samme tid.

Vi håber, at du har fundet denne artikel nyttig, og at den hjælper dig med at vælge den bedste temperatursensor til dine projektkrav.

Du vil måske også kunne lide at læse:

• 9 Arduino-kompatible temperatursensorer til dine elektronikprojekter
• ESP32/ESP8266 Plot sensoraflæsninger i realtidsdiagrammer
• Indskriv dig i vores elektronikkurser og e-bøger