La guía completa para los sensores digitales de temperatura DS18B20 con Arduino

Este tutorial incluye todo lo que necesitas saber sobre el uso de los sensores digitales de temperatura DS18B20 1-Wire con Arduino. He incluido diagramas de cableado y varios códigos de ejemplo para empezar.

Para este tutorial, vamos a utilizar el DallasTemperature en combinación con la biblioteca OneWire Arduino. Estas librerías hacen que la comunicación con uno o varios sensores sea súper fácil. En la primera parte de este artículo, puedes encontrar las especificaciones e información sobre los diferentes tipos de sensores DS18B20. A continuación, veremos cómo conectar el sensor al Arduino.

En el primer ejemplo de código, le mostraré cómo tomar lecturas de temperatura de un solo sensor y mostrar el resultado en el Monitor Serial. Los siguientes ejemplos explican cómo leer múltiples sensores con un solo pin de Arduino. Por último, le mostraré cómo mostrar la temperatura en una pantalla LCD I2C.

Si quiere saber más sobre otros sensores de temperatura, consulte los artículos siguientes.

Artículos recomendados

• Cómo utilizar los sensores DHT11 y DHT22 con Arduino
• Tutorial de sensor de temperatura analógico LM35 con Arduino
• Tutorial del sensor de temperatura analógico TMP36 con Arduino
• Cómo controlar un carácter I2C LCD con Arduino
• Cómo utilizar una pantalla LCD de 16×2 caracteres con Arduino

Si tiene alguna pregunta, deje un comentario a continuación.

Suministros

Componentes de hardware

Sensor de temperatura digital DS18B20 (TO-92)	× 3	Amazon
Impermeable DS18B20 (alternativa)	× 1	Amazon
Placa de conexión DS18B20 (alternativa)	× 1	Amazon
Arduino Uno	× 1	Amazon
Tablero de pruebas	× 1	Amazon
Cables de puente	~ 15	Amazon
Resistencia de pull-up de 4,7 kΩ	× 1	Amazon
LCD I2C de 16×2 caracteres	× 1	Amazon
Cable USB tipo A/B	× 1	Amazon

Software

Arduino IDE

Makerguides.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to products on Amazon.com. As an Amazon Associate we earn from qualifying purchases.

Acerca del sensor de temperatura DS18B20 1-Wire

El DS18B20 es un sensor de temperatura digital fabricado por Maxim Integrated (antes Dallas Semiconductor). Es uno de los sensores de temperatura más populares del mercado y proporciona una precisión bastante alta (±0,5 °C) en un amplio rango de temperaturas (-55 °C a + 125 °C). Debido a que el voltaje de funcionamiento del sensor es de 3,0 a 5,5 V, se puede utilizar tanto con el Arduino (que funciona a 5 V), así como con dispositivos como el ESP32 y la Raspberry Pi que tienen pines GPIO de 3,3 V.

Una de las principales ventajas de este sensor es que sólo requiere un pin digital del Arduino para la comunicación. El sensor se comunica utilizando el protocolo 1-Wire® de Dallas Semiconductor. Este protocolo funciona de forma similar a I2C, pero con menor velocidad de datos y mayor alcance.

Otra ventaja es que cada sensor DS18B20 tiene un código serie único de 64 bits, lo que permite que varios sensores funcionen en el mismo bus 1-Wire. Así que puedes leer los datos de múltiples sensores que están conectados juntos con un solo pin de Arduino (ver ejemplos de código más abajo).

La resolución del sensor puede ajustarse mediante programación a 9, 10, 11 o 12 bits. Esto corresponde a incrementos de temperatura de 0,5 °C, 0,25 °C, 0,125 °C y 0,0635 °C, respectivamente. La resolución por defecto en el encendido es de 12 bits.

Puede encontrar más especificaciones en la siguiente tabla.

Especificaciones del sensor de temperatura digital DS18B20

