Midiendo Temperatura con el Sensor DS18B20 y Arduino

En el vasto universo de la electrónica y la automatización, la capacidad de monitorear variables físicas es fundamental. Entre estas variables, la temperatura se destaca por su omnipresencia en una infinidad de aplicaciones, desde el control climático en hogares inteligentes hasta la supervisión de procesos industriales complejos. Hoy, nos adentraremos en el fascinante mundo de la medición de temperatura utilizando un componente extraordinariamente versátil y accesible: el sensor DS18B20. Este pequeño gigante, a menudo presentado en una robusta sonda impermeable, es su pasaporte para medir la temperatura de cualquier ambiente, incluso sumergiéndolo en líquidos, abriendo un abanico de posibilidades para sus proyectos.

El DS18B20 se ha ganado su lugar como uno de los sensores de temperatura más populares entre aficionados y profesionales por igual. Su alta versatilidad, su notable fiabilidad y, no menos importante, su impresionante economía, lo convierten en una elección predilecta. Con un costo que ronda los pocos dólares, e incluso más asequible en compras al por mayor o importaciones directas, este sensor ofrece un rendimiento excepcional sin desequilibrar su presupuesto. Si bien su diseño impermeable lo hace ideal para la inmersión, su utilidad se extiende a entornos de alta humedad o donde se requiera una resistencia adicional a impactos ligeros, demostrando su adaptabilidad en condiciones un tanto más hostiles.

Características Clave del Sensor de Temperatura DS18B20

Como siempre, la clave para dominar cualquier componente electrónico reside en comprender sus especificaciones técnicas. Para el DS18B20, nos basaremos en la documentación proporcionada por Maxim Integrated, su fabricante principal. Lo primero que salta a la vista es su sencilla configuración de pines. El circuito integrado central, responsable de la medición de temperatura, se presenta con solo tres conexiones esenciales: GND (Tierra), DQ (Datos) y VDD (Voltaje). Estas tres líneas son todo lo que necesita para establecer comunicación y alimentar el sensor.

A menudo, este diminuto integrado se encuentra encapsulado dentro de una sonda, provista de un cable de aproximadamente un metro de longitud. Este cable culmina en tres hilos, generalmente con un código de colores específico, que son los que utilizaremos para interactuar con el sensor. Es importante destacar que, aunque los colores pueden variar ligeramente entre diferentes fabricantes, la función de cada pin se mantiene constante.

El rango de voltaje de operación del DS18B20 es otro de sus puntos fuertes, aceptando alimentación a través del pin VDD en un amplio espectro que va desde los 3.0 V hasta los 5.5 V. Esto lo hace compatible con la mayoría de las placas de desarrollo, como Arduino, que suelen operar en estos voltajes. En cuanto a su capacidad de detección, el sensor es capaz de medir temperaturas en un rango impresionante, desde unos gélidos -55°C hasta unos abrasadores 125°C, cubriendo una vasta gama de aplicaciones.

Una de las características más distintivas y convenientes del DS18B20 es su protocolo de comunicación. Al contar con un único pin de datos (DQ), este sensor se comunica a través del protocolo 1-Wire®. Como su nombre lo indica, este protocolo bidireccional solo requiere un único cable para la transmisión de datos, simplificando enormemente el cableado y la conexión. Afortunadamente, no es necesario que profundicemos en los intrincados detalles técnicos de este protocolo, ya que existen librerías de software robustas y fáciles de usar que se encargan de toda la complejidad de la comunicación, permitiéndonos centrarnos en la lectura de los datos.

Precisión y Rango de Operación

Si bien el DS18B20 ofrece un amplio rango de detección de temperatura, es crucial entender su precisión. El fabricante detalla el error probable según el rango de operación, lo cual es vital para aplicaciones que demandan alta exactitud:

Para la mayoría de los proyectos prácticos y de aplicación general, este nivel de precisión es más que adecuado. Sin embargo, si su proyecto requiere una exactitud superior, existen en el mercado otros tipos de sensores de temperatura que ofrecen mejores prestaciones, mayor resolución y un margen de error más bajo, aunque generalmente a un costo más elevado. La elección dependerá siempre de las exigencias específicas de su aplicación.

