DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Existe uma grande variedade de sensores de temperatura compatíveis com Arduino, ESP32, ESP8266 e outras placas de desenvolvimento. Portanto, pode ser difícil captar o sensor mais adequado para o seu projecto. Neste artigo, vamos comparar 6 sensores de temperatura amplamente utilizados: DHT11, DHT22, LM35, DS18B20, BME280 e BMP180.

Compararemos os sensores quando se trata de protocolo de comunicação, faixa de temperatura, precisão, facilidade de uso e muito mais.

Também realizamos uma experiência simples na qual medimos a temperatura no mesmo ambiente usando todos os sensores de temperatura ao longo do tempo. Com este experimento pudemos ver como os sensores reagem às mudanças de temperatura. Fizemos este experimento por aproximadamente 36 horas e mostraremos os resultados mais tarde neste artigo.

Leitura recomendada: 9 Sensores de Temperatura Compatíveis com Arduino para seus Projetos Eletrônicos

Comparação de Sensores de Temperatura: DHT11 vs DHT22 vs LM35 vs DS18B20 vs DS18B20 vs BME280 vs BMP180

Para uma rápida comparação dos sensores, reunimos a seguinte tabela que mostra a informação mais importante quando se trata de seleccionar um sensor de temperatura, nomeadamente: protocolo de comunicação, tensão de alimentação, gama de temperaturas e precisão.

Nota: a tabela desloca-se horizontalmente tanto no computador de secretária, tablet como no telemóvel.


Sensor	DHT11	DHT22 (AM2302)	LM35	DS18B20	BME280	BMP180
Medidas	Temperatura Umidade	Temperatura Umidade	Temperatura	Temperatura	Temperatura Umidade Pressão	Temperatura Pressão
Comunicação Protocolo	Um-fio	Um fio	Análogo	Um fio	I2C SPI	I2C
Suprimento tensão	3 a 5.5V DC	3 a 6V DC	4 a 30V DC	3 a 5,5V DC	1,7 a 3,6V (para o chip) 3,3 a 5V para a placa	1,8 a 3,6V (para o chip) 3.3 a 5V para a placa
Temperatura amplitude	0 a 50ºC	-40 a 80ºC	-55 a 150ºC	-55 a 125ºC	-40 a 85ºC	0 a 65ºC
Acurácia	+/- 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)
Suporte (Arduino IDE)	Adafruit DHT Library Adafruit Unified Sensor Library	Adafruit DHT Library Adafruit Unified Sensor Library	analogRead()	DallasTemperature OneWire	Adafruit BME280 biblioteca Adafruit Unified Sensor Library	Adafruit BME085 Adafruit Unified Sensor Library
Suporte (MicroPython)	módulo dht (incluído no firmware MicroPython)	módulo dht (incluído no firmware MicroPython)	de importação da máquina ADC ADC().read	módulo ds18b20 (incluído no firmware MicroPython)	BME280 Adafruit Library	BMP180 módulo
Onde comprar?	Verifica os preços	Verifica os preços	Verifica os preços	Verifica os preços Verifica os preços (à prova de água)	Verifica os preços	Verifica os preços

DHT11 vs DHT22 (AM2302)

DHT11 vs DHT22 Sensor de Temperatura e Humidade

O DHT11 e DHT22 (AM2302) são sensores digitais de temperatura que medem temperatura e humidade. Parecem muito semelhantes e funcionam da mesma forma, mas têm especificações diferentes.

Bambos sensores podem ser alimentados tanto com 3.3V como com 5V. Portanto, você pode usá-los facilmente em seus projetos Arduino ou ESP.

O sensor DHT22 tem uma melhor resolução e uma faixa maior de medição de temperatura e umidade. No entanto, é um pouco mais caro e só pode solicitar leituras com intervalo de 2 segundos.

O DHT11 é ligeiramente mais barato, tem um intervalo menor, e é menos preciso. Mas você pode obter leituras de sensor a cada segundo.

Embora suas diferenças, elas funcionam de forma semelhante, e você pode usar o mesmo código para ler a temperatura e a umidade. Você só precisa selecionar no código o tipo de sensor que você está usando.

Então, se você estiver disposto a gastar um dólar extra, recomendamos o DHT22 sobre o DHT11.

Temos vários guias sobre como usar os sensores DHT11 e DHT22:

ESP32 (Arduino IDE) com sensor de temperatura e humidade DHT11/DHT22
ESP8266 (Arduino IDE) DHT11/DHT22 Web de temperatura e humidade Servidor
Arduino com DHT11/DHT22 Sensor de Umidade e Temperatura
ESP32/ESP8266 (MicroPython) com DHT11/DHT22 Servidor Web

