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

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

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


Suministros

Componentes de hardware

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

Software

Arduino IDEArduino IDE

Makerguides.com participa en el Programa de Asociados de Amazon Services LLC, un programa de publicidad de afiliados diseñado para proporcionar un medio para que los sitios ganen honorarios de publicidad mediante la publicidad y los enlaces a productos en Amazon.com.


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ón3,0 a 5,5 V
Corriente de espera1 μA
Corriente activa1,5 mA
Rango de mediciónDe -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ónProtocolo de bus 1-Wire
PaqueteTO-92 de 3 polos
FabricanteMaxim Integrated
CosteComprobar 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.

DS18B20-sensor-digital-de-temperatura-con-conexiones-Arduino-diagrama-cableado-circuito-esquemático-tutorial
Sensor de temperatura digital DS18B20 con diagrama de cableado de Arduino Uno

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

DS18B20-digital-temperature-sensor-pinout

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

DS18B20Arduino
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 DS18B20Arduino
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.

Esta biblioteca permite emitir comandos sencillos para leer los datos de temperatura de los sensores.

Puedes encontrar el código fuente de esta biblioteca aquí en 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.

Instalar una librería Arduino paso 1 abrir Library Manager

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).

Salida del monitor en serie

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, lospines 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 digitales de temperatura DS18B20 1-Wire conectados a un Arduino

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:

Múltiple-DS18B20-sensores de temperatura-Serial-Monitor-salida
Múltiples sensores DS18B20 Salida de monitor en serie

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í:

DS18B20-calculadora de direcciones

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ónIncremento de la temperaturaTiempo máximo de conversión
9 bits0.5 °C93,75 ms
10 bits0.25 °C187,5 ms
11 bits0.125 °C375 ms
12 bits0.0625 °C750 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.

La conexión de la pantalla LCD I2C es muy fácil como puedes ver en el diagrama de cableado de abajo. Usted puede comprobar mi tutorial detallado a continuación para obtener más información.

Si quieres usar un LCD estándar no-I2C en su lugar, echa un vistazo a este artículo:

DS18B20 con LCD I2C de 16×2 caracteres y Arduino

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

Conexiones I2C LCD

LCD de caracteres I2CArduino
GNDGND
VCC5 V
SDAA4
SCLA5

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.

Instalación de la biblioteca LiquidCrystal_I2C Arduino

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:

DS18B20-16x2-I2C-LCD-output

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.

Tenga en cuenta que los comentarios son retenidos por la moderación para evitar el spam.

Licencia Creative Commons

Nat

Viernes 26 de marzo de 2021

Hola,

Gracias por la subida, estoy usando el DS18B20 en mi proyecto con un MKR1010 pero tengo una pregunta: ¿Cómo recomiendas alimentar este sistema?

Me estoy topando con un problema extraño en el que mis mediciones funcionan mientras el sistema se alimenta de mi ordenador, pero: Cualquier otro, adaptador o sistema de baterías no lo hace funcionar. Con esto quiero decir que el arduino se enciende sin problemas, pero no consigue enviar ningún dato (temp) a mi plataforma.

Probé con ejemplos simples de parpadeo para asegurarme de que mi adaptador no estaba fuera de rango, etc. Luego traté de reducir el programa al mínimo estricto, haciendo que un solo sensor encendiera el LED de la placa: que de nuevo sólo funcionaba cuando se conectaba al ordenador en la serie.

¡Gracias por leer, si tienes algún consejo, será súper bienvenido! Saludos cordiales, N.

James

Viernes 15 de enero de 2021

He seguido estas instrucciones con un Arduino Nano, pero sólo consigo que la temperatura se reporte como -127C (que es también lo que se reporta si no hay nada conectado)...

También he probado otros tutoriales en los que decían que había que cablear el GND y el Vdd ambos a GND, y luego la resistencia entre los 5V de la placa y la señal (junto con la señal) a D2. Usé su código y obtuve el mismo resultado también.

¿Hay algún problema con mi resistencia? ¿Debe estar muerto el sensor?

¿Seguramente me estoy perdiendo algo sencillo?

Gareth

Martes 8 de marzo de 2022

Estuve luchando con este mismo problema durante un tiempo y casi tiré mi sensor asumiendo que estaba defectuoso, pero la respuesta resultó ser simple; mi placa Arduino es una Uno R3 y los pines de entrada analógica están numerados de A0 a A5 en lugar de 0 a 5 como en los ejemplos de código. Comprueba tu placa y si es como la mía, simplemente "#define ONE_WIRE_BUS A2" en lugar de "#define ONE_WIRE_BUS 2" y deberías estar bien.

František Pospíšil

Domingo 14 de marzo de 2021

Yo tenía el mismo problema, se me ocurrió conectar los sensores de temperatura al terminal D13, donde se conecta el LED de la placa Arduino, para ver si hay comunicación, y he aquí que ya ha empezado a funcionar como debería. Tengo una resistencia PullUp de 10kOhm. Luego, a veces, intento coger un osciloscopio y ver cuál es el problema. Por supuesto, necesitas poner OneWire en el pin 13, así que cambia esta línea: #define ONE_WIRE_BUS 13

František Pospíšil

Domingo 14 de marzo de 2021

měl jsem ten samý problém, napadlo mě připojit teplotní senzory na vývod D13, kde je na desce Arduina připojena LEDka, abych se podíval, jestli tam probíhá nějaká komunikace, a ejhle, už to začalo pracovat tak jak má. El PullUp es de 10kOhm. Zkusím pak někdy vzít osciloskop a podívám se, v čem je problém. El problema es que el OnaWire está en la clavija 13, lo que significa que está en la clavija 13: #define ONE_WIRE_BUS 13

Bill Frick

Lunes 9 de noviembre de 2020

¡Gran tutorial! Nuevo en Arduino y las explicaciones del código son muy útiles. Mi proyecto utiliza 15 sensores DS18B20 para controlar los ventiladores de circulación en 6 hornos solares. El plan es utilizar la temperatura DELTA del aire en cada uno para PWM la potencia a los ventiladores. 3 sensores son para controlar la temperatura exterior, interior y de la superficie del colector. Es un exceso, pero la versión anterior sólo medía la temperatura de salida.

Benne de Bakker

Lunes 9 de noviembre de 2020

Impresionante, parece un proyecto interesante.