DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Det finns en mängd olika temperatursensorer som är kompatibla med Arduino, ESP32, ESP8266 och andra utvecklingskort. Så det kan vara svårt att välja den mest lämpliga sensorn för ditt projekt. I den här artikeln jämför vi 6 allmänt använda temperatursensorer: DHT11, DHT22, LM35, DS18B20, BME280 och BMP180.

Vi kommer att jämföra sensorerna när det gäller kommunikationsprotokoll, temperaturområde, noggrannhet, användarvänlighet och mycket mer.

Vi kör också ett enkelt experiment där vi mäter temperaturen i samma miljö med alla temperatursensorer över tid. Med detta experiment kunde vi se hur sensorerna reagerar på temperaturförändringar. Vi har kört det här experimentet i ungefär 36 timmar och vi kommer att visa dig resultaten senare i den här artikeln.

Rekommenderad läsning: 9 Arduino-kompatibla temperatursensorer för dina elektronikprojekt

Varje temperaturgivare: DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

För en snabb jämförelse av sensorerna har vi sammanställt följande tabell som visar den viktigaste informationen när det gäller att välja en temperatursensor, nämligen: kommunikationsprotokoll, matningsspänning, temperaturområde och noggrannhet.

Observera: tabellen rullar horisontellt både på stationär dator, surfplatta och mobil.

Sensor	DHT11	DHT22 (AM2302)	LM35	DS18B20	BME280	BMP180
Mätningar	Temperatur Fuktighet	Temperatur Fuktighet	Temperatur	Temperatur	Temperatur	Temperatur Fuktighet Tryck	Temperatur Tryck
Kommunikation protokoll	En-tråd	En tråd	Analog	En tråd	I2C SPI	I2C
Försörjning spänning	3 till 5.5V DC	3 till 6V DC	4 till 30 V DC	3 till 5,5V DC	1,7 till 3,6V (för chipet) 3,3 till 5V för kretskortet	1,8 till 3,6V (för chipet) 3.3 till 5V för kortet
Temperatur område	0 till 50ºC	-40 till 80ºC	-55 till 150ºC	-55 till 125ºC	-40 till 85ºC	0 till 65ºC
Noggrannhet	+/- 2ºC (vid 0 till 50ºC)	+/- 0.5ºC (vid -40 till 80ºC)	+/-0,5ºC (vid 25ºC)	+/-0,5ºC (vid -10 till 85ºC)	+/-0,5ºC (vid 25ºC)	+/-0.5ºC (vid 25ºC)
Stöd (Arduino IDE)	Adafruit DHT-bibliotek 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 (ingår i MicroPython firmware)	dht-modul (ingår i MicroPython firmware)	from machine import ADC ADC().read	ds18b20 module (included in MicroPython firmware)	BME280 Adafruit Library	BMP180 module
Var kan man köpa?	Kontrollera priser	Kontrollera priser	Kontrollera priser	Kontrollera priser Kontrollera priser (vattentät)	Kontrollera priser	Kontrollera priser

DHT11 vs DHT22 (AM2302)

DTH11 och DHT22 (AM2302) är digitala temperatursensorer som mäter temperatur och fuktighet. De ser väldigt lika ut och fungerar på samma sätt, men har olika specifikationer.

Båda sensorerna kan strömförsörjas antingen med 3,3 V eller 5 V. Så du kan enkelt använda dem i dina Arduino- eller ESP-projekt.

DTH22-sensorn har en bättre upplösning och ett större mätområde för temperatur och fuktighet. Den är dock lite dyrare och du kan bara begära avläsningar med 2 sekunders intervall.

DTHT11 är något billigare, den har ett mindre intervall och är mindre exakt. Men du kan få sensoravläsningar varje sekund.

Trots sina skillnader fungerar de på ett liknande sätt och du kan använda samma kod för att läsa av temperatur och luftfuktighet. Du behöver bara välja i koden vilken sensortyp du använder.

Så, om du är villig att spendera en extra dollar rekommenderar vi DHT22 framför DHT11.

Vi har flera guider om hur man använder DHT11- och DHT22-sensorerna:

• ESP32 (Arduino IDE) med DHT11/DHT22 temperatur- och fuktgivare
• ESP8266 (Arduino IDE) DHT11/DHT22 temperatur- och fuktwebb Server
• Arduino med DHT11/DHT22 Fukt- och temperatursensor
• ESP32/ESP8266 (MicroPython) med DHT11/DHT22 Webbserver