Además, el DS18B20 incorpora una pequeña memoria interna. En esta memoria, cada sensor almacena un identificador único (ID). Esta característica es extraordinariamente útil, ya que permite conectar múltiples sensores al mismo pin de una placa de desarrollo, como Arduino, y distinguirlos individualmente. Este concepto, conocido como bus 1-Wire, simplifica el cableado en sistemas con múltiples puntos de medición de temperatura, una funcionalidad que exploraremos en detalle más adelante.

Conectando el Sensor de Temperatura DS18B20 a Arduino

La conexión física del sensor a su placa Arduino es un paso crucial. Como mencionamos, la sonda DS18B20 suele venir con tres cables de colores. Aunque la configuración de colores puede variar entre fabricantes, una convención común es la siguiente:

• Negro: GND (Tierra)
• Rojo: VDD (Voltaje de alimentación)
• Azul: DQ (Pin de Datos)

Al preparar los cables, notará que los conductores internos están formados por múltiples hilos finos, lo que puede dificultar la conexión directa a un protoboard o a los pines de Arduino. Una recomendación práctica es soldar cables Dupont (los mismos que hemos utilizado en otros proyectos) a los extremos de la sonda. Corte un extremo de los cables Dupont y suéldelos a los hilos del sensor, asegurándose de que el otro extremo tenga un conector macho, facilitando así una conexión limpia y segura a su placa o protoboard.

En caso de encontrarse con una configuración de colores diferente, no se preocupe. Generalmente, el cable rojo suele corresponder a VDD. Si no está seguro, puede probar las conexiones con precaución; el sensor DS18B20 es bastante robusto y rara vez se daña por una conexión incorrecta momentánea. Una vez que funcione, ¡etiquéte los cables para futuras referencias!

Opciones de Alimentación y la Resistencia Pull-Up

Al alimentar el sensor DS18B20 con Arduino, tiene dos métodos principales: el modo de alimentación directo y el modo parásito. Independientemente del modo elegido, un componente es indispensable: una resistencia pull-up conectada al pin DQ. ¿Recuerda el concepto de resistencia pull-up en sistemas de comunicación digital? Su función es asegurar que el pin de datos (DQ) mantenga un estado lógico alto (HIGH) cuando el sensor no está transmitiendo activamente. Esto evita lecturas erráticas y asegura una comunicación estable. Cuando el sensor necesita enviar datos, puede "tirar" la línea a un estado lógico bajo (LOW), y Arduino detectará este cambio.

La selección del valor adecuado para esta resistencia es importante y dependerá principalmente de la longitud del cable que conecta el sensor a su placa. Para el cable estándar incorporado en la sonda (aproximadamente un metro), una resistencia de 4.7 KΩ es la elección más común y efectiva. Sin embargo, si necesita extender la longitud del cable, considere la siguiente guía:

Modo de Alimentación Directo

Este es el método de alimentación más común y sencillo. Consiste en conectar el pin VDD del sensor directamente a una fuente de voltaje desde 3.0 V hasta 5.5 V, como el pin de 5V o 3.3V de su placa Arduino. El esquema de conexión sería el siguiente:

El pin GND del sensor se conecta a la tierra de Arduino. El pin DQ del sensor se conecta a un pin digital de Arduino (ej. Pin 3), y entre este pin digital y la línea de alimentación (5V o 3.3V) se coloca la resistencia pull-up. Es importante recordar que si conecta múltiples sensores DS18B20 al mismo pin digital de Arduino, todos compartirán la misma resistencia pull-up. No es necesario añadir una resistencia por cada sensor. Sin embargo, si decide conectar sensores a diferentes pines digitales de Arduino, cada pin digital necesitará su propia resistencia pull-up.

Modo de Alimentación Parásito

El modo de alimentación parásito es una característica ingeniosa del DS18B20 que permite reducir el número de cables necesarios para su funcionamiento. En esta configuración, los pines DQ y GND se conectan de la misma manera que en el modo directo. La diferencia radica en la conexión del pin VDD, que en este caso se conecta directamente a la tierra (GND).