Tensión de alimentación	3,0 a 5,5 V
Corriente de espera	1 μA
Corriente activa	1,5 mA
Rango de medición	De -55 °C a + 125 °C (de -67 °F a +257 °F)
Precisión (Error del termómetro)	±0,5 °C de -10 °C a +85 °C ±1 °C de -30 °C a +100 °C ±2 °C de -55 °C a +125 °C
Resolución	De 9 a 12 bits (programable)
Tiempo de conversión	< 750 ms (12-bit resolution)
Protocolo de comunicación	Protocolo de bus 1-Wire
Paquete	TO-92 de 3 polos
Fabricante	Maxim Integrated
Coste	Comprobar el precio

Para más información, también puede consultar la hoja de datos aquí:

Tipos de sensores DS18B20

El sensor suele presentarse en tres formatos. El tipo más común es el paquete TO-92 de 3 pines, que se parece a un transistor.

Este tipo de sensor se monta a veces en una placa de circuito impreso que puede incluir un LED de alimentación y la resistencia de pull-up de 4,7 kΩ necesaria. Asegúrate siempre de comprobar las marcas en la placa de circuito impreso, ya que el orden de los pines puede ser diferente según el fabricante.

Por último, puede comprar el sensor en un estilo de sonda a prueba de agua con un cable ya conectado. Este estilo puede ser útil si quieres medir algo lejos, bajo el agua o bajo el suelo.

Tenga en cuenta que el cable del sensor estanco suele estar recubierto de PVC, por lo que se recomienda mantenerlo por debajo de los 100 °C.

Cableado - Conexión del DS18B20 a un Arduino

Conectar un DS18B20 al Arduino es bastante fácil, ya que sólo necesitas conectar 3 pines. Empieza por conectar el pin GND a tierra y el pin VDD a la salida de 5 V del Arduino.

A continuación, conecta el pin del medio (DQ) a cualquiera de los pines digitales del Arduino. En este caso, he utilizado el pin digital 2. También tienes que añadir una resistencia pull-up de 4,7 kΩ entre el pin DQ y 5 V. Esto mantendrá el estado de reposo para el bus 1-Wire alto.

Las conexiones también se indican en la tabla siguiente.

Tenga en cuenta que la clavija 1 (GND) es la más a la izquierda cuando la cara plana del sensor (con el texto impreso) está orientada hacia usted.

Conexiones del sensor de temperatura digital DS18B20

DS18B20	Arduino
Pin 1 (GND)	GND
Pin 2 (DQ)	Pin 2 Arduino y a través de una resistencia de 4,7 kΩ a 5V
PIN 3 (VDD)	5V

Un sensor DS18B20 resistente al agua se conecta de la misma manera. Sin embargo, el color de los cables puede ser diferente según el fabricante. El cable de tierra (GND) suele ser negro o azul, el de alimentación (VDD) suele ser rojo y el de señal (DQ) suele ser amarillo o blanco. Te recomiendo que consultes siempre la hoja de datos de tu sensor si no estás seguro.

Conexiones del sensor digital de temperatura DS18B20 a prueba de agua

Impermeable DS18B20	Arduino
Cable negro (GND)	GND
Cable amarillo (DQ)	Pin 2 Arduino y a través de una resistencia de 4,7 kΩ a 5V
Cable rojo (VDD)	5V

Instalación de las librerías DallasTemperature y OneWire Arduino

El protocolo de comunicación 1-Wire es algo complejo y requiere un montón de código para analizar la comunicación. Por lo tanto, vamos a utilizar la biblioteca DallasTemperature Arduino por Miles Burton para hacer la programación de estos sensores mucho más fácil.

This library allows you to issue simple commands to read out the temperature data from the sensors. You can find the source code for this library here on GitHub.

Para instalar la biblioteca, vaya a Herramientas > Gestionar Bibliotecas (Ctrl + Shift + I en Windows) en el IDE de Arduino. El Administrador de Bibliotecas se abrirá y actualizará la lista de bibliotecas instaladas.

Puedes buscar 'ds18b20 ' y buscar la biblioteca DallasTemperature de Miles Burton. Selecciona la última versión y haz clic en Instalar.

La librería DallasTemperature depende de la librería OneWire de Arduino que también debes instalar. Esta biblioteca se encarga del protocolo de comunicación 1-Wire.

Busca 'onewire ' y busca la biblioteca OneWire de Jim Studt.

Sensor de temperatura DS18B20 con código de ejemplo de Arduino