LM35, LM335 och LM34

LM35, LM335 och LM34 är linjära temperatursensorer som ger ut en spänning som är proportionell mot temperaturvärdet. LM35 levereras kalibrerad i Celsiusgrader, LM335 i Kelvin och LM34 i Fahrenheit. Så beroende på vilka temperaturenheter du kommer att använda i ditt projekt kan en av dessa sensorer vara mer praktisk än den andra.

Vi rekommenderar att du använder LM35 eller LM34 i stället för LM335, eftersom subtraktion av ett stort antal till LM335-mätningarna för att konvertera temperaturen från Kelvin kan äventyra resultatets noggrannhet.

Enligt databladet kräver LM35- och LM34-sensorerna mycket lite ström för att fungera, cirka 60uA. Detta resulterar i mycket låg självuppvärmning (cirka 0,08ºC i stillastående luft), vilket innebär att temperaturmätningarna inte påverkas av själva sensorn.

För att läsa av temperaturen från dessa sensorer behöver du bara läsa av sensorns utgångsspänning med hjälp av ett analogt stift. Om du använder en Arduino behöver du bara använda funktionen analogRead() och du får temperaturavläsningar med två decimaler.

Så, om du behöver en billig och lättanvänd sensor för att övervaka temperaturen kan LM35 vara ett bra alternativ. Eftersom den förbrukar mycket lite energi är den dessutom utmärkt för bärbara projekt där låg strömförbrukning krävs.

Lär dig att använda temperatursensorerna LM35, LM335 och LM34 med Arduino:

• Guide för LM35, LM335 och LM34 temperatursensorer med Arduino

DS18B20 temperatursensor

Den DS18B20 temperatursensorn är en digital temperaturgivare med en tråd. Det innebär att den bara behöver en datalinje (och GND) för att kommunicera med dina mikrokontroller.

Den kan strömförsörjas av ett externt nätaggregat eller så kan den få ström från datalinjen (så kallat ”parasitläge”), vilket eliminerar behovet av ett externt nätaggregat.

Varje DS18B20-temperatursensor har en unik 64-bitars seriekod. Detta gör det möjligt att koppla flera givare till samma dataledning. Du kan alltså få temperaturen från flera sensorer med hjälp av en enda GPIO.

Temperaturgivarens upplösning kan dessutom ställas in till 9, 10, 11 eller 12 bitar, vilket motsvarar steg på 0,5 °C, 0,25 °C, 0,125 °C respektive 0,0625 °C. Standardupplösningen vid start är 12 bitar.

Temperaturgivaren DS18B20 finns även i vattentät version, idealisk för utomhusprojekt eller för att mäta vätsketemperatur.

Du kan följa våra guider för att lära dig hur du använder DS18B20-temperatursensorn med ESP32, ESP8266 och Arduino med Arduino IDE eller MicroPython:

• ESP32 (Arduino IDE) DS18B20 temperatursensor (enstaka, flera, webbserver)
• ESP8266 (Arduino IDE) DS18B20 temperatursensor (enstaka, flera, Web Server)
• ESP32 och ESP8266 (MicroPython) med DS18B20 temperatursensor
• Arduino med DS18B20 temperatursensor

BME280 vs BMP180

BME280 och BMP180 är barometriska sensorer, vilket innebär att de läser av det atmosfäriska trycket. BME280 är också utrustad med en temperatur- och en luftfuktighetssensor och BMP180 med en temperatursensor. Eftersom trycket förändras med höjden kan dessa sensorer också användas för att uppskatta höjden.

När det gäller temperaturområdet har BME280 ett större mätområde: -40 till 85ºC, medan BMP180 bara mäter från 0 till 65ºC. Du bör komma ihåg att BME280-modulen självvärmer lite grann, så temperaturmätningarna kan ligga 1 eller 2 grader över det verkliga temperaturvärdet.

BME280 kan använda antingen I2C- eller SPI-kommunikationsprotokollet medan BMP180 bara kan använda I2C-kommunikation.

BME280-sensorn är dyrare, men den har fler funktioner. Du kan till exempel bygga ett väderstationsprojekt med endast denna sensor. Men om du inte är intresserad av att mäta tryck eller luftfuktighet kan du skaffa en billigare temperatursensor.