LM35, LM335 e LM34

Os LM35, LM335 e LM34 são sensores lineares de temperatura que emitem uma tensão proporcional ao valor da temperatura. A LM35 vem calibrada em graus Celsius, a LM335 em Kelvin e a LM34 em Fahrenheit. Portanto, dependendo das unidades de temperatura que você vai usar no seu projeto, um desses sensores pode ser mais prático do que o outro.

Recomendamos usar a LM35 ou LM34 em vez da LM335, porque subtraindo um grande número às medições da LM335 para converter a temperatura de Kelvin pode comprometer a precisão dos resultados.

De acordo com a folha de dados, os sensores LM35 e LM34 requerem muito pouca corrente para operar, cerca de 60uA. Isto resulta num auto-aquecimento muito baixo (cerca de 0,08ºC em ar parado), o que significa que as medições de temperatura não serão afectadas pelo próprio sensor.

Para ler a temperatura destes sensores basta ler a tensão de saída do sensor usando um pino analógico. Se usar um Arduino, você só precisa usar a função analogRead() e você obterá leituras de temperatura com dois pontos decimais.

Então, se você precisar de um sensor barato e fácil de usar para monitorar a temperatura, a LM35 pode ser uma boa opção. Além disso, por consumir muito pouca energia, é ótimo para projetos portáteis, onde é necessário um baixo consumo de energia.

Saiba como usar os sensores de temperatura LM35, LM335 e LM34 com Arduino:

Guia para os sensores de temperatura LM35, LM335 e LM34 com Arduino

DS18B20 Sensor de temperatura

O sensor de temperatura DS18B20 é um sensor de temperatura digital de um fio. Isto significa que apenas necessita de uma linha de dados (e GND) para comunicar com os seus microcontroladores.

Pode ser alimentado por uma fonte de alimentação externa ou pode derivar energia da linha de dados (chamado “modo parasita”), o que elimina a necessidade de uma fonte de alimentação externa.

Cada sensor de temperatura DS18B20 tem um código de série único de 64 bits. Isto permite ligar vários sensores ao mesmo fio de dados. Assim, você pode obter a temperatura de vários sensores usando um único GPIO.

Adicionalmente, a resolução do sensor de temperatura pode ser ajustada para 9, 10, 11, ou 12 bits, o que corresponde a incrementos de 0,5°C, 0,25°C, 0,125°C, e 0,0625°C, respectivamente. A resolução padrão na energização é de 12 bits.

O sensor de temperatura DS18B20 também está disponível na versão à prova de água, ideal para projectos ao ar livre ou para medir a temperatura do líquido.

DS18B20 Sensor de temperatura à prova de água

Pode seguir os nossos guias para aprender a utilizar o sensor de temperatura DS18B20 com o ESP32, ESP8266 e Arduino utilizando o Arduino IDE ou MicroPython:

ESP32 (Arduino IDE) Sensor de temperatura DS18B20 (Único, Múltiplo, Servidor Web)
ESP8266 (Arduino IDE) Sensor de temperatura DS18B20 (Único, Múltiplo, Servidor Web)
ESP32 e ESP8266 (MicroPython) com Sensor de Temperatura DS18B20
Arduino com Sensor de Temperatura DS18B20

BME280 vs BMP180

O BME280 e o BMP180 são sensores barométricos, o que significa que lêem a pressão atmosférica. O BME280 também é equipado com um sensor de temperatura e umidade, e o BMP180 com um sensor de temperatura. Como a pressão muda com a altitude, estes sensores também podem ser usados para estimar a altitude.

Quando se trata de faixa de temperatura, o BME280 tem uma faixa de medição mais ampla: -40 a 85ºC, enquanto o BMP180 mede apenas de 0 a 65ºC. Você deve ter em mente que o módulo BME280 se autoaquece um pouco, assim as medições de temperatura podem estar 1 ou 2 graus acima do valor real da temperatura.

O BME280 pode usar tanto o protocolo de comunicação I2C ou SPI enquanto o BMP180 só pode usar comunicação I2C.

O sensor BME280 é mais caro, mas tem mais funcionalidades. Por exemplo, você pode construir um projeto de estação meteorológica apenas com este sensor. Mas se você não estiver interessado em medir a pressão ou umidade, você pode obter um sensor de temperatura mais barato.

Interfacing estes sensores com Arduino, ESP8266 e ESP32 é muito fácil, graças às bibliotecas Adafruit.

Pode usar os nossos guias para aprender a usar estes sensores:

