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

Este tutorial incluye todo lo que necesitas saber sobre el uso de DS18B20 sensores de temperatura digitales 1-Wire con Arduino.

Para este tutorial, usaremos la librería DallasTemperature junto con la librería OneWire de Arduino. Estas librerías facilitan mucho la comunicación con uno o varios sensores. En la primera parte de este artículo, encontrarás las especificaciones e información sobre los diferentes tipos de sensores DS18B20. Luego, veremos cómo conectar el sensor al Arduino.

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

Materiales

Componentes de hardware

DS18B20 digital temperature sensor (TO-92)	× 3	Amazon
Waterproof DS18B20 (alternativa)	× 1	Amazon
DS18B20 breakout board (alternativa)	× 1	Amazon
Arduino Uno	× 1	Amazon
Breadboard	× 1	Amazon
Jumper wires	~ 15	Amazon
4.7 kΩ pull-up resistor	× 1	Amazon
16×2 character I2C LCD	× 1	Amazon
USB cable type A/B	× 1	Amazon

Software

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Acerca del sensor de temperatura 1-Wire DS18B20

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 ofrece 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 operación del sensor es de 3.0 a 5.5 V, puedes usarlo tanto con Arduino (que funciona a 5 V) como con dispositivos como ESP32 y Raspberry Pi que tienen pines GPIO de 3.3 V.

Una de las principales ventajas de este sensor es que solo requiere un pin digital del Arduino para comunicarse. El sensor utiliza el protocolo Dallas Semiconductor 1-Wire. Este protocolo funciona de manera similar al I2C, pero con velocidades de datos más bajas y mayor alcance.

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

La resolución del sensor puede configurarse programáticamente 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 al encender es de 12 bits.

Puedes encontrar más especificaciones en la tabla a continuación.

Especificaciones del sensor de temperatura digital DS18B20