Interfacing dessa sensorer med Arduino, ESP8266 och ESP32 är mycket enkelt tack vare Adafruits bibliotek.

Du kan använda våra guider för att lära dig hur du använder dessa sensorer:

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

Vi har även andra projekt med BME280 som du kanske gillar:

• 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

Det här experimentet loggar temperaturavläsningar från olika temperatursensorer över tiden under samma förhållanden.

Vi kopplade alla följande temperatursensorer till en Arduino Mega:

• DHT11
• DHT22
• LM35
• 2x DS18B20 i samma databuss
• BME280
• BMP180

Data registrerades på ett microSD-kort med en microSD-kortmodul. Experimentet pågick i cirka 36 timmar och temperaturavläsningarna loggades var 5:e minut.

Vi kopplade datapinnarna från temperatursensorerna till följande pinnar på Arduino Mega:

• DHT11: Pin 11
• DHT22: Pin 12
• DS18B20: Pin 14
• LM35: Pin A0
• BME280: programvara SPI på dessa pinnar: 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) och Pin 21 (CSL)

MicroSD-kortmodulen var ansluten via SPI för maskinvara: Pin 51 (MOSI), Pin 50 (MISO), Pin 52 (SCK), Pin 53 (CS).

Detta är koden som körs 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);}

Visa råkod

Observera: för att kunna kompilera och köra den här koden måste du installera alla de sensorbibliotek som nämns i jämförelsetabellen i början av den här artikeln i ditt Arduino IDE.

Resultat: Jämförelse av temperaturavläsningar

Efter cirka 36 timmar tog vi bort microSD-kortet och kopierade resultaten till ett kalkylblad. Vi har plottat alla avläsningar för att bättre kunna jämföra mätningarna från de olika temperatursensorerna.

Detta diagram har ingen kontrollgrupp (vi använde inte en kalibrerad temperaturgivare), men vi har en uppfattning om hur dessa sensorer beter sig.

Om man tittar närmare på diagrammen kan man se att BME280 uppmätte något högre värden än de andra temperatursensorerna. Detta beteende är normalt och detta beskrivs i databladet. Modulen självvärmer lite grann och temperaturmätningarna kan ligga 1 eller 2 grader över det verkliga temperaturvärdet.

BME280 är dock också den temperatursensor som gav mer stabila temperaturmätningar utan många svängningar mellan mätningarna. Detta har att göra med sensorns upplösning. Den kan upptäcka förändringar på upp till 0,01ºC.

I fallet med DS18B20-temperatursensorerna kan vi se en del svängningar mellan avläsningarna och det är också märkbart att upplösningen inte är lika bra som hos BME280. Dessutom var DS18B20-temperatursensorn den enda som gav några ”noll”-avläsningar under hela experimentet. Vi har mätt två DS18B20 temperatursensorer i samma datalinje och en av sensorerna misslyckades med att läsa av temperaturen 6 gånger under hela experimentet (under 36 timmar).

DTH22 och BMP180 beter sig mycket likartat med små svängningar. DHT11 kunde inte upptäcka små temperaturförändringar eftersom dess upplösning är 1ºC.

Till sist upptäckte LM35-temperatursensorn temperaturförändringar mellan 24ºC och 26ºC men med många svängningar mellan mätningarna.

Detta diagram där de olika temperatursensorerna jämförs visar tydligt hur varje sensor skiljer sig från de andra. Det är lättare att förstå hur de fungerar och om de kommer att vara lämpliga för de projekt du vill bygga.

Vidare

I den här artikeln har vi jämfört flera temperatursensorer som du kan använda med ESP32, ESP8266, Arduino och andra utvecklingskort. Dessa sensorer mäter alla temperatur, men de beter sig olika när de sätts på prov i samma miljö vid samma tidpunkt.

Vi hoppas att du fann den här artikeln användbar och att den hjälper dig att välja den bästa temperatursensorn för dina projektkrav.

Du kanske också gillar att läsa:

• 9 Arduino-kompatibla temperatursensorer för dina elektronikprojekt
• ESP32/ESP8266 Plottar sensoravläsningar i diagram i realtid
• Inskriver dig i våra elektronikkurser och e-böcker