El DS18B20 es un sensor de temperatura en el cual se lleva la conversión analógico a digital dentro del encapsulado, facilitando el resultado de dicha conversión a través de una interfaz digital llamada 1-wire.
El sensor de temperatura DS18B20 se puede encontrar en diversas formas, entre las cuales destacamos 2 que son bastante comunes:
- El encapsulado TO-92 (usado comúnmente en transistores).
- El sensor tipo sumergible, que es fabricado por terceros utilizando sensores en encapsulado TO-92 colocados dentro de una cubierta impermeable de acero inoxidable.
En esta entrada estudiamos el proceso de comunicación con dispositivos 1-wire utilizando como ejemplo el DS18B20.
Materiales necesarios para las practicas
Para realizar los experimentos con el sensor DS18B20 recomendamos como mínimo el siguiente material:
- Arduino UNO R3
- Protoboard
- Cables para conexiones
- Resistencias 4.7 K 1/4 W
- Sensor de temperatura DS18B20
Teoría y conceptos básicos
En esta sección daremos detalles de cómo se comunica el sensor DS18B20 con el Arduino. No te preocupes, esta parte NO tendrás que implementarla por tu cuenta, pero del objetivo de este blog es aprender, así que te servirá conocer los conceptos básicos de 1-Wire.
El sensor DS18B20 utiliza una interfaz digital propietaria para transferir la información hacia el microcontrolador conocida como “1-Wire”. Como el nombre lo indica, solamente requerimos una linea de datos (además de la alimentación) entre el microcontrolador y uno o varios dispositivos que participan en el bus.
El bus 1-Wire consiste en un esquema de señalización, direccionamiento y arbitraje que permite comunicaciones bidireccionales entre un dispositivo maestro y uno o varios periféricos (esclavos) sobre un solo hilo de cobre o pista de circuito impreso.
La siguiente imagen muestra la conexión típica de un microcontrolador con dispositivos 1-wire:
Operaciones sobre el bus 1-wire
En realidad las operaciones básicas del bus 1-wire son bastante sencillas y son las siguientes:
- Reset – El esclavo envía un pulso de 480 microsegundos y luego “deja flotar” el bus, el esclavo (o esclavos) responden “jalando” el bus a estado bajo (pulso de presencia). Esta operación sincroniza el bus e indica a los esclavos que el master va a enviar información.
- Escribir bit 0 – El maestro envía un pulso de estado bajo de 60 microsegundos, luego libera el bus.
- Escribir bit 1 – El maestro envía un pulso en estado bajo de 6 microsegundos, luego libera el bus.
- Leer bit (desde esclavo) – El maestro genera un pulso bajo de 6 microsegundos y luego libera el bus. Si el esclavo desea transmitir un “1”, el esclavo “deja flotar” el bus, si desea enviar un “0”, mantiene un estado lógico bajo.
El dispositivo maestro inicia y controla todas las operaciones anteriores, toda la funcionalidad de 1-Wire se fundamenta en estas 4 sencillas operaciones, incluyendo el descubrimiento y direccionamiento de dispositivos.
La siguiente imagen muestra las operaciones anteriores como se verían en la pantalla de un osciloscopio o analizado lógico, junto con los tiempos correspondientes.
Direccionamiento del bus 1-wire
Una característica distintiva del bus 1-Wire es que cada uno de los dispositivos esclavos tiene un número de serie (dirección) único de 64 bits asignado desde fábrica. Esta dirección jamás se repite en otro dispositivo 1-wire, lo que permite seleccionar un esclavo de entre varios en el bus de comunicaciones.
Dado que en un bus 1-wire pueden coexistir múltiples dispositivos, es necesario conocer la dirección única de cada uno. Para esto se utiliza un algoritmo de búsqueda mediante el cual un dispositivo maestro puede conocer todas las direcciones de los esclavos.
Una vez que el dispositivo maestro conoce las direcciones de los esclavos puede dirigir las comunicaciones y comandos al dispositivo esclavo apropiado.
Algoritmo de búsqueda de dispositivos 1-wire
El algoritmo de búsqueda es en si algo complejo y podría ser tema de otro artículo, por eso de momento no explicaremos a detalle como se maneja el descubrimiento de dispositivos, sin embargo, en el sitio web de Maxim/Dallas Semiconductor hay una explicación bien detallada para quien desea conocer a fondo este proceso.
Para el usuario de Arduino, no es necesario conocer a detalle el proceso, ya que en la mayoría de los casos, este algoritmo es manejado directamente por la(s) librería(s).
Cabe señalar que si usamos un solo dispositivo en el bus, nos podemos comunicar de forma muy sencilla, evitando todo el proceso de descubrimiento de direcciones y la selección el dispositivo esclavo (evitamos la transmisión de 8 bytes). Para esto se utiliza el comando “Skip ROM” que permite justamente eso: seleccionar al único dispositivo esclavo en el bus o transmitir mensajes tipo “broadcast”.
Proceso de comunicación 1-Wire completo
- El proceso de comunicación comienza cuando el maestro genera un pulso de reset, el cual sincroniza todos los dispositivos del bus.
- Después de este pulso se selecciona un dispositivo esclavo para las comunicaciones subsecuentes. Se puede seleccionar un dispositivo esclavo específico (mediante su dirección o número de serie) o enviar un mensaje/comando a todos los dispositivos en el bus.
- Una vez que se ha seleccionado un dispositivo, los otros participantes del bus ignoran los comandos / datos y esperan el próximo reset.
- El dispositivo direccionado puede recibir comandos específicos de acuerdo a su funcionalidad, recibir datos, enviar datos, etc.
El proceso de descubrimiento y selección de dispositivo en el bus 1-wire siempre es el mismo, a pesar de que el protocolo y/o comandos para intercambiar datos puede variar entre distintos dispositivos debido a las diferentes funciones que desempeñan.
Visualización de la comunicación 1 wire
A continuación puedes descargar la captura de un analizador lógico para una comunicación 1wire. Podrás ver la señales que se generaron durante las pruebas que realizamos al escribir este articulo tal como se muestra a continuación.
Para visualizar la comunicación completa, podemos descargar el programa KingstVIS, el cual corresponde a nuestro analizador lógico USB y con el cual se realizaron estas imágenes. Los archivos de las capturas se encuentran disponibles en los siguientes enlaces:
Una instalado el programa y abierto el archivo deberá presentarse una interfaz similar a la que se muestra a continuación:
Características del sensor de temperatura DS18B20
Para conocer las características del sensor DS18B20 la mejor fuente de información es la hoja de datos del dispositivo, que se puede descargar del sitio web oficial o del enlace a continuación:
En esta sección proporcionaremos información resumida sobre este sensor que hemos obtenido desde la hoja de datos y recopilado desde distintas fuentes de internet.
Pinout del sensor DS18B20 y sus distintos encapsulados
Como ya hemos mencionado existen muchas variantes del DS18B20, siendo las más populares la de encapsulado TO-92 y el que viene en una cápsula de acero inoxidable a prueba de agua.
De cuerdo a la hoja de datos, los encapsulados que tenemos disponibles para elegir son los siguientes:
De estos el más común es el TO-92 que puede ser utilizado fácilmente en el protoboard y como se puede observar todos comparten los mismos pines:
- VDD – Se trata del pin por donde el sensor recibe la alimentación. Podemos alimentar nuestro sensor con un voltaje de entre 3.0 y 5.5 volts. Esto es un rango bastante bueno, ya que permite que utilicemos el sensor con placas que funcionan con 3.3 volts como las lineas de producto Arduino MKR o Adafruit Feather.
- GND – Conexión a tierra o masa del circuito.
- DQ – Se trata del pin de comunicación 1-Wire. A través de este pin tiene lugar la comunicación desde y hacia el microcontrolador. Cabe destacar que podemos conectar varios sensores a un solo pin del microcontrolador.
Distribución de señales en el sensor DS18B20 a prueba de agua
El DS18B20 se comercializa en una versión a prueba de agua que puede utilizarse para medir la temperatura de líquidos no corrosivos.La distribución de las señales en este tipo de sensores se muestra en la tabla e imagen a continuación.
| Señal | Color |
|---|---|
| VDD | Rojo |
| GND | Negro |
| DQ | Amarillo o blanco |
Rango de temperaturas y error en el DS18B20
Una característica muy importante al momento de elegir un sensor de temperatura es el rango de temperaturas en el cual puede operar. El DS18B20 utilzarse en un rango de -55 ºC a 125 ºC.
Es importante tomar en cuenta que el error del sensor es diferente según la temperatura a la que está operando. Para temperaturas entre -10ºC y 85ºC existe un error de ±0.5 ºC. Para el resto de temperaturas entre -55 ºC y 125 ºC el error es de ±2 ºC.
Lo anterior quiere decir que a 25 ºC la temperatura real estará entre 24.5 y 25.5, mientras que a 90 ºC la temperatura real podría estar entre 88 ºC y 92 ºC.
Resolución de las mediciones con DS18B20
La resolución de la medición de temperatura puede configurarse según los requisitos de nuestra aplicación.
Las resoluciones disponibles se resumen a continuación:
| Resolución | Temperatura por LSB |
|---|---|
| 9 bits | 0.5 ºC |
| 10 bits | 0.25 ºC |
| 11 bits | 0.125 ºC |
| 12 bits | 0.0625 ºC |
¿Cómo conectar el DS18B20 con Arduino?
Para conectar un sensor DS18B20 se requieren 3 conexiones básicas.
- Alimentación de 5 volts (VDD).
- Tierra del circuito (GND).
- Linea de transmisión de datos 1-Wire incluyendo una resistencia pull-up (DQ).
La conexión de alimentación de 5 volts es opcional y podemos retirarla si utilizamos la alimentación en modo parásito. En esta modalidad la linea de datos proporciona alimentación al dispositivo a través del pin DQ, haciendo que podamos omitir la linea de alimentación (VDD).
A continuación expondremos varios tipos de conexiones que se pueden realizar con el sensor DS18B20, nos daremos cuenta que se trata de un componente bastante versátil.
Valores de resistencias pull-up para DS18B20
Para que la comunicación con el DS18B20 funcione, requerimos una resistencia “pull-up” en el pin DQ.
La siguiente tabla resume los valores de resistencias pull-up que sugerimos emplear de acuerdo a la distancia a la que colocaremos el sensor (longitud del cable).
Podemos experimentar colocando la resistencia en el lado del sensor o del microcontrolador hasta conseguir el mejor resultado en distancias grandes.
| Distancia | Valor de resistencia |
|---|---|
| Hasta 5 metros | 4.7 kΩ |
| 5 a 10 metros | 3.3 kΩ |
| 10 a 20 metros | 2.2 kΩ |
| 20 a 50 metros | 1.2 kΩ |
Conexión de un solo sensor de temperatura DS18B20
La conexión de un DS18B20 con el arduino debe realizarse de la siguiente forma:
Conexión de varios sensores de temperatura DS18B20 en un mismo pin
La conexión de varios DS18B20 se realiza de forma similar a la anterior. Todos los sensores adicionales se colocan en paralelo con el primero, permitiendo de esta forma que la señal 1-wire llegue a todos los dispositivos.
Conexión para modo de alimentación parásito
Como ya mencionamos el DS18B20 se puede conectar de forma que reciba alimentación a través del pin DQ.
Para esta modalidad deberemos conectar el sensor como se muestra a continuación. La alimentación del sensor se realizará a través de la resistencia pull-up.
Librería para sensor DS18B20 con Arduino
Se requieren 2 librerías para podernos comunicar con un sensor DS18B20. La primera es la librería “OneWire” y la segunda es la librería “DallasTemperature”.
La primera librería se encarga de los detalles de bajo nivel del protocolo de comunicación, mientras que la segunda se encarga específicamente de la funcionalidad del sensor DS18B20 (y otros sensores similares).
Los enlaces a los repositorios son los siguientes:
También podemos instalar las librerías requeridas mediante el gestor de librerías de acuerdo a lo que ya hemos estudiado en el blog tal como se muestra en la imagen a continuación.
Programación de un sensor DS18B20 con Arduino
Leer un sensor DS18B20 con Arduino usando solo la librería OneWire
En este ejemplo realizamos la comunicación con un DS18B20 en su forma más simple, para obtener la lectura de temperatura y finalmente imprimir a la terminal serial.
Utilizando programa a continuación, no requerimos hacer la búsqueda de dispositivos ni enviar la dirección del DS18B20, lo que es más, no requerimos una librería específica para el DS18B20, solamente usamos la librería genérica OneWire.
La desventaja es que solo podremos tener conectado un sensor DS18B20 por pin en un momento dado, ya que no realizamos la búsqueda de dispositivos ni se utilizan las direcciones de 64 bits.
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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | /** Geek Factory - "Innovating together" Distribucion de materiales para el desarrollo e innovacion tecnologica www.geekfactory.mx Programa para leer un sensor DS18B20 sin utilizar la librería DallasTemperature. En este programa se puede apreciar como realizar la comunicacion con un sensor utilizando la librería OneWire solamente. */ #include <Arduino.h> #include <OneWire.h> /** * Objeto para la comunicación 1-Wire, se indica el pin a utilizar para la comunicacion * dentro del constructor, en este caso utilizaremos el pin 2. */ OneWire onewire(2); /** * @brief Funcion que implementa la lectura de un sensor DS18B20. * * @param result Apuntador a variable de tipo float para almacenar la temperatura leida del sensor. * @return true Retorna verdadero si la comunicación con el sensor es correcta. * @return false Retorna falso si no hay comunicación con el sensor. */ bool sensor_read(float *result) { uint8_t data[12]; int i; // retornar una lectura invalida si falla la comunicacion con el sensor *result = -100.0; // enviar comando de iniciar la conversion de temperatura // primero generamos pulso de reset onewire.reset(); // enviar el comando skip ROM que selecciona todos los dispositivos en el bus onewire.skip(); // enviar el comando de comienzo de conversion A/D onewire.write(0x44); // esperar el termino de conversion AD en el sensor delay(1000); // prestamos atención al pulso de presencia al generar el pulso de reset if (!onewire.reset()) return false; // enviar el comando skip ROM que selecciona todos los dispositivos en el bus onewire.skip(); // enviar comando de lectura de scratchpad onewire.write(0xBE); // comenzar lectura de datos for (i = 0; i < 9; i++) data[i] = onewire.read(); // alinear los datos recibidos int16_t temp = (((int16_t)data[1]) << 11) | (((int16_t)data[0]) << 3); // convertir a grados centigrados *result = (float)temp * 0.0078125; // lectura satisfactoria return true; } /** * Funcion setup, aqui efectuamos la configuracion inicial */ void setup() { // preparar serial Serial.begin(115200); while (!Serial) ; // mostrar mensaje Serial.println(F("----------------------------------------------------")); Serial.println(F(" DS18B20 temperature sensor test program ")); Serial.println(F(" https://www.geekfactory.mx ")); Serial.println(F("----------------------------------------------------")); } /** * Ciclo principal del programa */ void loop() { float temperature; // leer la temperatura desde el DS18B20 y colocarla en la variable temperature if (sensor_read(&temperature)) { Serial.print(F("OK, Temperatura: ")); Serial.println(temperature); } else { Serial.println(F("Fallo de comunicacion con DS18B20")); } } |
Código para encontrar la dirección de los dispositivos DS18B20
El siguiente programa nos permite descubrir la dirección de 64 bits que se encuentra presente en el DS18B20. Podemos utilizar esta dirección para comunicarnos específicamente con alguno de los dispositivos conectados al bus.
Recomendamos conectar un sensor a la vez, de forma que solamente se arroje una sola direcció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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | /** Geek Factory - "Innovating together" Distribucion de materiales para el desarrollo e innovacion tecnologica www.geekfactory.mx Programa para detectar los dispositivos conectados en el bus 1-Wire e imprimir la dirección de los dispositivos encontrados al monitor serial. El programa imprime las direcciones en hexadecimal. */ #include <Arduino.h> #include <OneWire.h> /** * Objeto para la comunicación 1-Wire, se indica el pin a utilizar para la comunicacion * dentro del constructor, en este caso utilizaremos el pin 2. */ OneWire onewire(2); /** * @brief Realiza la busqueda de dispositivos e imprime las direcciones de los sensores * detectados en el bus 1-wire al monitor serial de arduino. */ void sensor_print_addresses(void) { byte i; byte addr[8]; while (onewire.search(addr)) { Serial.print(F("Detectado dispositivo con dirección:t")); // imprimir los digitos de la direccion en hexadecimal for (i = 0; i < 8; i++) { Serial.print(F("0x")); if (addr[i] < 16) { Serial.print('0'); } Serial.print(addr[i], HEX); if (i < 7) { Serial.print(", "); } } // revisar validez de datos con CRC if (OneWire::crc8(addr, 7) != addr[7]) { Serial.print(F(" (CRC invalido)")); } // imprimir linea nueva Serial.println(); } // reiniciar algoritmo de busqueda onewire.reset_search(); } /** * Funcion setup, aqui efectuamos la configuracion inicial */ void setup(void) { // preparar serial Serial.begin(115200); while (!Serial) ; // mostrar mensaje Serial.println(F("----------------------------------------------------")); Serial.println(F(" 1-Wire address scan program ")); Serial.println(F(" https://www.geekfactory.mx ")); Serial.println(F("----------------------------------------------------")); // detectar sensores e imprimir direcciones sensor_print_addresses(); } /** * Ciclo principal del programa */ void loop(void) { // no realizamos ninguna accion } |
Leer un sensor DS18B20 con librería DallasTemperature
En este programa estaremos realizando algo similar al primer programa, pero estaremos utilizando la librería DallasTemperature.
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 48 49 50 51 52 53 54 55 56 57 58 59 60 | /** Geek Factory - "Innovating together" Distribucion de materiales para el desarrollo e innovacion tecnologica www.geekfactory.mx Programa para detectar los dispositivos conectados en el bus 1-Wire e imprimir la dirección de los dispositivos encontrados al monitor serial. El programa imprime las direcciones en hexadecimal. */ #include <Arduino.h> #include <OneWire.h> #include <DallasTemperature.h> /** * Objeto para la comunicación 1-Wire, se indica el pin a utilizar para la comunicacion * dentro del constructor, en este caso utilizaremos el pin 2. */ OneWire onewire(2); /** * Crear una instancia de DallasTemperature y pasar una referencia a onewire */ DallasTemperature sensors(&onewire); /** * Funcion setup, aqui efectuamos la configuracion inicial */ void setup() { // preparar serial Serial.begin(115200); while (!Serial) ; // mostrar mensaje Serial.println(F("----------------------------------------------------")); Serial.println(F(" DS18B20 temperature sensor test program ")); Serial.println(F(" https://www.geekfactory.mx ")); Serial.println(F("----------------------------------------------------")); // preparar la libreria dallas temperature sensors.begin(); } /** * Ciclo principal del programa */ void loop() { // enviar el comando de conversion de temperatura a todos los sensores presentes en el bus // usando el comando skip ROM para que sea recibido por todos los sensores Serial.print(F("Solicitando temperaturas... ")); sensors.requestTemperatures(); Serial.println(F("LISTO!")); // despues de solicitar las temperaturas, podemos leerlas usando getTempCByIndex // en este caso nos devolvera la lectura del primer sensor que se encuentre en el bus Serial.print(F("Temperatura del primer sensor (indice 0) es: ")); Serial.println(sensors.getTempCByIndex(0)); } |
Leer varios sensores DS18B20 en un mismo pin con librería DallasTemperature
Este sketch permite detectar 3 sensores conectados en el mismo pin y obtener sus lecturas. Como podemos observar, el programa es prácticamente igual al anterior, con la excepción de que se realizan 3 lecturas.
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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 | /** Geek Factory - "Innovating together" Distribucion de materiales para el desarrollo e innovacion tecnologica www.geekfactory.mx Programa que lee varios sensores conectados al mismo pin. Este programa utiliza la librería DallasTemperature para la comunicación con los sensores de temperatura. */ #include <Arduino.h> #include <OneWire.h> #include <DallasTemperature.h> /** * Objeto para la comunicación 1-Wire, se indica el pin a utilizar para la comunicacion * dentro del constructor, en este caso utilizaremos el pin 2. */ OneWire onewire(2); /** * Crear una instancia de DallasTemperature y pasar una referencia del tipo OneWire */ DallasTemperature sensors(&onewire); /** * Funcion setup, aqui efectuamos la configuracion inicial */ void setup() { // preparar serial Serial.begin(115200); while (!Serial) ; // mostrar mensaje Serial.println(F("----------------------------------------------------")); Serial.println(F(" DS18B20 temperature sensor test program ")); Serial.println(F(" https://www.geekfactory.mx ")); Serial.println(F("----------------------------------------------------")); // preparar la libreria dallas temperature sensors.begin(); } /** * Ciclo principal del programa */ void loop() { // enviar el comando de conversion de temperatura a todos los sensores presentes en el bus // usando el comando skip ROM para que sea recibido por todos los sensores Serial.print(F("Solicitando temperaturas... ")); sensors.requestTemperatures(); Serial.println(F("LISTO!")); // despues de solicitar las temperaturas, podemos leerlas usando getTempCByIndex // en este caso nos devolvera la lectura del primer sensor que se encuentre en el bus Serial.print(F("Temperatura del primer sensor (indice 0) es: ")); Serial.println(sensors.getTempCByIndex(0)); Serial.print(F("Temperatura del segundo sensor (indice 1) es: ")); Serial.println(sensors.getTempCByIndex(1)); Serial.print(F("Temperatura del tercer sensor (indice 2) es: ")); Serial.println(sensors.getTempCByIndex(1)); } |
Leer sensores DS18B20 si conocemos su dirección
En este programa demostramos como podemos comunicarnos con varios sensores, si conocemos de antemano la dirección de cada uno. La principal ventaja es que no ocuparemos tiempo para ejecutar el algoritmo de búsqueda.
Para conocer las dirección de un DS18B20 podemos utilizar el programa que se encuentra más arriba en esta página.
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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 | /** Geek Factory - "Innovating together" Distribucion de materiales para el desarrollo e innovacion tecnologica www.geekfactory.mx Programa que utiliza la libreria DallasTemperature para comunicarse con los sensores utilizando sus direcciones especificas. Se debe conocer de antemano la direccion de los dispositivos conectados y configurarla correctamente al principio de este programa. */ #include <Arduino.h> #include <OneWire.h> #include <DallasTemperature.h> /** * Objeto para la comunicación 1-Wire, se indica el pin a utilizar para la comunicacion * dentro del constructor, en este caso utilizaremos el pin 2. */ OneWire onewire(2); /** * Crear una instancia de DallasTemperature y pasar una referencia del tipo OneWire */ DallasTemperature sensors(&onewire); /** * Declaramos las direcciones de los sensores que deseamos medir, debemos conocer previamente * las direcciones utilizando el programa correspondiente (DS18B20 DIRECCIONES) */ DeviceAddress sensor1 = {0x28, 0xA8, 0xF8, 0xE7, 0x08, 0x00, 0x00, 0x91}; DeviceAddress sensor2 = {0x28, 0x6F, 0xB6, 0xC6, 0x08, 0x00, 0x00, 0x3F}; DeviceAddress sensor3 = {0x28, 0xA4, 0x29, 0xE6, 0x08, 0x00, 0x00, 0xF0}; /** * Funcion setup, aqui efectuamos la configuracion inicial */ void setup() { // preparar serial Serial.begin(115200); while (!Serial) ; // mostrar mensaje Serial.println(F("----------------------------------------------------")); Serial.println(F(" DS18B20 temperature sensor test program ")); Serial.println(F(" https://www.geekfactory.mx ")); Serial.println(F("----------------------------------------------------")); // preparar la libreria dallas temperature sensors.begin(); } /** * Ciclo principal del programa */ void loop() { // enviar el comando de conversion de temperatura a todos los sensores presentes en el bus // usando el comando skip ROM para que sea recibido por todos los sensores Serial.print(F("Solicitando temperaturas... ")); sensors.requestTemperatures(); Serial.println(F("LISTO!")); // despues de solicitar la conversion de temperaturas, podemos leerlas usando getTempC // en este caso debemos proporcionar a la librería la dirección de cada uno de los sensores Serial.print(F("Temperatura de sensor1: ")); Serial.println(sensors.getTempC(sensor1)); Serial.print(F("Temperatura de sensor2: ")); Serial.println(sensors.getTempC(sensor2)); Serial.print(F("Temperatura de sensor3: ")); Serial.println(sensors.getTempC(sensor3)); // esperamos antes de realizar otra medicion delay(1000); } |
Conclusión
En este tutorial hemos aprendido el funcionamiento y capacidades del bus 1-wire para conectar sensores de temperatura. Especialmente trabajamos con el sensor DS18B20 que es muy popular.
Hemos observado el uso de la librería OneWire de Arduino y como usando la funcionalidad de esta podemos escribir código para acceder a cualquier dispositivo compatible con el bus 1-wire.
También exploramos el uso de la librería DallasTemperature que permite acceder a diversos sensores de temperatura, siendo esta una capa adicional que funciona sobre la librería OneWire y que provee las funciones de alto nivel para acceder a los datos del sensor.
Como podemos observar los sensores DS18B20 son bastante versátiles y nos permiten ahorrar pines del microcontrolador al permitir la conexión de varios de estos sensores a un solo pin.