En este modo, el sensor obtiene la energía necesaria para su funcionamiento directamente del pin de datos DQ. Cuando el pin DQ está en un estado HIGH, el sensor aprovecha ese voltaje para cargarse y operar. Esto es especialmente útil en aplicaciones donde el espacio o la cantidad de cables son críticos. Ambos modos de alimentación son válidos y la elección dependerá de las necesidades específicas de su proyecto; la programación que veremos a continuación funcionará indistintamente con cualquiera de ellos.

Preparando el Software: Librerías Esenciales

Antes de sumergirnos en la programación de nuestro Arduino, es fundamental instalar las librerías necesarias para que la comunicación con el sensor DS18B20 sea fluida y sin complicaciones. Necesitaremos dos librerías principales:

1. Librería 1-Wire®: Esta librería proporciona las funciones básicas para la comunicación a través del protocolo 1-Wire. Para instalarla, abra el IDE de Arduino, vaya a Sketch > Incluir Librería > Administrar Librerías.... En el buscador, escriba "one wire" y busque la librería "OneWire by Paul Stoffregen". Haga clic en "Instalar".
2. Librería Dallas Temperature: Esta librería se construye sobre la base de la librería 1-Wire y contiene todas las funciones específicas y de alto nivel necesarias para interactuar con el sensor DS18B20. Repita el proceso: en el Administrador de Librerías, busque "Dallas Temperature" y seleccione "DallasTemperature by Miles Burton". Haga clic en "Instalar".

Una vez instaladas ambas librerías, su entorno de desarrollo estará listo para comenzar a programar la lectura de temperatura.

Programando Arduino para Leer el Sensor DS18B20

¡Manos a la obra! Con el sensor conectado y las librerías instaladas, estamos listos para escribir el código que dará vida a nuestro proyecto de monitoreo de temperatura. Recuerde que la teoría es la base, pero la práctica es donde la magia sucede.

Lectura Básica de Temperatura

Primero, debemos incluir las librerías que utilizaremos al inicio de nuestro programa:

#include <OneWire.h> #include <DallasTemperature.h> 

Luego, definiremos el pin digital de Arduino al que conectaremos el pin DQ del sensor (y su respectiva resistencia pull-up). Para este ejemplo, utilizaremos el pin 3:

const int pinDatosDQ = 3; OneWire oneWireObjeto(pinDatosDQ); DallasTemperature sensorDS18B20(&oneWireObjeto); 

Aquí, creamos un objeto `OneWire` llamado `oneWireObjeto`, indicándole el pin físico donde actuará. Posteriormente, creamos un objeto `DallasTemperature` llamado `sensorDS18B20`, que representará nuestro sensor y a través del cual invocaremos las funciones para trabajar con él. Es como si estuviéramos "instanciando" el sensor en nuestro código.

Dentro de la función `setup()`, inicializaremos la comunicación serie para poder ver las lecturas en el Monitor Serie de Arduino y también inicializaremos el sensor:

