DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Existe una amplia variedad de sensores de temperatura compatibles con Arduino, ESP32, ESP8266 y otras placas de desarrollo. Por eso, puede resultar difícil elegir el sensor más adecuado para tu proyecto. En este artículo compararemos 6 sensores de temperatura de uso extendido: DHT11, DHT22, LM35, DS18B20, BME280 y BMP180.

Compararemos los sensores en cuanto a protocolo de comunicación, rango de temperatura, exactitud, facilidad de uso y mucho más.

También realizamos un experimento sencillo en el que medimos la temperatura en el mismo entorno usando todos los sensores a lo largo del tiempo. Con este experimento pudimos ver cómo reaccionan los sensores a los cambios de temperatura. Ejecutamos este experimento durante aproximadamente 36 horas y más adelante en este artículo te mostraremos los resultados.

Lectura recomendada: 9 sensores de temperatura compatibles con Arduino para tus proyectos de electrónica

Comparando sensores de temperatura: DHT11 vs DHT22 vs LM35 vs DS18B20 vs BME280 vs BMP180

Para una comparación rápida de los sensores, hemos preparado la siguiente tabla que muestra la información más importante a la hora de seleccionar un sensor de temperatura, a saber: protocolo de comunicación, voltaje de alimentación, rango de temperatura y exactitud.

Nota: la tabla se desplaza horizontalmente tanto en computadora de escritorio como en tableta y móvil.

DHT11 vs DHT22 (AM2302)

El DHT11 y el DHT22 (AM2302) son sensores digitales de temperatura que miden temperatura y humedad. Se ven muy parecidos y funcionan de la misma forma, pero tienen especificaciones diferentes.

Ambos sensores pueden alimentarse ya sea con 3.3V o 5V. Así que puedes usarlos fácilmente en tus proyectos con Arduino o ESP.

El sensor DHT22 tiene mejor resolución y un rango de medición de temperatura y humedad más amplio. Sin embargo, es un poco más caro y solo puedes solicitar lecturas con un intervalo de 2 segundos.

El DHT11 es ligeramente más barato, tiene un rango menor y es menos exacto. Pero puedes obtener lecturas del sensor cada segundo.

A pesar de sus diferencias, funcionan de forma similar y puedes usar el mismo código para leer temperatura y humedad. Solo necesitas seleccionar en el código el tipo de sensor que estás usando.

Así que, si estás dispuesto a gastar un dólar extra, recomendamos el DHT22 sobre el DHT11.

Tenemos varias guías sobre cómo usar los sensores DHT11 y DHT22:

• ESP32 (Arduino IDE) con sensor de temperatura y humedad DHT11/DHT22
• ESP8266 (Arduino IDE) servidor web de temperatura y humedad DHT11/DHT22
• Arduino con sensor de humedad y temperatura DHT11/DHT22
• ESP32/ESP8266 (MicroPython) con servidor web DHT11/DHT22

LM35, LM335 y LM34

El LM35, el LM335 y el LM34 son sensores de temperatura lineales que entregan un voltaje proporcional al valor de temperatura. El LM35 viene calibrado en grados Celsius, el LM335 en Kelvin y el LM34 en Fahrenheit. Así que, dependiendo de las unidades de temperatura que uses en tu proyecto, uno de estos sensores podría ser más práctico que el otro.

Recomendamos usar el LM35 o el LM34 en lugar del LM335, porque restar un número grande a las mediciones del LM335 para convertir la temperatura desde Kelvin puede comprometer la exactitud de los resultados.

Según la hoja de datos, los sensores LM35 y LM34 requieren muy poca corriente para operar, unos 60uA. Esto se traduce en un autocalentamiento muy bajo (alrededor de 0.08ºC en aire quieto), lo que significa que las mediciones de temperatura no se verán afectadas por el propio sensor.

Para leer la temperatura de estos sensores solo necesitas leer el voltaje de salida del sensor usando un pin analógico. Si usas un Arduino, solo necesitas usar la función analogRead() y obtendrás lecturas de temperatura con dos decimales.