Con el siguiente código de ejemplo, puedes leer la temperatura de un sensor DS18B20 y mostrarla en el Monitor Serial.

Puedes cargar el código de ejemplo en tu Arduino utilizando el IDE de Arduino.

Para copiar el código, haga clic en el botón de la esquina superior derecha del campo de código.

/* DS18B20 1-Wire digital temperature sensor with Arduino example code. More info: https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();
}

void loop() {
  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

  // Fetch the temperature in degrees Celsius for device index:
  float tempC = sensors.getTempCByIndex(0); // the index 0 refers to the first device
  // Fetch the temperature in degrees Fahrenheit for device index:
  float tempF = sensors.getTempFByIndex(0);

  // Print the temperature in Celsius in the Serial Monitor:
  Serial.print("Temperature: ");
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");

  // Print the temperature in Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("F");

  // Wait 1 second:
  delay(1000);
}

Debería ver la siguiente salida en el Monitor Serial (Ctrl + Shift + M).

Asegúrese de que la tasa de baudios del Monitor Serial también está ajustada a 9600.

Cómo funciona el código

El primer paso es incluir las librerías de Arduino necesarias:

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

A continuación, he definido a qué pin del Arduino se conecta el pin DQ del sensor. La declaración #define se puede utilizar para dar un nombre a un valor constante. El compilador sustituirá todas las referencias a esta constante por el valor definido cuando se compile el programa. Por lo tanto, en todos los casos en los que se menciona ONE_WIRE_BUSel compilador lo sustituirá por el valor 2 al compilar el programa.

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

Después de esto, creé un nuevo objeto de la clase OneWire y pasé el pin DQ a su constructor. También es necesario crear un objeto de la clase DallasTemperature y pasar el objeto oneWire como parámetro.

Tenga en cuenta que he llamado al objeto DallasTemperature 'sensores', pero puede utilizar otros nombres también.

OneWire oneWire(ONE_WIRE_BUS);
Sensores DallasTemperature(&oneWire);

En la sección de configuración del código, comenzamos la comunicación en serie a una tasa de baudios de 9600. Luego, inicialicé el bus con la función begin().

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();
}

En la sección de bucle del código, comenzamos con la orden para que todos los sensores del bus inicien una conversión de temperatura.

  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

A continuación, he utilizado las funciones getTempCByIndex(deviceIndex) y getTempFByIndex(deviceIndex) para obtener la temperatura en grados Celsius y Fahrenheit respectivamente. En este caso, sólo tenemos 1 sensor conectado al bus. Debido a que el conteo comienza en cero, puse el índice de nuestro sensor en 0.

  // Fetch the temperature in degrees Celsius for device index:
  float tempC = sensors.getTempCByIndex(0); // the index 0 refers to the first device
  // Fetch the temperature in degrees Fahrenheit for device index:
  float tempF = sensors.getTempFByIndex(0);

Por último, las temperaturas se imprimen en el monitor de serie:

  // Print the temperature in Celsius in the Serial Monitor:
  Serial.print("Temperature: ");
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");
  // Print the temperature in Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("F");

Como la conversión de temperatura en el modo de 12 bits puede tardar hasta 750 ms, añadí un retraso de un segundo entre cada medición.

Uso de múltiples sensores DS18B20 con Arduino

Como mencioné en la introducción, puedes leer la temperatura de múltiples sensores DS18B20 con un solo pin del Arduino. A continuación puedes encontrar dos códigos de ejemplo. Con el primer ejemplo, puedes leer la temperatura de los sensores conectados por su índice. Debido a que todos los sensores están conectados al mismo bus 1-Wire, el primer sensor tiene el índice 0, el segundo el índice 1, y así sucesivamente.

En el segundo ejemplo, le mostraré cómo leer la dirección única de 64 bits de cada sensor. Esta dirección se puede utilizar para leer cada sensor individualmente.

Cableado - Conexión de varios sensores DS18B20 al Arduino

Conectar varios sensores DS18B20 al Arduino es tan sencillo como conectar uno solo. Todos los sensores se conectan en paralelo, es decir, se conectan todos los mismos pines. Al igual que antes, los pines GND se conectan a tierra, los_pines VDD a 5 V y los pines DQ al pin 2 del Arduino. No olvides la resistencia pull-up de 4,7 kΩ entre el pin DQ y 5 V.

Ten en cuenta que he utilizado una protoboard para conectar todos los pines. Si no estás familiarizado con el funcionamiento de una protoboard, puedes encontrar una explicación aquí.

Múltiples sensores DS18B20 con código de ejemplo de Arduino

Con el siguiente ejemplo, puede leer la temperatura de cada sensor por su índice y mostrarla en el Monitor Serial.

/* Multiple DS18B20 1-Wire digital temperature sensors with Arduino example code. More info: https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"


// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

int deviceCount = 0;
float tempC;
float tempF;

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();

  // Locate the devices on the bus:
  Serial.println("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");
}

void loop() {
  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

  // Display temperature from each sensor
  for (int i = 0;  i < deviceCount;  i++) {
    Serial.print("Sensor ");
    Serial.print(i + 1);
    Serial.print(" : ");
    tempC = sensors.getTempCByIndex(i);
    tempF = sensors.getTempFByIndex(i);
    Serial.print(tempC);
    Serial.print(" \xC2\xB0"); // shows degree symbol
    Serial.print("C  |  ");
    Serial.print(tempF);
    Serial.print(" \xC2\xB0"); // shows degree symbol
    Serial.println("F");
  }

  Serial.println();
  delay(1000);
}

La salida en el Monitor Serial debería tener este aspecto:

Cómo funciona el código

El código de este ejemplo es en su mayor parte el mismo que antes.

En la sección de configuración, he añadido una función extra que cuenta el número de dispositivos que están conectados al bus 1-Wire.

  // Locate the devices on the bus:
  Serial.println("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");

En la sección de bucle del código, he utilizado un bucle for para recorrer una sección de código que obtiene la temperatura de cada sensor conectado al bus por su índice.

  // Display temperature from each sensor
  for (int i = 0;  i < deviceCount;  i++) {
    Serial.print("Sensor ");
    Serial.print(i + 1);
    Serial.print(" : ");
    tempC = sensors.getTempCByIndex(i);
    tempF = sensors.getTempFByIndex(i);
    Serial.print(tempC);
    Serial.print(" \xC2\xB0"); // shows degree symbol
    Serial.print("C  |  ");
    Serial.print(tempF);
    Serial.print(" \xC2\xB0"); // shows degree symbol
    Serial.println("F");
  }

Lectura de sensores por dirección

Para leer los sensores por su dirección individual, primero necesitamos saber cuál es la dirección de cada sensor. Para ello, puedes utilizar el sketch de ejemplo que aparece a continuación.

El sketch imprime las direcciones de los sensores conectados en el Monitor Serial. Para saber qué sensor es cada uno, puedes cablear sólo un sensor a la vez o añadir sucesivamente un nuevo sensor. Entonces, puedes etiquetar cada sensor que está conectado al bus de 1-Wire.

Buscador de direcciones DS18B20

/* Multiple DS18B20 1-Wire digital temperature sensors with Arduino example code. More info: https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

// Create variables:
int deviceCount = 0; // variable to store the number of devices connected
DeviceAddress deviceAddress; // variable to store the device address

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();

  // Locate the devices on the bus:
  Serial.println("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount);
  Serial.println(" devices");

  Serial.println("Printing addresses...");
  for (int i = 0;  i < deviceCount;  i++) {
    Serial.print("Sensor ");
    Serial.print(i + 1);
    Serial.print(" : ");
    sensors.getAddress(deviceAddress, i);
    printAddress(deviceAddress);
  }
}

void loop() {
}

void printAddress(DeviceAddress deviceAddress) {
  for (uint8_t i = 0; i < 8; i++) {
    Serial.print("0x");
    if (deviceAddress[i] < 0x10) {
      Serial.print("0");
    }
    Serial.print(deviceAddress[i], HEX);
    if (i < 7) {
      Serial.print(", ");
    }
  }
  Serial.println();
}

La salida en el Monitor Serial debería ser algo así:

Ahora anota las direcciones de todos los sensores, porque las necesitarás en el siguiente ejemplo.

Lectura de sensores por dirección Código de ejemplo de Arduino

Con el siguiente ejemplo, puede leer la temperatura de cada sensor especificando su dirección única.

/* Read multiple DS18B20 1-Wire digital temperature sensors by address. 
   More info: https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};
byte sensor2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB};
byte sensor3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21};

void setup() {
  // Begin serial communication at a baud rate of 9600:
  Serial.begin(9600);
  // Start up the library:
  sensors.begin();
}

void loop() {
  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

  Serial.print("Sensor 1: ");
  printTemperature(sensor1); // call the printTemperature function with the address of sensor1 as input
  Serial.print("Sensor 2: ");
  printTemperature(sensor2);
  Serial.print("Sensor 3: ");
  printTemperature(sensor3);

  Serial.println(); // prints an empty line
  delay(1000);
}

void printTemperature(DeviceAddress address) {
  // Fetch the temperature in degrees Celsius for device address:
  float tempC = sensors.getTempC(address);
  // Fetch the temperature in degrees Fahrenheit for device address:
  float tempF = sensors.getTempF(address);
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");

  // Print the temperature in Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("F");
}

Tenga en cuenta que tiene que reemplazar las direcciones de las líneas 17 a 19 con las direcciones que encontró utilizando el código de ejemplo anterior.

// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};
byte sensor2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB};
byte sensor3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21};

Debería ver la siguiente salida en el Monitor Serial.

Explicación del código

La dirección de cada sensor consta de 64 bits. En el código, especificamos la dirección como una matriz de ocho bytes de 8 bits.

// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};
byte sensor2[8] = {0x28, 0xCC, 0x19, 0x49, 0x0C, 0x00, 0x00, 0xBB};
byte sensor3[8] = {0x28, 0x19, 0xEF, 0x48, 0x0C, 0x00, 0x00, 0x21};

La sección de configuración del código es la misma que en los ejemplos anteriores.

En el bucle, llamamos al printTemperature(DeviceAddress address) función. En esta función personalizada, utilizamos getTempC(address) y getTempF(address) para obtener la temperatura de un sensor cuya dirección se pasa como parámetro.

void printTemperature(DeviceAddress address) {
  // Fetch the temperature in degrees Celsius for device address:
  float tempC = sensors.getTempC(address);
  // Fetch the temperature in degrees Fahrenheit for device address:
  float tempF = sensors.getTempF(tempC);
  Serial.print(tempC);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");

  // Print the temperature in Fahrenheit
  Serial.print(tempF);
  Serial.print(" \xC2\xB0"); // shows degree symbol
  Serial.println("F");
}

Otras funciones de la biblioteca DallasTemperature Arduino

La biblioteca DallasTemperature tiene algunas otras funciones útiles incorporadas que no he cubierto en los ejemplos anteriores. Por lo tanto, he enumerado algunas de ellas a continuación:

setResolution()

Esta función se puede utilizar para establecer la resolución de la conversión de temperatura a digital. Como mencioné en la introducción, se puede establecer en 9, 10, 11 o 12 bits, que corresponden a incrementos de 0,5 °C, 0,25 °C, 0,125 °C y 0,0625 °C, respectivamente.

Te preguntarás por qué querrías cambiar la resolución, ¿no es siempre mejor una mayor? Una de las ventajas de seleccionar una resolución más baja es que la conversión de temperatura a digital lleva mucho menos tiempo. Esto significa que puede tomar más lecturas de temperatura en la misma cantidad de tiempo.

De la hoja de datos obtuve la siguiente información:

Resolución	Incremento de la temperatura	Tiempo máximo de conversión
9 bits	0.5 °C	93,75 ms
10 bits	0.25 °C	187,5 ms
11 bits	0.125 °C	375 ms
12 bits	0.0625 °C	750 ms

La biblioteca DallasTemperature permite establecer la resolución con la función setResolution(). Esta función se puede añadir a la sección de configuración o de bucle de su código.

Puede ajustar la resolución de todos los sensores conectados de la siguiente manera:

// Set the resolution for all devices to 9, 10, 11, or 12 bits:
sensors.setResolution(9);

O bien, puede configurarlo individualmente para un sensor específico especificando su dirección:

// Addresses of DS18B20 sensors connected to the 1-Wire bus
byte sensor1[8] = {0x28, 0x18, 0xB4, 0x49, 0x0C, 0x00, 0x00, 0x7C};

// Set the resolution of a specific device to 9, 10, 11, or 12 bits:
sensors.setResolution(sensor1, 9);

toFahrenheit()

Esta función permite convertir la temperatura en grados Celsius a Fahrenheit.

float tempC = sensors.getTempCbyIndex(0);
float tempF = DallasTemperature::toFahrenheit(tempC);

setHighAlarmTemp() y setLowAlarmTemp()

Esta función establece las alarmas internas de temperatura alta y baja para un dispositivo en grados Celsius.

bool tieneAlarma()

Esta función devuelve true cuando un dispositivo tiene una condición de alarma. Puede encontrar un ejemplo de estas funciones aquí.

Mostrar las lecturas de temperatura del DS18B20 en una pantalla LCD I2C

Si quieres hacer un proyecto autónomo que no necesite un ordenador, puede ser bueno saber cómo mostrar las lecturas de temperatura en una pantalla LCD.

Con el código de ejemplo que se muestra a continuación, puede mostrar las lecturas de temperatura en una pantalla LCD I2C de 16×2 caracteres.

Connecting the I2C LCD is very easy as you can see in the wiring diagram below. You can check out my detailed tutorial below for more information. How to control a character I2C LCD with Arduino. If you want to use a standard non-I2C LCD instead, take a look at this article: How to use a 16×2 character LCD with Arduino

Las conexiones también se indican en la tabla siguiente:

Conexiones I2C LCD

LCD de caracteres I2C	Arduino
GND	GND
VCC	5 V
SDA	A4
SCL	A5

Para utilizar una pantalla LCD I2C, tendrá que instalar la biblioteca LiquidCrystal_I2C Arduino.

Abre el gestor de bibliotecas en el IDE de Arduino y busca 'liquidcrystal_i2c'. Ahora desplázate hacia abajo y busca la biblioteca de Frank de Brabander. Selecciona la última versión y haz clic en Instalar.

Código de ejemplo del DS18B20 con LCD I2C

/* DS18B20 1-Wire digital temperature sensor with 16x2 I2C LCD and Arduino example code. More info: https://www.makerguides.com */