BMP180:
- Arduino com Sensor Barométrico BMP180
- ESP32 (Arduino IDE) com Sensor Barométrico BMP180
BME280:
- ESP32 (Arduino IDE) com Sensor BME280 (Pressão, Temperatura, Umidade)
- ESP8266 (Arduino IDE) com BME280 (Pressão, Temperatura, Umidade)
- Arduino com Sensor BME280 (Pressão, Temperatura, Umidade)

Também temos outros projetos com o BME280 que você pode gostar:

Low Power Weather Station Datalogger usando ESP8266 e BME280 com MicroPython
ESP32 Web Server com BME280 – Mini Weather Station
ESP32/ESP8266 Inserir dados no banco de dados MySQL usando PHP e Arduino IDE

Testar todos os sensores de temperatura

Esta experiência registrou leituras de temperatura de diferentes sensores de temperatura ao longo do tempo nas mesmas condições.

Testamos todos os seguintes sensores de temperatura com um Arduino Mega:

DHT11
DHT22
LM35
2x DS18B20 no mesmo bus de dados
BME280
BMP180

Os dados foram gravados num cartão microSD usando um módulo de cartão microSD. O experimento durou aproximadamente 36 horas e as leituras de temperatura foram registradas a cada 5 minutos.

Ligamos os pinos de dados dos sensores de temperatura aos seguintes pinos no Arduino Mega:

DHT11: Pino 11
DHT22: Pino 12
DS18B20: Pino 14
LM35: Pino A0
BME280: software SPI nestes pinos: Pino 4 (MISO), Pino 5 (CS), Pino 6 (SCK), Pino 7 (MOSI)
BMP180: Pino 20 (SDA) e Pino 21 (CSL)

O módulo de cartão microSD foi conectado via hardware SPI: Pino 51 (MOSI), Pino 50 (MISO), Pino 52 (SCK), Pino 53 (CS).

Este é o código que corre no 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);}

Ver código raw

Nota: para compilar e correr este código, deve instalar na sua IDE Arduino todas as bibliotecas de sensores mencionadas na tabela de comparação no início deste artigo.

Resultados: Comparando leituras de temperatura

Após aproximadamente 36 horas, removemos o cartão microSD e copiamos os resultados para uma planilha de cálculo. Traçamos todas as leituras para melhor comparar as medições dos diferentes sensores de temperatura.

Resultados em graus Celsius Sensores de Temperatura DHT11 DHT22 LM35 DS18B20 BME280 BMP180 com Arduino — Temperatura em graus Celsius (ºC)

Resultados em graus Fahrenheit Sensores de Temperatura DHT11 DHT22 LM35 DS18B20 BME280 BMP180 com Arduino — Temperatura em graus Fahrenheit (ºF)

Esta tabela não tem um grupo de controle (não usamos um sensor de temperatura calibrado), mas temos uma ideia de como estes sensores se comportam.

Se você olhar mais de perto para os gráficos, o BME280 mediu valores ligeiramente superiores aos dos outros sensores de temperatura. Este comportamento é normal, e isto está descrito na folha de dados. O módulo autoaquece um pouco e as medições de temperatura podem estar 1 ou 2 graus acima do valor real da temperatura.

No entanto, o BME280 é também o sensor de temperatura que deu leituras de temperatura mais estáveis, sem muitas oscilações entre as leituras. Isto tem a ver com a resolução do sensor. Ele pode detectar alterações até 0.01ºC.

No caso dos sensores de temperatura DS18B20, podemos ver algumas oscilações entre as leituras e também é perceptível que a resolução não é tão boa quanto a do BME280. Além disso, o sensor de temperatura DS18B20 foi o único a dar algumas leituras “nulas” ao longo da experiência. Medimos dois sensores de temperatura DS18B20 na mesma linha de dados e um dos sensores não conseguiu ler a temperatura 6 vezes ao longo do experimento (durante 36 horas).

O DHT22 e o BMP180 comportam-se de forma muito semelhante com pequenas oscilações. O DHT11 não conseguiu detectar pequenas variações de temperatura, pois sua resolução é de 1ºC.

Finalmente, o sensor de temperatura LM35 detectou variações de temperatura entre 24ºC e 26ºC mas com muitas oscilações entre as medições.

Este gráfico comparando os diferentes sensores de temperatura mostra claramente como cada sensor difere dos outros. É mais fácil compreender como funcionam e se serão adequados para os projectos que pretende construir.

Embrulhamento

Neste artigo comparamos vários sensores de temperatura que pode utilizar com o ESP32, ESP8266, Arduino e outras placas de desenvolvimento. Todos estes sensores medem a temperatura mas comportam-se de forma diferente quando colocados à prova no mesmo ambiente ao mesmo tempo.

Esperamos que tenha achado este artigo útil e que o ajude a escolher o melhor sensor de temperatura para os requisitos do seu projecto.