Sensor de temperatura DS18B20 con Arduino, ESP32 y Pico

El DS18B20 es un sensor de temperatura digital y una de las formas más precisas y flexibles de medir temperatura con Arduino. Mide de −55 °C a +125 °C, ofrece una precisión de ±0,5 °C entre −10 °C y +85 °C y envía el resultado como un número digital, no como una tensión analógica, así que la lectura no se degrada ni con cables largos. Su gran baza es la comunicación 1-Wire: puedes conectar decenas de DS18B20 a un único pin de datos y leer cada uno por separado mediante su propia dirección única.

En este artículo aprenderás cómo funciona el DS18B20, la lógica del bus 1-Wire, por qué necesita siempre una resistencia pull-up de 4,7 kΩ, la versión de sonda sumergible y los colores de sus cables. Después veremos paso a paso el código para uno y para varios sensores con las librerías OneWire y DallasTemperature, la lectura sin bloqueos en el ESP32 y su uso con MicroPython en la Raspberry Pi Pico. Al final encontrarás las causas y soluciones de los errores habituales de −127 °C y 85 °C.

¿Qué es el DS18B20 y cómo funciona?

Dentro del DS18B20 hay un elemento sensor de temperatura, un convertidor analógico-digital, una pequeña memoria (scratchpad) y un número de serie único de 64 bits grabado de fábrica. Cuando el microcontrolador envía la orden de medida, el sensor mide la temperatura, guarda el resultado en su memoria como un número de dos bytes y espera a que lo lean. Como la medida la hace el propio sensor, no hay errores debidos a la entrada analógica de Arduino, a su tensión de referencia ni a la resistencia del cable. A diferencia de un termistor NTC, tampoco necesitas tablas de calibración ni fórmulas: el valor que lees está directamente en grados Celsius.

La resolución del sensor se elige por software. A mayor resolución, pasos más finos pero también más tiempo de conversión. Por defecto son 12 bits, lo adecuado para la mayoría de proyectos; si necesitas lecturas muy rápidas, puedes bajar a 9 o 10 bits.

¿Qué es 1-Wire? Comunicación por un solo cable

Como su nombre indica, 1-Wire es un protocolo que transporta los datos por una sola línea, con la masa (GND) compartida. En el bus hay un maestro (el Arduino) y uno o varios esclavos (los DS18B20). Cuando el bus está libre, una resistencia pull-up lo mantiene en HIGH. Quien quiere hablar baja la línea a LOW durante instantes cortos; los bits se codifican en la duración de esos pulsos LOW, medida en microsegundos. Cada comunicación empieza con un pulso de reset, y los sensores responden con un pulso de presencia que viene a decir «aquí estoy».

Como ningún dispositivo fuerza la línea a HIGH (diseño en drenador abierto), puedes poner en el mismo bus tantos sensores como quieras sin conflictos. El maestro busca primero todas las direcciones de 64 bits del bus con una orden de búsqueda, después selecciona por su dirección el sensor que le interesa y habla con él. Así, para medir la temperatura en cinco puntos distintos gastas un solo pin en lugar de cinco.

DS18B20, DHT11, DHT22 y NTC: comparativa

En resumen, si también necesitas medir humedad, el DHT11 o el DHT22 es la opción correcta. Si vas a medir la temperatura del agua, de la tierra, de una tubería o de un congelador, quieres vigilar varios puntos con un solo pin o trabajar bajo cero, el DS18B20 no tiene rival.

Pines del DS18B20 y colores de los cables

Conexión del DS18B20: Arduino Uno, ESP32 y Pico

La resistencia pull-up es imprescindible en este circuito. Los dispositivos del bus 1-Wire solo pueden bajar la línea a LOW; es esta resistencia la que la devuelve a HIGH. Sin ella la línea queda al aire, el sensor no se encuentra y la librería devuelve −127 °C. Un valor de 4,7 kΩ sube la línea lo bastante rápido y mantiene baja la corriente: con la línea en LOW, según la ley de Ohm circulan I = 5 V / 4700 Ω ≈ 1,06 mA. Los colores de una resistencia de 4,7 kΩ de cuatro bandas son amarillo, violeta, rojo y dorado; para asegurarte puedes usar la herramienta de código de colores. Algunos módulos DS18B20 (el sensor en una placa pequeña con resistencia y LED) ya traen esta resistencia montada; en ese caso no hace falta añadir otra.