Así que, si necesitas un sensor barato y fácil de usar para monitorear temperatura, el LM35 puede ser una buena opción. Además, como consume muy poca energía, es ideal para proyectos portátiles, donde se requiere bajo consumo de energía.

Aprende a usar los sensores de temperatura LM35, LM335 y LM34 con Arduino:

• Guía de los sensores de temperatura LM35, LM335 y LM34 con Arduino

Sensor de temperatura DS18B20

El sensor de temperatura DS18B20 es un sensor de temperatura digital one-wire. Esto significa que solo requiere una línea de datos (y GND) para comunicarse con tus microcontroladores.

Puede alimentarse mediante una fuente de alimentación externa o puede obtener energía de la línea de datos (llamado “modo parásito”), lo que elimina la necesidad de una fuente de alimentación externa.

Cada sensor de temperatura DS18B20 tiene un código serial único de 64 bits. Esto te permite cablear múltiples sensores a la misma línea de datos. Así que puedes obtener temperatura de varios sensores usando un solo GPIO.

Además, la resolución del sensor de temperatura puede configurarse a 9, 10, 11 o 12 bits, lo que corresponde a incrementos de 0.5°C, 0.25°C, 0.125°C y 0.0625°C, respectivamente. La resolución predeterminada al encender es de 12 bits.

El sensor de temperatura DS18B20 también está disponible en versión a prueba de agua, ideal para proyectos al aire libre o para medir la temperatura de líquidos.

Puedes seguir nuestras guías para aprender a usar el sensor de temperatura DS18B20 con el ESP32, ESP8266 y Arduino usando Arduino IDE o MicroPython:

• ESP32 (Arduino IDE) sensor de temperatura DS18B20 (único, múltiple, servidor web)
• ESP8266 (Arduino IDE) sensor de temperatura DS18B20 (único, múltiple, servidor web)
• ESP32 y ESP8266 (MicroPython) con sensor de temperatura DS18B20
• Arduino con sensor de temperatura DS18B20

BME280 vs BMP180

El BME280 y el BMP180 son sensores barométricos, lo que significa que leen la presión atmosférica. El BME280 también está equipado con un sensor de temperatura y uno de humedad, y el BMP180 con un sensor de temperatura. Como la presión cambia con la altitud, estos sensores también pueden usarse para estimar la altitud.

En cuanto al rango de temperatura, el BME280 tiene un rango de medición más amplio: -40 a 85ºC, mientras que el BMP180 solo mide de 0 a 65ºC. Debes tener en cuenta que el módulo BME280 se autocalienta un poco, así que las mediciones de temperatura pueden estar 1 o 2 grados por encima del valor real de temperatura.

El BME280 puede usar el protocolo de comunicación I2C o SPI, mientras que el BMP180 solo puede usar comunicación I2C.

El sensor BME280 es más caro pero tiene más funcionalidades. Por ejemplo, puedes construir un proyecto de estación meteorológica solo con este sensor. Pero si no te interesa medir la presión o la humedad, puedes optar por un sensor de temperatura más barato.

Conectar estos sensores con Arduino, ESP8266 y ESP32 es muy fácil gracias a las librerías de Adafruit.

Puedes usar nuestras guías para aprender a usar estos sensores:

• BMP180:
  • Arduino con el sensor barométrico BMP180
  • ESP32 (Arduino IDE) con el sensor barométrico BMP180
• BME280:
  • ESP32 (Arduino IDE) con el sensor BME280 (presión, temperatura, humedad)
  • ESP8266 (Arduino IDE) con BME280 (presión, temperatura, humedad)
  • Arduino con el sensor BME280 (presión, temperatura, humedad)

También tenemos otros proyectos con el BME280 que quizás te gusten:

• Datalogger de estación meteorológica de bajo consumo usando ESP8266 y BME280 con MicroPython
• Servidor web ESP32 con BME280 – Mini estación meteorológica
• ESP32/ESP8266 Insertar datos en una base de datos MySQL usando PHP y Arduino IDE