// Include the required Arduino libraries:
#include "OneWire.h"
#include "DallasTemperature.h"
#include "LiquidCrystal_I2C.h"

// Define to which pin of the Arduino the 1-Wire bus is connected:
#define ONE_WIRE_BUS 2

// Create a new instance of the oneWire class to communicate with any OneWire device:
OneWire oneWire(ONE_WIRE_BUS);

// Pass the oneWire reference to DallasTemperature library:
DallasTemperature sensors(&oneWire);

LiquidCrystal_I2C lcd(0x27, 16, 2);

// Degree symbol:
byte Degree[] = {
  B00111,
  B00101,
  B00111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

void setup() {
  // Start up the library:
  sensors.begin();
  // Start the LCD and turn on the backlight:
  lcd.init();
  lcd.backlight();
  // Create a custom character:
  lcd.createChar(0, Degree);
}

void loop() {
  // Send the command for all devices on the bus to perform a temperature conversion:
  sensors.requestTemperatures();

  // Fetch the temperature in degrees Celsius for device index:
  float tempC = sensors.getTempCByIndex(0); // the index 0 refers to the first device

  // Print the temperature on the LCD;
  lcd.setCursor(0,0);
  lcd.print("Temperature:");
  lcd.setCursor(0,1);
  lcd.print(tempC);
  lcd.write(0); // print the custom character
  lcd.print("C");

  // Wait 1 second:
  delay(1000);
}

Debería ver la siguiente salida en la pantalla LCD:

Conclusión

En este tutorial, he mostrado cómo utilizar los sensores digitales de temperatura DS18B20 1-Wire con Arduino. Espero que lo hayas encontrado útil e informativo. Si lo hiciste, por favor comparte este artículo con un amigo que también le guste la electrónica y hacer cosas.

Me encantaría saber qué proyectos planeas construir (o ya has construido) con estos sensores. Si tienes alguna pregunta, sugerencia, o si crees que faltan cosas en este tutorial, por favor deja un comentario abajo.