Instalar las librerías

1. En el Arduino IDE abre Herramientas > Administrar bibliotecas.
2. Escribe DallasTemperature en el buscador e instala la librería de Miles Burton.
3. Cuando te pregunte por las dependencias, elige Install all para que también se instale la librería OneWire de Paul Stoffregen. Si no te lo pregunta, busca OneWire e instálala aparte.
4. Si quieres, abre Archivo > Ejemplos > DallasTemperature > Simple, cambia el número de pin según tu circuito y pruébalo.

Primer código: leer un DS18B20

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4#define ONE_WIRE_BUS 2                    // DS18B20 veri pini (DQ) / data pin (DQ)
5
6OneWire oneWire(ONE_WIRE_BUS);            // 1-Wire hattı / 1-Wire bus
7DallasTemperature sensors(&oneWire);      // sensör kütüphanesi / sensor library
8
9void setup() {
10  Serial.begin(9600);
11  sensors.begin();                        // hattaki sensörleri bul / find sensors on the bus
12  Serial.print(F("Sensor sayisi / Sensor count: "));
13  Serial.println(sensors.getDeviceCount());
14}
15
16void loop() {
17  sensors.requestTemperatures();          // ölçümü başlat, bitmesini bekle / start conversion and wait
18  float tempC = sensors.getTempCByIndex(0);  // ilk sensörün sıcaklığı / first sensor's temperature
19
20  if (tempC == DEVICE_DISCONNECTED_C) {   // -127: sensör yanıt vermedi / sensor did not respond
21    Serial.println(F("Hata: sensor yok / Error: no sensor"));
22  } else {
23    Serial.print(F("Sicaklik / Temperature: "));
24    Serial.print(tempC, 2);
25    Serial.println(F(" C"));
26  }
27  delay(1000);
28}

Con el monitor serie a 9600 baudios verás cada segundo una línea como «Sicaklik / Temperature: 23.44 C». Te darás cuenta de que las últimas cifras cambian en múltiplos de 0,0625, el paso de la resolución de 12 bits. Si sujetas el sensor entre los dedos, la temperatura debería subir en pocos segundos. Si el monitor serie muestra −127, el sensor no se encuentra en absoluto; si muestra 85, el sensor se encontró pero se leyó antes de que terminara la medida. La solución de ambos casos está en la tabla del final del artículo.

Varios DS18B20 en el mismo pin

Para conectar varios sensores basta con unir en paralelo todos sus pines VDD, GND y DQ; para todo el bus se usa una sola resistencia pull-up de 4,7 kΩ. Leer con getTempCByIndex() es cómodo, pero el orden lo deciden las direcciones de los sensores, no el orden en que los conectaste. Si cambias un sensor, el orden puede variar. Por eso, en los proyectos permanentes conviene leer cada sensor por su propia dirección. El siguiente código encuentra todos los sensores del bus, muestra sus direcciones y lee la temperatura de cada uno por su dirección:

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4#define ONE_WIRE_BUS 2                    // tüm sensörler aynı pinde / all sensors on the same pin
5
6OneWire oneWire(ONE_WIRE_BUS);
7DallasTemperature sensors(&oneWire);
8DeviceAddress addr;                       // 8 baytlık sensör adresi / 8-byte sensor address
9int count = 0;
10
11void printAddress(const DeviceAddress a) {
12  for (uint8_t i = 0; i < 8; i++) {
13    Serial.print(F("0x"));
14    if (a[i] < 0x10) Serial.print('0');   // tek haneyi sıfırla tamamla / pad single digit
15    Serial.print(a[i], HEX);
16    if (i < 7) Serial.print(F(", "));
17  }
18}
19
20void setup() {
21  Serial.begin(9600);
22  sensors.begin();
23  count = sensors.getDeviceCount();       // hatta kaç sensör var? / how many sensors on the bus?
24  Serial.print(F("Sensor sayisi / Sensor count: "));
25  Serial.println(count);
26  sensors.setResolution(12);              // hepsi 12 bit (0,0625 C) / all 12-bit (0.0625 C)
27}
28
29void loop() {
30  sensors.requestTemperatures();          // tüm sensörler aynı anda ölçer / all sensors convert at once
31  for (int i = 0; i < count; i++) {
32    if (!sensors.getAddress(addr, i)) continue;   // adresi al / get the address
33    Serial.print(F("Sensor "));
34    Serial.print(i);
35    Serial.print(F(" { "));
36    printAddress(addr);
37    Serial.print(F(" }: "));
38    Serial.print(sensors.getTempC(addr), 2);      // adrese göre oku / read by address
39    Serial.println(F(" C"));
40  }
41  Serial.println();
42  delay(2000);
43}