Voltaje de alimentación	3.0 a 5.5 V
Corriente en espera	1 μA
Corriente activa	1.5 mA
Rango de medición	-55 °C a +125 °C (-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 (resolución de 12 bits)
Protocolo de comunicación	Protocolo de bus 1-Wire®
Encapsulado	TO-92 de 3 pines
Fabricante	Maxim Integrated
Costo	Check price

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

Tipos de sensores DS18B20

El sensor suele venir en tres formatos. El tipo más común es el 3-pin TO-92 encapsulado, que se parece a un transistor.

Este tipo de sensor a veces se monta en una breakout board que puede incluir un LED de alimentación y la resistencia pull-up de 4.7 kΩ necesaria. Siempre asegúrate de revisar las marcas en la PCB, ya que el orden de los pines puede variar según el fabricante.

Por último, puedes comprar el sensor en formato sonda impermeable con un cable ya conectado. Este formato es útil si quieres medir algo a distancia, bajo el agua o bajo tierra.

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

Cableado – Conectar el DS18B20 a un Arduino

Conectar un DS18B20 al Arduino es bastante sencillo, ya que solo necesitas conectar 3 pines. Comienza conectando el pin GND a tierra y el pin V _DD al pin de 5 V del Arduino.

Luego, conecta el pin central (DQ) a cualquiera de los pines digitales del Arduino. En este caso, usé el pin digital 2. También debes añadir una resistencia pull-up de 4.7 kΩ entre el pin DQ y 5 V. Esto mantendrá el estado inactivo del bus 1-Wire en alto.

Las conexiones también se muestran en la tabla a continuación.

Ten en cuenta que el pin 1 (GND) es el pin más a la izquierda cuando el lado plano del sensor (con el texto impreso) está frente a ti.

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 (V DD )	5V

Un sensor DS18B20 impermeable se conecta de la misma manera. Sin embargo, el color de los cables puede variar según el fabricante. El cable de tierra (GND) suele ser negro o azul, el cable de alimentación (VDD) generalmente es rojo, y el cable de señal (DQ) suele ser amarillo o blanco. Te recomiendo siempre revisar la hoja de datos de tu sensor si tienes dudas.

Conexiones del sensor de temperatura digital DS18B20 impermeable

DS18B20 impermeable	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 (V DD )	5V

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

El protocolo de comunicación 1-Wire es algo complejo y requiere bastante código para manejar la comunicación. Por eso, usaremos la librería Arduino-Temperature-Control-Library de Miles Burton para facilitar la programación de estos sensores.

Para instalar la librería, ve a Tools > Manage Libraries (Ctrl + Shift + I en Windows) en el Arduino IDE. Se abrirá el Library Manager y actualizará la lista de librerías instaladas.

Puedes buscar ‘ds18b20’ y buscar la librería DallasTemperature de Miles Burton. Selecciona la versión más reciente y haz clic en Install.

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

Busca ‘onewire’ y selecciona la librería OneWire de Jim Studt.

Ejemplo de código para sensor de temperatura DS18B20 con Arduino

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

/* DS18B20 1-Wire digital temperature sensor with Arduino example code. 
   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ías ver la siguiente salida en el Monitor Serial (Ctrl + Shift + M).

Asegúrate de que la velocidad en baudios del Monitor Serial también esté configurada 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"

Luego, definí a qué pin del Arduino está conectado el pin DQ del sensor. La instrucción #define se usa para dar un nombre a un valor constante. El compilador reemplazará todas las referencias a esta constante con el valor definido cuando se compile el programa. Así que donde menciones ONE_WIRE_BUS, el compilador lo reemplazará 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, creé un nuevo objeto de la clase OneWire y pasé el pin DQ a su constructor. También necesitas crear un objeto de la clase DallasTemperature y pasarle el objeto oneWire como parámetro.

Ten en cuenta que llamé al objeto DallasTemperature ‘sensors’, pero puedes usar otros nombres también.

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

En la sección setup del código, iniciamos la comunicación serial a 9600 baudios. 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 loop del código, comenzamos con el comando para que todos los sensores en el bus inicien una conversión de temperatura.

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

Luego, usé las funciones getTempCByIndex(deviceIndex) y getTempFByIndex(deviceIndex) para obtener la temperatura en grados Celsius y Fahrenheit respectivamente. En este caso, solo tenemos 1 sensor conectado al bus. Como la cuenta empieza en cero, establecí el índice para 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 Serial:

  // 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 modo de 12 bits puede tardar hasta 750 ms, añadí un retardo 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 varios sensores DS18B20 con solo un pin del Arduino. A continuación, encontrarás dos ejemplos de código. Con el primer ejemplo, puedes leer la temperatura de los sensores conectados por su índice. Como todos los sensores están conectados al mismo bus 1-Wire, el primer sensor tiene índice 0, el segundo índice 1, y así sucesivamente.

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

Cableado – Conectar múltiples sensores DS18B20 al Arduino

Conectar múltiples sensores DS18B20 al Arduino es tan sencillo como conectar uno solo. Todos los sensores se conectan en paralelo, es decir, todos los mismos pines están conectados juntos. Igual que antes, los pines GND se conectan a tierra, los pines V _DD 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.

Ejemplo de código para múltiples sensores DS18B20 con Arduino

Con el siguiente ejemplo, puedes 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. M
   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 verse así:

Cómo funciona el código

El código en este ejemplo es casi igual que antes.

En la sección setup, añadí una función extra que cuenta el número de dispositivos 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 loop del código, usé un for loop para recorrer un bloque 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");
  }

Leer 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 esto, puedes usar el sketch de ejemplo a continuación.

El sketch imprime las direcciones de los sensores conectados en el Monitor Serial. Para saber cuál sensor es cuál, puedes conectar un sensor a la vez o ir añadiendo sensores sucesivamente. Luego, puedes etiquetar cada sensor conectado al bus 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 verse algo así:

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

Ejemplo de código Arduino para leer sensores por dirección

Con el siguiente ejemplo, puedes 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");
}

Ten en cuenta que debes reemplazar las direcciones en las líneas 17 a 19 con las direcciones que encontraste usando 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ías 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 un arreglo 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 setup del código es igual que en los ejemplos anteriores.

En el loop, llamamos a la función printTemperature(DeviceAddress address). En esta función personalizada, usamos 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 librería DallasTemperature para Arduino

La librería DallasTemperature tiene otras funciones útiles integradas que aún no he cubierto en los ejemplos anteriores. Por eso, he listado algunas a continuación:

setResolution()

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

Quizás te preguntes por qué querrías cambiar la resolución, ¿no es mejor siempre la más alta? Una ventaja de seleccionar una resolución menor es que la conversión de temperatura a digital toma mucho menos tiempo. Esto significa que puedes tomar más lecturas de temperatura en el mismo tiempo.

Según la hoja de datos, obtuve la siguiente información:

Resolución	Incremento de 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 librería DallasTemperature te permite configurar la resolución con la función setResolution(). Esta función puede añadirse en la sección setup o loop de tu código.

Puedes configurar la resolución para todos los sensores conectados así:

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

O puedes configurarla 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 se usa para convertir la temperatura de grados Celsius a Fahrenheit.

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

setHighAlarmTemp() y setLowAlarmTemp()

Estas funciones configuran las alarmas internas de temperatura alta y baja para un dispositivo en grados Celsius.

bool hasAlarm()

Esta función devuelve true cuando un dispositivo tiene una condición de alarma. Consulta el sketch AlarmHandler.ino para un ejemplo de cómo usar esta función.

Mostrar las lecturas de temperatura DS18B20 en un LCD I2C

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

Con el código de ejemplo a continuación, puedes mostrar las lecturas de temperatura en un LCD I2C de 16×2 caracteres.

Conectar el LCD I2C es muy fácil, como puedes ver en el diagrama de cableado a continuación. Puedes consultar mi tutorial detallado para más información. How to control a character I2C LCD with Arduino. Si prefieres usar un LCD estándar sin I2C, echa un vistazo a este artículo: How to use a 16×2 character LCD with Arduino

Las conexiones también se muestran en la tabla a continuación:

Conexiones LCD I2C

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

Para usar un LCD I2C, necesitarás instalar la librería LiquidCrystal_I2C para Arduino.

Abre el gestor de librerías en el IDE de Arduino y busca ‘liquidcrystal_i2c’. Luego desplázate hacia abajo y busca la librería de Frank de Brabander. Selecciona la versión más reciente y haz clic en Install.

Ejemplo de código DS18B20 con LCD I2C

/* DS18B20 1-Wire digital temperature sensor with 16x2 I2C LCD and Arduino example code. 
  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ías ver la siguiente salida en el LCD:

Conclusión

En este tutorial, te he mostrado cómo usar sensores de temperatura digitales DS18B20 1-Wire con Arduino. Espero que te haya resultado útil e informativo.

Si quieres aprender más sobre otros sensores de temperatura, consulta los artículos a continuación.

• How to use DHT11 and DHT22 sensors with Arduino
• LM35 analog temperature sensor with Arduino tutorial
• TMP36 analog temperature sensor with Arduino tutorial

Si tienes alguna pregunta, por favor deja un comentario abajo.