Probando todos los sensores de temperatura

Este experimento registró lecturas de temperatura de distintos sensores a lo largo del tiempo en las mismas condiciones.

Cableamos todos los siguientes sensores de temperatura a un Arduino Mega:

• DHT11
• DHT22
• LM35
• 2x DS18B20 en el mismo bus de datos
• BME280
• BMP180

Los datos se registraron en una tarjeta microSD usando un módulo de tarjeta microSD. El experimento se ejecutó durante aproximadamente 36 horas y las lecturas de temperatura se registraron cada 5 minutos.

Cableamos los pines de datos de los sensores de temperatura a los siguientes pines del Arduino Mega:

• DHT11: Pin 11
• DHT22: Pin 12
• DS18B20: Pin 14
• LM35: Pin A0
• BME280: SPI por software en estos pines: Pin 4 (MISO), Pin 5 (CS), Pin 6 (SCK), Pin 7 (MOSI)
• BMP180: Pin 20 (SDA) y Pin 21 (CSL)

El módulo de tarjeta microSD se conectó vía SPI por hardware: Pin 51 (MOSI), Pin 50 (MISO), Pin 52 (SCK), Pin 53 (CS).

Este es el código ejecutándose en el 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 card

const 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 sin formato

Nota: para poder compilar y ejecutar este código, debes instalar en tu Arduino IDE todas las librerías de sensores mencionadas en la tabla comparativa al principio de este artículo.

Resultados: comparando las lecturas de temperatura

Después de aproximadamente 36 horas, retiramos la tarjeta microSD y copiamos los resultados a una hoja de cálculo. Graficamos todas las lecturas para comparar mejor las mediciones de los distintos sensores de temperatura.

Esta gráfica no tiene un grupo de control (no usamos un sensor de temperatura calibrado), pero nos da una idea de cómo se comportan estos sensores.

Si observas de cerca las gráficas, el BME280 midió valores ligeramente más altos que los demás sensores de temperatura. Este comportamiento es normal y está descrito en la hoja de datos. El módulo se autocalienta un poco y las mediciones de temperatura pueden estar 1 o 2 grados por encima del valor real de temperatura.

Sin embargo, el BME280 también es el sensor de temperatura que dio las lecturas más estables, sin muchas oscilaciones entre lecturas. Esto tiene que ver con la resolución del sensor. Puede detectar cambios de hasta 0.01ºC.

En el caso de los sensores de temperatura DS18B20, podemos ver algunas oscilaciones entre lecturas y también se nota que la resolución no es tan buena como la del BME280. Además, el sensor de temperatura DS18B20 fue el único que dio algunas lecturas “nulas” a lo largo del experimento. Medimos dos sensores de temperatura DS18B20 en la misma línea de datos y uno de los sensores falló al leer la temperatura 6 veces a lo largo del experimento (durante 36 horas).

El DHT22 y el BMP180 se comportan de forma muy similar, con pocas oscilaciones. El DHT11 no pudo detectar pequeños cambios de temperatura, porque su resolución es de 1ºC.

Finalmente, el sensor de temperatura LM35 detectó cambios de temperatura entre 24ºC y 26ºC pero con muchas oscilaciones entre mediciones.

Esta gráfica que compara los distintos sensores de temperatura muestra claramente cómo se diferencia cada sensor de los demás. Es más fácil entender cómo funcionan y si serán adecuados para los proyectos que quieres construir.

Conclusión

En este artículo hemos comparado varios sensores de temperatura que puedes usar con el ESP32, ESP8266, Arduino y otras placas de desarrollo. Todos estos sensores miden temperatura pero se comportan de forma diferente cuando se ponen a prueba en el mismo entorno al mismo tiempo.

Esperamos que este artículo te haya resultado útil y que te ayude a elegir el mejor sensor de temperatura para los requisitos de tu proyecto.

Artículo traducido al español. Fuente original: Random Nerd Tutorials (Rui Santos)