Ejecuta el código una vez y calienta los sensores uno a uno (por ejemplo, sujetándolos en la mano) para saber qué dirección corresponde a cada punto. Después escribe en tu código la dirección que viste en el monitor serie: añade una línea como DeviceAddress sensorAgua = {0x28, 0xFF, 0x64, 0x1E, 0x0F, 0x16, 0x03, 0x90}; y léela con sensors.getTempC(sensorAgua). En el DS18B20 el primer byte de la dirección siempre es 0x28, y el último es un CRC que comprueba que la dirección es válida. Así, sea cual sea el orden de los sensores, los valores de «agua», «exterior» o «caldera» siempre llegan del sitio correcto.

DS18B20 con ESP32: lectura sin bloquear el programa

El DS18B20 funciona en el ESP32 con las mismas librerías OneWire y DallasTemperature. Para la línea de datos, el GPIO 4 es una buena elección. No uses los GPIO 34–39, porque son solo de entrada y no pueden bajar la línea 1-Wire a LOW; evita también los GPIO 0, 2, 12 y 15, cuyo nivel influye en el arranque. Conecta siempre el sensor y la resistencia pull-up a 3V3: si llevas la pull-up a 5 V, estarás aplicando 5 V a un pin del ESP32.

Por defecto, requestTemperatures() espera 750 ms a 12 bits. Durante ese tiempo la placa no puede hacer nada más: el servidor web, los pulsadores o la pantalla se congelan. La solución es desactivar la espera con setWaitForConversion(false) y leer el resultado 750 ms después con millis(). En el siguiente código para ESP32, el LED sigue parpadeando con fluidez incluso mientras se mide la temperatura:

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int ONE_WIRE_PIN = 4;               // ESP32 GPIO 4 (DQ)
5const int LED_PIN = 2;                    // dahili LED (çoğu kartta) / onboard LED (most boards)
6
7OneWire oneWire(ONE_WIRE_PIN);
8DallasTemperature sensors(&oneWire);
9
10unsigned long requestTime = 0;
11unsigned long lastBlink = 0;
12bool converting = false;
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17  sensors.begin();
18  sensors.setResolution(12);
19  sensors.setWaitForConversion(false);    // requestTemperatures() beklemesin / do not block
20}
21
22void loop() {
23  unsigned long now = millis();
24
25  if (!converting) {
26    sensors.requestTemperatures();        // ölçümü başlat, hemen dön / start and return at once
27    requestTime = now;
28    converting = true;
29  }
30
31  if (converting && now - requestTime >= 750) {   // 12 bit için 750 ms / 750 ms for 12-bit
32    float t = sensors.getTempCByIndex(0);
33    if (t == DEVICE_DISCONNECTED_C) {
34      Serial.println("Sensor yok / No sensor");
35    } else {
36      Serial.printf("Sicaklik / Temperature: %.2f C\n", t);
37    }
38    converting = false;                   // bir sonraki ölçüme geç / move to the next reading
39  }
40
41  if (now - lastBlink >= 250) {           // bu arada LED yanıp söner / meanwhile the LED blinks
42    lastBlink = now;
43    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
44  }
45}

Este patrón es especialmente importante en los proyectos Wi-Fi: el ESP32 puede medir la temperatura mientras sirve una página web, envía datos a internet o actualiza una pantalla. Si acabas de conocer el ESP32, consulta ¿Qué es el ESP32? para elegir pines y configurarlo; también puedes ver el mapa de pines de tu placa en la herramienta Pinout.

DS18B20 con Raspberry Pi Pico y MicroPython