void setup() { Serial.begin(9600); // Inicializa la comunicación serial a 9600 baudios sensorDS18B20.begin(); // Inicializa el sensor DS18B20 } 

Finalmente, en la función `loop()`, colocaremos las instrucciones para solicitar y leer la temperatura de forma continua. El código completo para una lectura básica sería el siguiente:

#include <OneWire.h> #include <DallasTemperature.h> // Definimos el pin digital de Arduino al que conectamos el pin DQ del DS18B20 const int pinDatosDQ = 3; // Creamos una instancia de la clase OneWire OneWire oneWireObjeto(pinDatosDQ); // Pasamos la instancia de OneWire a la librería Dallas Temperature DallasTemperature sensorDS18B20(&oneWireObjeto); void setup() { // Iniciamos la comunicación serial para depuración Serial.begin(9600); // Iniciamos el sensor DS18B20 sensorDS18B20.begin(); Serial.println("Sensor DS18B20 inicializado. Listo para leer temperaturas."); } void loop() { // Solicitamos las lecturas de temperatura a todos los sensores en el bus 1-Wire Serial.print("Solicitando temperaturas..."); sensorDS18B20.requestTemperatures(); // Envía el comando para leer las temperaturas Serial.println("Hecho."); // Leemos la temperatura del primer sensor (índice 0) en grados Celsius float tempC_sensor1 = sensorDS18B20.getTempCByIndex(0); Serial.print("Temperatura sensor 1: "); Serial.print(tempC_sensor1); Serial.println(" C"); // Si tienes más sensores, puedes leerlos por su índice. Por ejemplo, para un segundo sensor: // float tempC_sensor2 = sensorDS18B20.getTempCByIndex(1); // Serial.print("Temperatura sensor 2: "); // Serial.print(tempC_sensor2); // Serial.println(" C"); // Esperamos un segundo antes de la siguiente lectura delay(1000); } 

En el código anterior, cada vez que necesitamos una nueva lectura de temperatura, llamamos a la función `requestTemperatures();` del objeto `sensorDS18B20`. Si tuviéramos varios sensores conectados a diferentes pines de Arduino, necesitaríamos crear un objeto `DallasTemperature` para cada pin. Sin embargo, si varios sensores están en el mismo pin (modo bus 1-Wire), una sola llamada a `requestTemperatures()` es suficiente para todos.

Para obtener el valor de la temperatura, utilizamos la función `sensorDS18B20.getTempCByIndex(0);`. El índice `0` se refiere al primer sensor detectado en el bus 1-Wire. Si tiene varios sensores conectados al mismo pin, puede acceder al segundo con el índice `1`, al tercero con el índice `2`, y así sucesivamente. Esta función nos devuelve directamente la temperatura en grados Celsius (°C).

Al abrir el Monitor Serie del IDE de Arduino (Herramientas > Monitor Serie), debería ver las lecturas de temperatura actualizándose cada segundo. Si en algún momento observa un valor de `-127.00`, esto indica un error de conexión o que el sensor no fue detectado correctamente. Revise su cableado, especialmente la resistencia pull-up.

Identificando Múltiples Sensores por su Dirección Única

Una pregunta común surge cuando se conectan múltiples sensores DS18B20 al mismo pin de Arduino: ¿Cómo saber cuál lectura corresponde a qué sensor físico? Aunque el método "empírico" de calentar o enfriar un sensor y observar el cambio en el Monitor Serie es válido, existe una forma más robusta y programática de identificarlos: utilizando su dirección de identificación única (ID).

El siguiente código le permitirá escanear el bus 1-Wire y mostrar las direcciones únicas de cada sensor DS18B20 conectado al pin especificado:

#include <OneWire.h> #include <DallasTemperature.h> // Definimos el pin digital de Arduino al que conectamos el pin DQ del DS18B20 const int pinDatosDQ = 3; // Creamos una instancia de la clase OneWire OneWire oneWireObjeto(pinDatosDQ); // Pasamos la instancia de OneWire a la librería Dallas Temperature DallasTemperature sensorDS18B20(&oneWireObjeto); // Función para imprimir la dirección de un sensor void printAddress(DeviceAddress deviceAddress) { for (uint8_t i = 0; i < 8; i++) { Serial.print("0x"); if (deviceAddress[i] < 0x10) Serial.print("0"); // Añade un cero si el byte es menor que 0x10 Serial.print(deviceAddress[i], HEX); // Imprime el byte en formato hexadecimal if (i < 7) Serial.print(", "); // Añade una coma si no es el último byte } Serial.println(""); // Salto de línea al final de la dirección } void setup() { // Iniciamos la comunicación serial Serial.begin(9600); // Iniciamos el sensor DS18B20 sensorDS18B20.begin(); Serial.println("\nBuscando sensores DS18B20..."); // Obtenemos el número de sensores encontrados en el bus int sensoresConectados = sensorDS18B20.getDeviceCount(); Serial.print("Encontrados: "); Serial.print(sensoresConectados); Serial.println(" sensores."); // Si hemos encontrado al menos un sensor, mostramos sus direcciones if (sensoresConectados >= 1) { Serial.println("Imprimiendo direcciones de los sensores:"); // Iteramos a través de cada sensor encontrado for (int i = 0; i < sensoresConectados; i++) { DeviceAddress termometro; // Variable para almacenar la dirección del sensor Serial.print("Sensor "); Serial.print(i + 1); Serial.print(" (indice "); Serial.print(i); Serial.print("): "); sensorDS18B20.getAddress(termometro, i); // Obtenemos la dirección del sensor por su índice printAddress(termometro); // Imprimimos la dirección } } else { Serial.println("No se encontraron sensores. Revise las conexiones."); } } void loop() { // En este ejemplo, el loop está vacío ya que solo necesitamos detectar las direcciones una vez en setup. } 

Al cargar este código en su Arduino y abrir el Monitor Serie, verá la dirección única de 8 bytes de cada sensor detectado. Una estrategia muy útil es ejecutar este código conectando un solo sensor a la vez. Anote la dirección que aparece en el Monitor Serie y etiquete físicamente ese sensor con su ID. Repita el proceso para cada sensor. De esta manera, tendrá un mapeo claro entre el sensor físico y su dirección programática.

Lectura de Temperatura Utilizando la Dirección del Sensor

Una vez que ha identificado las direcciones de sus sensores, puede modificar el código para solicitar la temperatura de un sensor específico por su ID, en lugar de utilizar el índice genérico. Esto es especialmente útil cuando la posición física de los sensores importa y desea asociar una lectura de temperatura con una ubicación o función específica.

#include <OneWire.h> #include <DallasTemperature.h> // Definimos el pin digital de Arduino al que conectamos el pin DQ del DS18B20 const int pinDatosDQ = 3; // Creamos una instancia de la clase OneWire OneWire oneWireObjeto(pinDatosDQ); // Pasamos la instancia de OneWire a la librería Dallas Temperature DallasTemperature sensorDS18B20(&oneWireObjeto); // Agregamos las direcciones de cada sensor que hemos detectado previamente. // REEMPLAZA ESTAS DIRECCIONES CON LAS TUYAS PROPIAS DeviceAddress sensor_ambiente = {0x28, 0x23, 0x53, 0x45, 0x92, 0x0F, 0x02, 0x88}; // Ejemplo de dirección para un sensor // Si tienes otro sensor, puedes añadir su dirección aquí: // DeviceAddress sensor_liquido = {0x28, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x01}; void setup() { // Iniciamos la comunicación serial Serial.begin(9600); // Iniciamos el sensor DS18B20 sensorDS18B20.begin(); Serial.println("\nInicializando sensores por dirección..."); // Opcional: Volver a verificar el número de sensores conectados int sensoresConectados = sensorDS18B20.getDeviceCount(); Serial.print("Sensores detectados en el bus: "); Serial.println(sensoresConectados); } void loop() { // Solicitamos las lecturas de temperatura a todos los sensores en el bus 1-Wire Serial.print("Solicitando temperaturas..."); sensorDS18B20.requestTemperatures(); Serial.println("Hecho."); // Leemos la temperatura del sensor 'sensor_ambiente' por su dirección float temp_ambiente = sensorDS18B20.getTempC(sensor_ambiente); if (temp_ambiente != DEVICE_DISCONNECTED_C) { // DEVICE_DISCONNECTED_C es -127.00 Serial.print("Temperatura Ambiente: "); Serial.print(temp_ambiente); Serial.println(" C"); } else { Serial.println("Error: Sensor Ambiente desconectado o no encontrado."); } // Si tienes un segundo sensor, puedes leerlo de manera similar: // float temp_liquido = sensorDS18B20.getTempC(sensor_liquido); // if (temp_liquido != DEVICE_DISCONNECTED_C) { // Serial.print("Temperatura Líquido: "); // Serial.print(temp_liquido); // Serial.println(" C"); // } else { // Serial.println("Error: Sensor Líquido desconectado o no encontrado."); // } delay(2000); // Esperamos 2 segundos antes de la siguiente lectura } 

En este código modificado, hemos agregado una o más líneas donde definimos las direcciones de nuestros sensores y les asignamos nombres descriptivos (por ejemplo, `sensor_ambiente`). Dentro de `loop()`, en lugar de usar `getTempCByIndex()`, ahora utilizamos `getTempC()` y le pasamos el nombre de la variable `DeviceAddress` que contiene la dirección del sensor deseado. Esto nos permite obtener lecturas precisas de cada sensor individualmente, sin importar su orden físico en el bus.

La flexibilidad y facilidad de uso del sensor DS18B20, combinadas con las potentes librerías de Arduino, lo convierten en una herramienta invaluable para cualquier proyecto que requiera monitoreo de temperatura. Desde sistemas de control de invernaderos hasta termómetros digitales para acuarios, las posibilidades son ilimitadas. Esperamos que este tutorial le haya proporcionado las herramientas y el conocimiento necesarios para comenzar a integrar este sensor en sus propias creaciones.

Preguntas Frecuentes (FAQ)

¿Qué es el sensor DS18B20 y para qué sirve?

El DS18B20 es un sensor de temperatura digital de precisión, ampliamente utilizado por su robustez, bajo costo y la capacidad de comunicarse a través de un único cable (protocolo 1-Wire). Se presenta comúnmente en una sonda impermeable, lo que lo hace ideal para medir la temperatura en entornos húmedos, líquidos o ambientes exteriores. Sirve para monitorear temperaturas en una vasta gama de aplicaciones, desde sistemas de calefacción, ventilación y aire acondicionado (HVAC), electrodomésticos, hasta proyectos de automatización y robótica.

¿Necesito una resistencia pull-up para el DS18B20? ¿De qué valor?

Sí, es indispensable utilizar una resistencia pull-up en el pin de datos (DQ) del DS18B20. Esta resistencia asegura que la línea de datos se mantenga en un estado lógico HIGH cuando el sensor no está transmitiendo, evitando lecturas erráticas. El valor más común y recomendado para la mayoría de las aplicaciones con el cable de sonda estándar es de 4.7 KΩ (kilo-ohmios). Si la longitud del cable es considerablemente mayor (más de 5 metros), el valor de la resistencia pull-up puede necesitar ajustarse a la baja (por ejemplo, 3.3 KΩ, 2.2 KΩ o incluso 1.2 KΩ para distancias muy largas) para mantener la integridad de la señal.

¿Puedo conectar varios sensores DS18B20 al mismo pin de Arduino?

¡Absolutamente sí! Una de las grandes ventajas del DS18B20 y el protocolo 1-Wire es que permite conectar múltiples sensores (hasta decenas, dependiendo de la longitud del cable y la calidad de la señal) al mismo pin digital de su Arduino. Cada sensor DS18B20 tiene una dirección de identificación única de 64 bits grabada de fábrica. Las librerías como Dallas Temperature permiten escanear el bus 1-Wire, detectar todos los sensores conectados y luego solicitar la temperatura de cada uno utilizando su índice o, de forma más precisa, su dirección única.

¿Cuál es el rango de temperatura que puede medir el DS18B20?

El sensor DS18B20 es capaz de medir temperaturas en un amplio rango que va desde -55°C hasta +125°C. Sin embargo, su precisión varía dentro de este rango. Es más preciso en el rango de -10°C a +85°C, donde el error típico es de ±0.5°C. Fuera de este rango, el error puede aumentar hasta ±2°C. Es importante considerar este margen de error al diseñar aplicaciones donde la precisión es crítica.

¿Qué significa un valor de -127.00 en la lectura del sensor?

Un valor de -127.00 (o `DEVICE_DISCONNECTED_C` si utiliza la constante de la librería Dallas Temperature) es un código de error. Indica que el sensor DS18B20 no pudo ser detectado o que hubo un problema en la comunicación. Las causas comunes incluyen: cableado incorrecto (especialmente la resistencia pull-up), un sensor dañado, o un problema con el pin digital de Arduino. Si ve este valor, revise cuidadosamente sus conexiones y asegúrese de que las librerías estén correctamente instaladas.

¿Es resistente al agua el DS18B20?

La respuesta depende de la presentación del sensor. El chip DS18B20 en sí no es inherentemente resistente al agua. Sin embargo, es muy común encontrarlo encapsulado dentro de una sonda de acero inoxidable sellada, que es completamente impermeable y diseñada específicamente para ser sumergida en líquidos o utilizada en ambientes de alta humedad sin sufrir daños. Si adquiere el chip suelto, necesitará encapsularlo usted mismo para protegerlo del agua.

Si quieres conocer otros artículos parecidos a Midiendo Temperatura con el Sensor DS18B20 y Arduino puedes visitar la categoría Librerías.