DS18B20 sensor de temperatura para líquidos con Arduino Deja un comentario
Recuerdo cuando compré mi primer kit de Arduino. Lo primero que hice fue encender un LED vamos, como todo el mundo. Pero probablemente el segundo programa que hice fue medir la temperatura con el LM35. Fue una sensación increíble. Ahora, en este punto he aprendido que hay un componente para cada situación. El sensor de temperatura DS18B20 es uno de los sensores más versátiles que puedes encontrar en el mercado.
Este sensor es idóneo cuando queremos medir la temperatura en ambientes húmedos e incluso dentro del agua. Esto es debido a que podemos comprar una versión que viene en forma de sonda impermeable. A lo largo de este artículo veremos las particularidades, ventajas y desventajas del DS18B20. No se trata de un sensor de temperatura común, veremos que es algo más.
Quizás lo más complicado sea la programación ya que utiliza un protocolo poco común dentro del mundo de Arduino, 1-Wire. No te preocupes, yo te voy a enseñar paso a paso todo lo que tienes que hacer para conectarlo a tu Arduino y programarlo.
Además, gracias a las librerías de Arduino la programación resulta muy sencilla, lo podrás comprobar más adelante.
Por último decirte que este es el sensor que hemos utilizado en el proyecto IoT Fridge Saver en el que hemos estado trabajando los últimos meses yo, Germán y José Manuel.
Como es norma de este blog, no solo estamos aquí para copiar y pegar, también queremos aprender. Ponte cómodo y empecemos con el tutorial del sensor de temperatura DS18B20.
Características técnicas del sensor DS18B20
Si realmente quieres sacar todo el partido a un componente, lo primero que tienes que hacer es dirigirte a la hoja de características técnicas del DS18B20. En este documento vas a encontrar todo lo necesario para conectar y programar el componente.
Lo primero que vemos es que hay diferentes formas del sensor DS18B20. A esto se le llama encapsulado y depende de donde lo utilices (protoboard, PCB, etc…), tendrás que elegir uno u otro.
Lo más importante de esta parte es la disposición de los pines. Para cada encapsulado encontramos una disposición diferente. Existen tres encapsulados: TO-92, SO y μSOP. El más adecuado para prototipar con Arduino es el TO-92 por su fácil conexión en la una protoboard.
Imagen obtenida del Datasheet DS18B20
La única diferencia entre ellos es la forma o encapsulado. Todos tienen tres pines útiles VDD, GND y DQ.
- VDD: es la tensión de alimentación es decir, que voltaje necesita para que el sensor de temperatura DS18B20 funcione correctamente. Podemos alimentar desde 3V a 5,5V. Ojo con este dato ya que es muy interesante cuando queremos trabajar con placas como Arduino MKR1000 y NodeMCU que trabajan a 3,3V.
- GND: es la toma de tierra. A este pin conectaremos la referencia 0V de nuestro circuito.
- DQ: es el pin de datos. Por este pin es por donde se recibirán todos los datos en el protocolo 1-Wire. Este protocolo tiene una ventaja. Como su propio nombre indica (1-Wire significa un cable en español) solo es necesario utilizar un cable para conectar varios sensores de temperatura DS18B20. Por lo tanto, solo utilizaremos 1 pin de Arduino para conectar múltiples sensores.
De momento ya hemos avanzado bastante, ya sabríamos como conectar el sensor de temperatura DS18B20 a un Arduino. Faltaría la programación :). Aún así, es interesante conocer más aspectos técnicos de este sensor.
Es importante fijarse en el consumo eléctrico si queremos utilizar el DS18B20 con alguna placa que requiera de baterías o pilas. Eso lo vemos en la segunda página en los parámetros que se miden en Amperios. Para este artículo no nos hace falta ya que será alimentado a través de la red eléctrica.
Rango de temperaturas del DS18B20
Algo muy importante es saber qué rango de temperaturas es capaz de medir un sensor de este tipo. No es lo mismo medir la temperatura ambiente de una casa situada en Alicante que medir la temperatura de un congelador o frigorífico.
También es importante conocer el error que puede llegar a tener y la resolución del sensor de temperatura DS18B20. Toda esta información la sacamos de la hoja de características técnicas.
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Comenzamos con el rango de temperaturas. El DS18B20 puede medir temperaturas entre -55ºC y 125ºC. Es un rango muy amplio sin embargo, no en todo el rango tenemos el mismo error. Ahora te estarás preguntando ¿qué es el error de un sensor de temperatura?
DS18B20 y el error en la medición
Si viviéramos en un mundo ideal donde todos salimos del trabajo a nuestra hora, nuestros hijos nos hacen caso y tenemos pagada la hipoteca desde hace años, un sensor de temperatura nos mediría exactamente la temperatura que hace en un sitio.
Pero no, no vivimos en un mundo idóneo y no salimos a nuestra hora, nuestros hijos no nos hacen caso y nos queda mucho de hipoteca por pagar. En este mundo, el real, un sensor de temperatura como el DS18B20 tiene errores debido a factores externos, al ruido inherente en los circuitos eléctricos y alteraciones en el medio físico.
No todo son noticias malas, aunque los componentes eléctricos tengan errores, estos se pueden medir. Por lo tanto sabemos más o menos cuanto oscilará la medición entorno a su valor real. En el caso del DS18B20 el error depende del rango de temperaturas.
Para temperaturas entre -10ºC y 85ºC podemos tener ±0,5ºC. Para el resto de temperaturas entre -55ºC y 125ºC el error es de ±2ºC.
Esto equivale a decir que si el sensor DS18B20 suministra una temperatura de 23ºC el valor real estará entre 22,5ºC y 23,5ºC. Si por el contrario suministra un valor de 90ºC el valor real estará entre 88ºC y 92ºC.
Esto tampoco te debe preocupar a no ser que quieras “cocer metanfetamina” como Walter White en Breaking Bad 🙂
Resolución del sensor de temperatura DS18B20
Una de las características más interesantes de este sensor es que podemos trabajar con diferentes resoluciones. Cuando hablo de resoluciones me refiero a cual es la variación mínima que podemos medir entre dos temperaturas.
Es lo mismo que nos sucede con los pines analógicos en Arduino o cualquier otra placa de desarrollo. El DS18B20 admite resoluciones de 9-bit, 10-bit, 11-bit y 12-bit. Por defecto utiliza la resolución de 12-bit.
Las variaciones para cada resolución las puedes consultar en la siguiente tabla.
| Resolución | Temperatura |
|---|---|
| 9-bit | 0,5ºC |
| 10-bit | 0,25ºC |
| 11-bit | 0,125ºC |
| 12-bit | 0,0625ºC |
Elegir una resolución u otra dependerá de la precisión que necesitemos para nuestro proyecto. A través de la programación podremos cambiar dicha resolución pero todo eso lo veremos más adelante.
Otras características del sensor de temperatura DS18B20
Además de medir la temperatura, el DS18B20 incorpora una memoria de 64-bit (equivalente a 8 bytes) para almacenar el identificador o dirección única de cada sensor.
El primer byte identifica el tipo de componente. Por ejemplo para los DS18B20 es el número 28 en hexadecimal.
Esta dirección única es necesaria dentro del bus 1-Wire para identificar cada uno de los sensores de temperatura DS18B20 conectados al bus de comunicación.
Gracias a que utiliza este tipo de comunicaciones, se consiguen dos cosas. Por un lado robustez en la transmisión de los datos ya que trabaja con datos digitales, mucho menos sensibles a los efectos adversos del ruido que las señales analógicas. Por otro lado permite conectar muchos sensores de temperatura con un único pin digital.
Internamente tiene otro tipo de memoria que sirve para diferentes cosas. Utiliza el sistema de verificación de redundancia cíclica CRC para la detección de errores en los datos. El código CRC se almacena en la memoria.
También almacena la temperatura obtenida y dispone de dos alarmas que se disparan si la temperatura es mayor o menor que un umbral de temperatura máxima o temperatura mínima.
Con todo estas características, el DS18B20 se convierte en un sensor bastante potente con unas capacidades superiores a otros en el mismo rango de precios. Estamos hablando que el precio de este sensor oscila entre 1€ y 3€, casi despreciable.
Resumen de las características técnicas del DS18B20
| Característica | Valor |
|---|---|
| Voltaje de alimentación | 3V a 5,5V |
| VDD | voltaje de alimentación |
| GND | Tierra |
| DQ | Datos |
| Rango de temperaturas | -55ºC a 125ºC |
| Error (-10ºC a 85ºC) | ±0,5ºC |
| Error (-55ºC a 125ºC) | ±2ºC |
| Resolución programable | 9-bit, 10-bit, 11-bit o 12-bit (default) |
Conexión del DS18B20 con Arduino
Una vez que entendemos cómo funciona el sensor de temperatura DS18B20 y, sobre todo, cuales son sus características técnicas más importantes, vamos a pasar al montaje eléctrico con Arduino. Como supondrás, todo este montaje se hace entorno al protocolo 1-Wire.
Esto no es único del DS18B20, cualquier otro componente que trabaje con el protocolo 1-Wire, utilizará la misma configuración eléctrica.
Ya hemos visto que podemos trabajar con diferentes encapsulados. En este tutorial voy a centrarme en el TO-92 y más concreto el que viene en forma de sonda impermeable. Si tienes otro modelo o incluso el mismo sin sonda los pasos serán prácticamente los mismos.
#1 ¿Cómo conectamos los cables de la sonda DS18B20 a una protoboard o a Arduino?
Estamos acostumbrados a que cualquier componente que compremos venga con conectores fáciles de utilizar o con algún cable tipo dupont semirigido. En este caso, la sonda impermeable lleva unos cables normales sin conectores de metal.
En principio esto podría ser un impedimento pero podemos resolverlo de diferentes formas. Mi opción puede que no sea la más óptima o la más elegante, pero es la que mejor se adapta a la hora de prototipar con cualquier placa ya sea un Arduino o un ESP8266.
Simplemente voy a coger un cable dupont hembra (este tipo de cables son los que suelen venir en casi todos los kit de Arduino) y conectaré cada terminal en cada cable dupont.
Es interesante aunque no obligatorio que los cables sean del mismo color, así no te equivocarás. Ahora seguramente los puristas (entre ellos yo) estarán diciendo, “vaya chapuza de conexiones :)”. Efectivamente es una chapuza, aunque no es la conexión definitiva 😉
El objetivo es ponernos en acción lo más rápido posible, no entrar en parálisis por análisis. Tenemos que ser ágiles y empezar a trabajar ya. Solo así coseguiremos avanzar y por lo tanto aprender.
Mi opción final ha sido soldar los cables y dejar en el extremo un conector de metal para prototipar rápido.
#2 Identificando los cables y pines del DS18B20
La distribución de los pines dependerá del encapsulado. En cualquier caso siempre vamos a trabajar con tres pines. Un pin para alimentación VDD, un pin para tierra GND y un pin para la transmisión de datos DQ.
Con el modelo TO-92 no vamos a tener ningún problema. Estos serían los pines.
Sin embargo, cuando compramos un DS18B20 en una sonda impermeable no vemos el propio sensor, solo vemos los cables.
Tenemos diferentes configuraciones de colores en los cables. En concreto vamos a encontrar tres.
El tipo clave 1 donde:
- Cable rojo: VDD
- Cable negro: GND
- Cable amarillo: DQ
Imagen obtenida del Datasheet Waterproof
El tipo clave 2 donde:
- Cable rojo: VDD
- Cable verde: GND
- Cable amarillo: DQ
El tipo clave 3 donde:
- Cable rojo: VDD
- Cable verde: DQ
- Cable amarillo: GND
Si tenemos el tipo A, no tendremos problema solo hay una configuración. Si tenemos alguno de los otros, tendremos un problema 🙁
No sabemos como se debe de conectar así que la recomendación es primero buscar el fabricante (tarea muy complicada si lo has comprado en Aliexpress o alguna otra tienda de China). La segunda opción es probar las dos conexiones para ver cual es la que funciona.
Elige primero el tipo 2, es la configuración mas habitual y lo mismo tienes suerte como yo 🙂
Para finalizar esta sección te dejo un resumen de todas las conexiones.
| Sensor tipo 1 | Sensor tipo 2 | Sensor tipo 3 | Pin DS18B20 |
|---|---|---|---|
| Negro | Verde | Amarillo | GND |
| Rojo | Rojo | Rojo | Vdd |
| Amarillo | Amarillo | Verde | DQ |
Aunque los colores más típicos son los que he comentado aquí, también puedes encontrarte otras configuraciones de colores. He podido comprobar como hay sondas impermeables del DS18B20 donde el cable verde es de color azul. Sigue los mismos pasos expuestos anteriormente para identificar cada conector.
#3 Conexión de los pines del sensor de temperatura DS18B20 con Arduino
Ya estamos preparados para comenzar a conectar el DS18B20 a Arduino. Sin embargo, antes de hacerlo tenemos que conocer que existen dos formas de alimentar el DS18B20. La primera sería la más simple y sería a través del pin VDD. La segunda opción sería hacerlo a través del propio pin de datos DQ, en modo parásito.
En los dos modos posibles, siempre se pone una resistencia pull-up con el pin DQ. El motivo de esta resistencia es debido a la electrónica para controlar el bus de comunicación. Utiliza un FET de drenaje abierto que se comporta como una puerta AND.
Cuando todos los sensores conectados al bus 1-Wire no envíen datos, la línea de datos será igual a la tensión que suministremos (puede ser de 3V a 5,5V) debido a la resistencia pull-up. En el momento que un sensor empieza a transmitir, la línea cambia de estado y ya sabemos que hay un sensor transmitiendo datos.
Lo único que nos quedaría es determinar la resistencia pull-up. Como ya te he comentado nos servirá para tener en pin DQ siempre un modo alto o HIGH. La resistencia que se vaya a utilizar dependerá de la longitud del cable. Por norma general utilizaremos siempre una de 4,7 kΩ.
En la siguiente tabla puedes ver la resistencia más adecuada dependiendo de la longitud del cable de datos.
| Resistencia pull-up | Distancia del cable (metros) |
|---|---|
| 4,7 kΩ | De 0 m a 5 m |
| 3,3 kΩ | De 5 m a 10 m |
| 2,2 kΩ | De 10 m a 20 m |
| 1,2 kΩ | De 20 m a 50 m |
Modo alimentación por el pin VDD
Recuerda que la alimentación por este pin es desde 3V a 5,5V. No sobrepases el máximo valor o dañarás el sensor de temperatura DS18B20.
El esquema de conexión para Arduino UNO sería el siguiente.
En el circuito he conectado dos sensores DS18B20. Da lo mismo los que conectes, todos ellos comparten la resistencia pull-up del pin de datos. Luego una de las patillas va a tierra (GND) y la otra va a alimentación (VDD). Es relativamente sencillo y no tiene mayor complicación 🙂
Modo alimentación parásito por el pin DQ
El otro modo nos permite alimentar el sensor de temperatura DS18B20 a través del pin de datos DQ. A esta configuración se le llama modo parásito.
El esquema de conexión para Arduino UNO sería el siguiente.
La conexiones del pin DQ y de GND son las mismas que en el ejemplo anterior. La diferencia está en que el pin VDD lo conectamos a tierra. Asegúrate de que todos los sensores tienen este pin a tierra (GND).
Con este último ejemplo ya tenemos el circuito preparado para empezar a programar. Da lo mismo el modo que utilices, las dos configuraciones se programan igual.
Programando el sensor de temperatura DS18B20
Quizás sea una de las tareas más complejas del DS18B20 debido al protocolo 1-Wire que utiliza este sensor. Pero gracias a las librerías de Arduino, nuestras grandes amigas, va a resultar muy sencillo.
La primera parte es hacernos un esquema de lo que queremos hacer. Esto siempre ayuda a programar.
Librerías y variables del programa
En la primera parte del programa vamos a incluir las librerías OneWire y DallasTemperature. Solo tienes que buscar e instalar la librería a través del Gestor de Librerías.
El código de esta parte sería el siguiente.
|
#include #include // Pin donde se conecta el bus 1-Wire const int pinDatosDQ = 9; // Instancia a las clases OneWire y DallasTemperature OneWire oneWireObjeto(pinDatosDQ); DallasTemperature sensorDS18B20(&oneWireObjeto); |
Lo primero es incluir las librerías en el código tanto OneWire, es la que implementa el protocolo 1-Wire, como DallasTemperature, implementa el código para enviar los comandos adecuados a los sensores y obtener la temperatura.
Por norma siempre utilizamos una variable (se aconseja que sea una constante) para indicar el número del pin donde tenemos conectado los sensores. Este pin es el marcado como DQ.
Por último declaramos dos objetos de las clases OneWire y DallasTemperature. Como veremos posteriormente, solo utilizaremos este último que es el que nos da acceso a los sensores de temperatura DS18B20.
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Cuando una variable la pasamos con el símbolo &nombreVariable, estamos pasando la posición de memoria donde se almacenan los datos y no su valor. A esto se le llama paso por referencia. Esto es lo que hacemos al pasar el argumento al constructor de la clase DallasTemperature.
Función setup()
El código de la función setup() es muy sencillo.
|
void setup() { // Iniciamos la comunicación serie Serial.begin(9600); // Iniciamos el bus 1-Wire sensorDS18B20.begin(); } |
Lo primero que hacemos es iniciar la comunicación con el monitor serie indicando la velocidad de transmisión con Serial.begin(). Luego iniciamos el bus de comunicación 1-Wire llamando a la función sensorDS18B20.begin() que no admite ningún parámetro.
Función loop()
En esta función accederemos a los sensores a través del bus 1-Wire y mostraremos los datos por el monitor serie.
|
void loop() { // Mandamos comandos para toma de temperatura a los sensores Serial.println(“Mandando comandos a los sensores”); sensorDS18B20.requestTemperatures(); // Leemos y mostramos los datos de los sensores DS18B20 Serial.print(“Temperatura sensor 0: “); Serial.print(sensorDS18B20.getTempCByIndex(0)); Serial.println(” C”); Serial.print(“Temperatura sensor 1: “); Serial.print(sensorDS18B20.getTempCByIndex(1)); Serial.println(” C”);
delay(1000); } |
Lo primero mostramos un mensaje para indicar que estamos enviando los comandos necesarios a los sensores para que empiecen a leer la temperatura. Luego llamamos a la función sensorDS18B20.requestTemperatures() que envía dichos comandos.
Una vez que los sensores lo han recibido, ya han tomado la temperatura y la tienen lista para enviarla a Arduino. Para solicitar dicha temperatura hacemos una llamada a la función sensorDS18B20.getTempCByIndex(indice_sensor).
Vamos a parar a analizar esta función. Si tenemos varios sensores conectados en serie con Arduino, los podemos identificar de diferentes maneras. La más rápida es a través de un índice. A cada uno de ellos se le asigna un número en orden secuencial.
Si tenemos 2 sensores, sus índices serán 0 y 1. Si tuviéramos 5 sensores sus índices serían 0, 1, 2, 3 y 4. Así sucesivamente. Si tenemos solo un sensor, el índice que debemos utilizar es el 0.
Además esta función nos devuelve la temperatura en grados Celsius. Esto viene indicado por TempC.
Código completo
Aquí te dejo todo el código completo. Puedes copiarlo y utilizarlo en tus proyectos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
#include #include // Pin donde se conecta el bus 1-Wire const int pinDatosDQ = 9; // Instancia a las clases OneWire y DallasTemperature OneWire oneWireObjeto(pinDatosDQ); DallasTemperature sensorDS18B20(&oneWireObjeto); void setup() { // Iniciamos la comunicación serie Serial.begin(9600); // Iniciamos el bus 1-Wire sensorDS18B20.begin(); } void loop() { // Mandamos comandos para toma de temperatura a los sensores Serial.println(“Mandando comandos a los sensores”); sensorDS18B20.requestTemperatures(); // Leemos y mostramos los datos de los sensores DS18B20 Serial.print(“Temperatura sensor 0: “); Serial.print(sensorDS18B20.getTempCByIndex(0)); Serial.println(” C”); Serial.print(“Temperatura sensor 1: “); Serial.print(sensorDS18B20.getTempCByIndex(1)); Serial.println(” C”);
delay(1000); } |
Si cargas este código te deberá aparecer algo parecido a esto en el monitor serie.
Ahora surge una duda. Imagínate que quieres monitorizar un frigorífico tanto la parte de arriba como el congelador. Te gustaría saber cual es cada sensor. Si recuerdas, anteriormente te he dicho que cada uno de los sensores está identificado con un número de 64-bit, el identificador o dirección única.
Lo ideal sería identificar cada uno de los sensores que hemos conectado a Arduino, eso es lo que vamos a ver a continuación.
Identificar cada sensor de temperatura DS18B20
Para identificar un único sensor vamos a partir del siguiente esquema eléctrico donde solo tenemos un sensor conectado. Esto lo tendrás que repetir con cada sensor. Voy a utiliza la configuración de alimentación modo parásito, alimentación por el pin de datos DQ.
Podemos optar por otras opciones como diferenciar los sensores a través de la temperatura. Por ejemplo, pones uno en una estufa y el otro lo pones en temperatura ambiente, verás como notas las diferencias. Sin embargo, a nivel de código esto puede resultar más complicado.
Lo importante de esta sección es identificar la dirección única de 64-bit (8 bytes) de cada sensor. Esto es debido a que la implementación de la librería DallasTemperature es más rápida cuando trabajamos con estos identificadores y no con los índices que asigna de forma automática.
Programando la identificación del DS18B20
Como hemos hecho en el ejercicio anterior, vamos a mostrar un diagrama de lo que vamos a programar con este circuito. Normalmente no es necesario hacer esto, sobre todo si ya tienes experiencia programando Arduino.
Pero si estás empezando es más que recomendable hacerte un esquema de lo que tienes que hacer antes de empezar. En este caso vamos a hacer los siguiente.
Librerías y variables del programa
La primera parte es la misma que en el ejemplo anterior. Incluimos las librerías OneWire y DallasTemperature y declaramos las variables y clases.
|
#include #include // Pin donde se conecta el bus 1-Wire const int pinDatosDQ = 9; // Instancia a las clases OneWire y DallasTemperature OneWire oneWireObjeto(pinDatosDQ); DallasTemperature sensorDS18B20(&oneWireObjeto); |
Función setup()
En este caso vamos a hacer todo en la función setup(). Solo queremos saber la dirección única que tiene el sensor que hemos conectado a nuestro Arduino.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
void setup() { // Iniciamos monitor serie y sensor de temperatura DS18B20 Serial.begin(9600); sensorDS18B20.begin(); // Buscamos los sensores conectados Serial.println(“Buscando dispositivos…”); Serial.print(“Encontrados: “); int numeroSensoresConectados = sensorDS18B20.getDeviceCount(); Serial.print(numeroSensoresConectados); Serial.println(” sensores”); // Si hemos encontrado uno mostramos su dirección if(numeroSensoresConectados==1){
// Tipo definido como una array de 8 bytes (uint8_t) DeviceAddress sensorTemperatura; // Obtenemos dirección sensorDS18B20.getAddress(sensorTemperatura, 1); // Mostamos por el monitor serie Serial.print(“Sensor encontrado: “); // Recorremos los 8 bytes del identificador único for (uint8_t i = 0; i < 8; i++) { // Si solo tiene un dígito rellenamos con un cero a la izquierda if (sensorTemperatura[i] < 16) Serial.print(“0”); // Mostramos los datos que van en HEXADECIMAL Serial.print(sensorTemperatura[i], HEX); } } } |
Lo primero es iniciacilizar el monitor serie y el bus de comunicación 1-Wire con Serial.begin() y sensorDS18B20.begin(). No es nada nuevo.
Una vez que esté todo correcto comenzamos comprobando si hay algún sensor conectado al bus 1-Wire. Esto lo hacemos con el método sensorDS18B20.getDeviceCount(). Este método nos devuelve un número entero con los sensores conectados al bus.
Puede ser muy útil para saber que todo está funcionando correctamente. Imagínate que tienes 3 sensores conectados a Arduino. Lo primero que haces en tu programa es comprobar que estén conectados si no lo estuvieran podrías parar la ejecución y alertar de que algo está mal.
Lo siguiente es comprobar que solo tengamos conectado un único sensor a través de la sentencia de control if(…). Te recuerdo que este programa solo nos va a servir para detectar la dirección de un único sensor.
¿Quieres montar tu primer proyecto con Arduino?
Con este curso gratuito crearás un Sistema de Riego Automático con Arduino, paso a paso y en sólo una semana.
Una vez comprobado declaramos una variable del tipo DeviceAddress que no es más que un array de 8 bytes. Si recuerdas, la dirección única tiene 64-bit (8 bytes) y la almacenaremos en esta variable. Cada byte en un elemento del array.
La propia librería ya incorpora un tipo de dato específico para esta dirección, DeviceAddress. Es conveniente utilizarlas así no tendremos ningún error y quedará todo bastante más claro.
Todo esto lo mostramos a través del monitor serie. Debido a que es un array de 8 elementos, tenemos que recorrerlo con un bucle for(…). Luego mostramos cada dígito en el monitor serie teniendo en cuenta de que si un número es menor que 16, lo rellenaremos con un cero a la izquierda.
Esto es debido a que en el sistema hexadecimal, los primeros 16 números solo tienen 1 dígito (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F).
Ejecutando el código de identificador del DS18B20
Este sería el código completo de la aplicación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
#include #include // Pin donde se conecta el bus 1-Wire const int pinDatosDQ = 9; // Instancia a las clases OneWire y DallasTemperature OneWire oneWireObjeto(pinDatosDQ); DallasTemperature sensorDS18B20(&oneWireObjeto); void setup() { // Iniciamos monitor serie y sensor de temperatura DS18B20 Serial.begin(9600); sensorDS18B20.begin(); // Buscamos los sensores conectados Serial.println(“Buscando dispositivos…”); Serial.println(“Encontrados: “); int numeroSensoresConectados = sensorDS18B20.getDeviceCount(); Serial.print(numeroSensoresConectados); Serial.println(” sensores”); // Si hemos encontrado uno mostramos su dirección if(numeroSensoresConectados==1){
// Tipo definido como una array de 8 bytes (uint8_t) DeviceAddress sensorTemperatura; // Obtenemos dirección sensorDS18B20.getAddress(sensorTemperatura, 1); // Mostamos por el monitor serie Serial.print(“Sensor encontrado: “); // Recorremos los 8 bytes del identificador único for (uint8_t i = 0; i < 8; i++) { // Si solo tiene un dígito rellenamos con un cero a la izquierda if (sensorTemperatura[i] < 16) Serial.print(“0”); // Mostramos los datos que van en HEXADECIMAL Serial.print(sensorTemperatura[i], HEX); } } } void loop() { } |
Si cargas el código anterior en tu Arduino y tienes todo bien conectado te deberá aparecer algo parecido a esto en el monitor serie.
|
Buscando dispositivos... Encontrados: 1 sensores Sensor encontrado: 28A8F8E708000091 |
La dirección única será diferente para cada sensor de temperatura DS18B20. Esa es la información importante que tendrás que guardar y relacionar con el sensor. Lo puedes pegar con una etiqueta o como quieras hacerlo. Luego en el código lo utilizaremos para obtener la temperatura de ese sensor.
Incluso como ves en la foto, puedes poner algo descriptivo que te indique donde vas a poner ese sensor.
Una vez que tengas identificado el sensor ya puedes conectar otro e ir identificando cada uno de ellos. En mi caso tengo cuatro que voy a utilizar para el proyecto IoT Fridge Saver. Dos sondas van al frigorífico y al congelador. Otras dos van a tomar la temperatura de la parte delantera y trasera del electrodoméstico.
Por último, vamos a ver cómo accederíamos a los datos de temperatura a través de la dirección única de cada sensor de temperatura DS18B20.
Accediendo a la temperatura del DS18B20 por su dirección única
Hasta ahora lo que hemos hecho es acceder a la temperatura del DS18B20 a través del índice que ocupa en el bus de comunciación. Esto es un poco peligroso ya que no tenemos control sobre ese orden, podría variar con alguna modificación en el circuito.
Por eso es importante conocer la dirección única. En la sección anterior ya hemos identificado cada sensor, ahora ya podemos programar y ser conscientes de la temperatura que nos da cada uno de ellos.
Librerías y variables del programa
|
#include #include // Pin donde se conecta el bus 1-Wire const int pinDatosDQ = 9; // Instancia a las clases OneWire y DallasTemperature OneWire oneWireObjeto(pinDatosDQ); DallasTemperature sensorDS18B20(&oneWireObjeto); // Variables con las direcciones únicas de los 4 sensores DS18B20 DeviceAddress sensorFrigorifico = {0x28, 0xA8, 0xF8, 0xE7, 0x08, 0x00, 0x00, 0x91}; DeviceAddress sensorCongelador = {0x28, 0x6F, 0xB6, 0xC6, 0x08, 0x00, 0x00, 0x3F}; DeviceAddress sensorDelante = {0x28, 0xA4, 0x29, 0xE6, 0x08, 0x00, 0x00, 0xF0}; DeviceAddress sensorAtras = {0x28, 0x45, 0x92, 0xE6, 0x08, 0x00, 0x00, 0xD1}; |
Las librerías ya las conoces OneWire y DallasTemperature. También tienes que declarar una constante para el pin DQ e instanciar las dos clases OneWire y DallasTemperature. Nada nuevo por ahora.
En la parte final, declaramos 4 variables del tipo DeviceAddress. Como ya te he comentado, este tipo representa un array de 8 elementos. Cada uno de ellos es 1 byte. Ahora tienes que rescatar las direcciones únicas que hemos sacado anteriormente.
Para asignar el valor a cada variable tienes que hacer grupos de dos. Cada grupo irá en un elemento del array y en total son 8 elementos que equivalen a 8 bytes (64-bit como hemos visto en la parte de las características técnicas).
Fíjate bien en los nombres, aquí se pone de manifiesto la utilidad de las variables. Le vamos a dar a cada dirección un descriptivo. Esta variable almacenará la dirección única, pero será fácilmente recordada gracias la nombre de la variable.
Nombrar variables es algo muy personal. Mi consejo es que te acostumbres a poner nombres lo más descriptivo posible.
Función setup()
|
void setup() { // Iniciamos la comunicación serie Serial.begin(9600); // Iniciamos el bus 1-Wire sensorDS18B20.begin(); // Buscamos los sensores conectados Serial.println(“Buscando dispositivos…”); Serial.println(“Encontrados: “); Serial.print(sensorDS18B20.getDeviceCount()); Serial.println(” sensores”); } |
Comenzamos la función setup() iniciando el monitor serie con Serial.begin() y el protocolo 1-Wire con sensorDS18B20().
Luego como hemos visto en el ejemplo de identificación buscamos todos los dispositivos conectados al bus con la función sensorDS18B20.getDeviceCount(). En mi caso me debería dar 4 sensores, si fueran menos es que hay algún error de conexión.
En las pruebas realizadas he tenido problemas con las conexiones. En el momento que falla alguno de los sensores, tira el bus 1-Wire abajo y se desconectan todos los sensores.
Función loop()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
void loop() { // Mandamos comandos para toma de temperatura a los sensores Serial.println(“Mandando comandos a los sensores”); sensorDS18B20.requestTemperatures(); // Leemos y mostramos los datos de los sensores DS18B20 por dirección única Serial.print(“Temperatura sensor frigorifico: “); Serial.print(sensorDS18B20.getTempC(sensorFrigorifico)); Serial.println(” C”); Serial.print(“Temperatura sensor congelador: “); Serial.print(sensorDS18B20.getTempC(sensorCongelador)); Serial.println(” C”); Serial.print(“Temperatura sensor delante: “); Serial.print(sensorDS18B20.getTempC(sensorDelante)); Serial.println(” C”); Serial.print(“Temperatura sensor detras: “); Serial.print(sensorDS18B20.getTempC(sensorAtras)); Serial.println(” C”); delay(1000); } |
En la función loop() vamos a acceder a la temperatura de los cuatro sensores DS18B20. Comenzamos enviando los comandos pertinentes para que los sensores empiecen a medir. Esto lo hacemos con la función sensorDS18B20.requestTemperatures().
Luego mostramos la temperatura de cada sensor. Como ya tenemos identificados cada uno de ellos, mostramos dónde es esa temperatura. Para acceder a la temperatura ya no utilizamos la función getTempCByIndex(). Ahora utilizamos sensorDS18B20.getTempC() al que pasamos como argumento el array de 8 bytes definido por el tipo DeviceAddress.
Por último hacemos una pausa de 1 segundo para cada medición.
Si quieres almacenar la temperatura en una variable debe ser del tipo float.
|
float temperaturaCongelador = sensorDS18B20.getTempC(sensorCongelador); |
Funciones más importantes de la librería DallasTemperature
Para terminar este extenso artículo, voy a numerar y explicar las funciones más importantes (a mi entender) de la librería DallasTemperature. Hay muchas más que puedes inspeccionar en el código de la librería en GitHub.
uint8_t getDeviceCount(void)
Devuelve el número de dispositivos conectados al bus 1-Wire en un entero sin signo de 8-bit.
|
// Buscamos los sensores conectados Serial.println(“Buscando dispositivos…”); Serial.println(“Encontrados: “); Serial.print(sensorDS18B20.getDeviceCount()); Serial.println(” sensores”); |
bool getAddress(uint8_t*, uint8_t)
Obtiene la dirección única de un dispositivo dado un índice en el bus 1-Wire. Devuelve verdadero (true) si se encuentra el dispositivo.
|
// Tipo definido como una array de 8 bytes (uint8_t) DeviceAddress sensorTemperatura; // Obtenemos dirección sensorDS18B20.getAddress(sensorTemperatura, 0); |
bool isConnected(const uint8_t*)
Comprueba si un sensor está conectado al bus 1-Wire dado una dirección única.
|
// Tipo definido como una array de 8 bytes (uint8_t) DeviceAddress sensorTemperatura = {0x28, 0xA8, 0xF8, 0xE7, 0x08, 0x00, 0x00, 0x91}; // Obtenemos dirección if(sensorDS18B20.isConnected(sensorTemperatura)){ // Obtener temperatura float temperatura = sensorDS18B20.getTempC(sensorTemperatura); } |
uint8_t getResolution()
Obtiene la resolución global de todos los sensores. Devuelve un valor entero sin signo de 8-bit con la resolución. Recuerda que ésta puede ser de 9-bit, 10-bit, 11-bit o 12-bit.
|
// Obtenemos la resolución global uint8_t resolucionGlobal = sensorDS18B20.getResolution(); |
void setResolution(uint8_t)
Establece la resolución de un sensor dado su índice en el bus 1-Wire. No devuelve ningún valor.
|
// Establecemos al resolución del sensor con índice 0 sensorDS18B20.setResolution(0); |
uint8_t getResolution(const uint8_t*)
Obtiene la resolución de un sensor dado su dirección única. Devuelve el valor de la resolución.
|
// Obtenemos la resolución global uint8_t resolucionGlobal = sensorDS18B20.getResolution(sensorCongelador); |
Si te das cuentas hay dos funciones con el mismo nombre getResolution(). A esto se le llama sobrecargar un método y la clase que lo implementa es lo suficientemente lista como para saber cual tiene que ejecutar dependiendo del número de argumentos que pases a la función.
void requestTemperatures(void)
Envía los comandos a los sensores para que hagan la lectura de la temperatura.
|
// Mandamos comandos para toma de temperatura a los sensores Serial.println(“Mandando comandos a los sensores”); sensorDS18B20.requestTemperatures(); |
bool requestTemperaturesByAddress(const uint8_t*)
Igual que la función anterior pero este solo envía los comandos para que un solo dispositivo haga la lectura de temperatura dado una dirección única.
|
// Mandamos comandos para toma de temperatura del sensor del congelador Serial.println(“Mandando comandos a los sensores”); sensorDS18B20.requestTemperaturesByAddress(sensorCongelador); |
bool requestTemperaturesByIndex(uint8_t)
Igual que los dos anteriores pero dado el índice del sensor de temperatura DS18B20 dentro del bus 1-Wire.
|
// Mandamos comandos para toma de temperatura del sensor 0 Serial.println(“Mandando comandos a los sensores”); sensorDS18B20.requestTemperaturesByIndex(0); |
float getTempC(const uint8_t*)
Obtiene la temperatura en grados Celsius dada la dirección única del sensor. Devuelve la temperatura en un tipo de dato float.
|
Serial.print(“Temperatura sensor congelador: “); float temperaturaCongeladorCelsius = sensorDS18B20.getTempC(sensorCongelador); Serial.print(temperaturaCongeladorCelsius); Serial.println(” C”); |
float getTempF(const uint8_t*)
Obtiene la temperatura en grados Fahrenheit dada la dirección única del sensor. Devuelve la temperatura en un tipo de dato float.
|
Serial.print(“Temperatura sensor congelador: “); float temperaturaCongeladorFahrenheit = sensorDS18B20.getTempC(sensorCongelador); Serial.print(temperaturaCongeladorFahrenheit); Serial.println(” F”); |
float getTempCByIndex(uint8_t)
Obtiene la temperatura en grados Celsius dado el índice del sensor dentro del bus 1-Wire. Devuelve la temperatura en un tipo de dato float.
|
Serial.print(“Temperatura sensor 0: “); float temperaturaCongeladorCelsius = sensorDS18B20.getTempCByIndex(0); Serial.print(temperaturaCongeladorCelsius ); Serial.println(” C”); |
float getTempFByIndex(uint8_t)
Obtiene la temperatura en grados Fahrenheit dado el índice del sensor dentro del bus 1-Wire. Devuelve la temperatura en un tipo de dato float.
|
Serial.print(“Temperatura sensor 0: “); float temperaturaCongeladorFahrenheit = sensorDS18B20.getTempCByIndex(0); Serial.print(temperaturaCongeladorFahrenheit); Serial.println(” F”); |
Sensor de temperatura DS18B20, conclusiones
Quizás no sea el sensor más preciso que hay en el mercado, ni el más sencillo. Sin embargo, el sensor de temperatura DS18B20 tiene tres características que lo hacen un componente muy deseable.
Su bajo precio, entre 1€ y 3€, junto con la precisión de 0,5ºC en el rango de vida humana, son factores importantes a la hora de elegir el DS18B20 para nuestros proyectos. Además, permite la conexión en serie de bastantes sensores gracias al bus 1-Wire que viene implementado en el dispositivo.
Si a esto le añadimos que podemos comprar la versión que viene en forma de sonda impermeable, definitivamente tenemos un sensor muy versátil que puede llegar a medir temperaturas en entornos muy húmedos e incluso dentro de líquidos.
¿Dónde utilizarías el sensor DS18B20?
¿Conoces algún modelo más del sensor de temperatura DS18B20?
Cualquier comentario te agradecería que lo dejaras en este artículo.
Te recomiendo que leas los artículos que te dejo a continuación para profundizar más en este sensor.