Los módulos onewire y ds18x20 vienen incluidos en MicroPython para la Raspberry Pi Pico, así que no tienes que subir ningún archivo extra. Conecta el sensor a 3V3(OUT) y GND, la línea de datos a GP22, y no olvides la pull-up de 4,7 kΩ entre DQ y 3V3. Las resistencias pull-up internas de la Pico son demasiado débiles para 1-Wire.

1from machine import Pin
2import onewire, ds18x20, time, binascii
3
4ds_pin = Pin(22)                                   # DQ -> GP22 (fiziksel pin 29 / physical pin 29)
5sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
6
7roms = sensor.scan()                               # hattaki sensör adresleri / sensor addresses on the bus
8print("Sensor sayisi / Sensor count:", len(roms))
9
10while True:
11    sensor.convert_temp()                          # hepsi aynı anda ölçer / all sensors convert at once
12    time.sleep_ms(750)                             # 12 bit dönüşüm süresi / 12-bit conversion time
13    for rom in roms:
14        t = sensor.read_temp(rom)                  # adrese göre oku / read by address
15        print(binascii.hexlify(rom).decode(), "{:.2f} C".format(t))
16    time.sleep(2)

scan() devuelve una lista con las direcciones de 8 bytes de todos los sensores del bus. convert_temp() envía la orden de medida a todos los sensores a la vez, por eso después hay que esperar 750 ms. read_temp(rom) lee en grados Celsius la temperatura del sensor con esa dirección. Si la lista sale vacía, revisa primero la resistencia pull-up y el número de pin. Si acabas de conocer la Pico, consulta ¿Qué es la Raspberry Pi Pico? para instalar MicroPython.

La sonda sumergible DS18B20

La forma más popular del DS18B20 es la sonda sumergible, en la que el chip va dentro de un tubo de acero inoxidable sellado con resina. Suele tener una punta de 6 mm de diámetro y 50 mm de largo y un cable de tres hilos de 1 metro (también hay versiones de 2, 3 y 5 metros). Es ideal para acuarios, depósitos de agua, termos de agua caliente, tierra, frigoríficos y congeladores. Puedes meter la punta de acero en agua hirviendo un momento, pero como el cable suele ser de PVC, no mantengas el cable ni la unión mucho tiempo por encima de 85–100 °C. La funda de la sonda frena el paso del calor al sensor, así que tras un cambio brusco de temperatura la lectura puede tardar desde unos segundos hasta varias decenas de segundos en estabilizarse.

En el mercado hay muchas copias del DS18B20. Algunas no alcanzan la precisión especificada o no funcionan en modo de alimentación parásita. Meter dos sensores en el mismo vaso de agua y comparar sus lecturas es una forma sencilla de saber si el tuyo es fiable. Si difieren en más de 0,5 °C, puedes aplicar un pequeño valor de corrección (offset) en el código.

Ideas de proyectos con el DS18B20

• Termostato para acuario: Enciende y apaga un calentador con la sonda sumergible y un módulo de relé; con histéresis mantienes el agua entre 25 y 26 °C.
• Control de temperatura en varios puntos: Conecta cinco sensores a un pin y vigila a la vez la habitación, el exterior, el frigorífico y la ida y el retorno de la caldera.
• Termómetro OLED: Muestra la temperatura con cifras grandes en una pantalla OLED, junto con la mínima y la máxima del día.
• Indicador de temperatura con LCD: Escribe las lecturas de dos sensores en las dos líneas de una pantalla LCD I2C.
• Página web de temperatura por Wi-Fi: Sigue en directo la temperatura medida por un ESP32 en una página web que abres desde el móvil.
• Control de invernadero: Mide la temperatura del suelo con un DS18B20 y la humedad con un sensor de humedad del suelo para decidir cuándo regar.

Problemas frecuentes y soluciones

Por su robustez, su sonda sumergible y la posibilidad de conectar muchos sensores a un solo pin, el DS18B20 es uno de los sensores de temperatura más útiles de la electrónica de aficionado. Puedes mostrar la temperatura en una pantalla, encender un calentador o un ventilador con un relé o llevarla a internet con un ESP32. En la app BlueGrays encontrarás proyectos de medida de temperatura con DHT11 y NTC, pantallas LCD I2C, un registrador de temperatura con ESP32 y riego inteligente para Arduino y ESP32, con esquemas de circuito y código paso a paso.