Conexión de múltiples sensores de temperatura digitales DS18B20 a Arduino

En la era de la tecnología y la automatización, la capacidad de monitorear y controlar la temperatura de diversos entornos es esencial. En este artículo, te enseñaremos cómo conectar múltiples sensores de temperatura digitales DS18B20 a tu Arduino de una manera sencilla y efectiva. ¡Sigue leyendo para descubrir cómo puedes crear un sistema de monitoreo de temperatura personalizado y eficiente!

Una de las características del DS18B20 es que pueden coexistir varios DS18B20 en el mismo bus 1-Wire. Debido a que cada DS18B20 está preprogramado con un código de serie único de 64 bits, se pueden distinguir entre sí.

El siguiente tutorial le mostrará cómo leer la temperatura de varios DS18B20 conectados al mismo bus. Esta función puede resultar extremadamente útil si necesita controlar varios DS18B20 repartidos en un área grande.

Antes de continuar con este tutorial, debe estar familiarizado con los conceptos básicos del sensor de temperatura de un solo cable DS18B20. Lea primero el siguiente tutorial.

Conexión del sensor de temperatura digital de 1 cable DS18B20 a Arduino

Una de las formas más fáciles y rentables de integrar sensores de temperatura en su proyecto Arduino es utilizar un sensor de temperatura de 1 cable DS18B20. Estos sensores…

Sin más, conectemos el DS18B20s a nuestro Arduino.

Cableado de múltiples sensores DS18B20 a Arduino

Las conexiones son bastante simples.

Comience conectando todos los DS18B20 en paralelo y compartiendo todos los pines VDD, GND y Signal. Luego conecte VDD a la salida de 5 V del Arduino, GND a tierra del Arduino y el pin de señal al pin digital 2 del Arduino.

Para mantener estable la transferencia de datos, agregue una resistencia pull-up de bus completo de 4,7 kOhm entre los pines de señal y alimentación (nota: los pull-ups internos del Arduino no funcionarán aquí).

Instalar biblioteca para DS18B20

El protocolo 1-Wire es un poco complicado y requiere mucho código para que funcione. DallasTemperatura.h fue escrito para abstraer esta complejidad innecesaria y permitirnos emitir comandos simples para obtener lecturas de temperatura del sensor.

Para instalar la biblioteca, navegue hasta Bosquejo > Incluir biblioteca > Administrar bibliotecas… Espere a que el administrador de la biblioteca descargue el índice de la biblioteca y actualice la lista de bibliotecas instaladas.

Filtra tu búsqueda escribiendo 'ds18b20'. Debería haber algunas entradas. Buscar Dallastemperatura de Miles Burton. Haga clic en esta entrada y luego seleccione «Instalar».

Dallas Temperature es una biblioteca específica de hardware que maneja funciones de nivel inferior. Hay que combinarlo con eso. Biblioteca de un solo cable para comunicarse con cualquier dispositivo de un solo cable, no solo el DS18B20. Instale esta biblioteca también.

Métodos para leer varios DS18B20

Existen dos métodos para leer varios DS18B20 conectados al mismo bus.

• Por índice – En este método, utilizamos un índice (asignado por la biblioteca) para ubicar cada sensor y leer su temperatura.
• Por dirección – En este método leemos cada sensor individualmente aprovechando que cada sensor tiene su propia dirección de 64 bits (preprogramada).

Repasemos cada método uno por uno.

Método 1: lectura de DS18B20 por índice

Cuando se inicializa la biblioteca Dallas Temperature, busca en el bus todos los sensores que comparten el mismo bus. Considera todo el autobús como una serie de sensores y asigna un índice a cada uno. Esto nos permite identificar cada sensor por su índice y leer la temperatura.

Aquí hay un boceto simple que ubica todos los DSB1820 en el bus y luego muestra la temperatura de cada uno.

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into digital pin 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire device
OneWire oneWire(ONE_WIRE_BUS);	

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

int deviceCount = 0;
float tempC;

void setup(void)
{
  sensors.begin();	// Start up the library
  Serial.begin(9600);
  
  // locate devices on the bus
  Serial.print("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount, DEC);
  Serial.println(" devices.");
  Serial.println("");
}

void loop(void)
{ 
  // Send command to all the sensors for 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);
    Serial.print(tempC);
    Serial.print((char)176);//shows degrees character
    Serial.print("C  |  ");
    Serial.print(DallasTemperature::toFahrenheit(tempC));
    Serial.print((char)176);//shows degrees character
    Serial.println("F");
  }
  
  Serial.println("");
  delay(1000);
}

El resultado se ve así:

Explicación del código:

El boceto comienza incluyendo bibliotecas, declarando el pin al que está conectado el bus del sensor y creando un objeto de biblioteca DallasTemperature. Se definen dos variables en el mismo ámbito global: deviceCount almacena el número de sensores que se encuentran en el autobús y tempC almacena la temperatura medida por cada sensor.

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into digital pin 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire device
OneWire oneWire(ONE_WIRE_BUS);	

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

int deviceCount = 0;
float tempC;

En la sección de configuración del código, primero llamamos al begin() Función. Inicializa el bus y detecta todos los DS18B20 conectados. Luego, a cada sensor se le asigna un índice y la resolución de bits se establece en 12 bits.

El getDeviceCount() Luego se llama a la función para generar la cantidad de dispositivos detectados en el bus.

void setup(void)
{
  sensors.begin();	// Start up the library
  Serial.begin(9600);
  
  // locate devices on the bus
  Serial.print("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount, DEC);
  Serial.println(" devices.");
  Serial.println("");
}

En la sección de bucle del código usamos el requestTemperatures() Función para indicar a todos los sensores del bus que realicen una conversión de temperatura.

Finalmente, usamos uno simple. for Bucle para iterar a través del conjunto de sensores y leer la temperatura de un DS18B20 específico llamando a la función getTempCByIndex(i)

void loop(void)
{ 
  // Send command to all the sensors for 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);
    Serial.print(tempC);
    Serial.print((char)176);//shows degrees character
    Serial.print("C  |  ");
    Serial.print(DallasTemperature::toFahrenheit(tempC));
    Serial.print((char)176);//shows degrees character
    Serial.println("F");
  }
  
  Serial.println("");
  delay(1000);
}

Método 2: leer DS18B20 por dirección

Cada DS18B20 está programado con una dirección única de 64 bits en el momento de su fabricación para que puedan distinguirse entre sí. Por lo tanto, utilizamos un boceto para encontrar y registrar la dirección de cada sensor, y luego otro boceto para leer cada sensor individualmente.

Encontrar las direcciones de DS18B20 en un autobús

El siguiente esquema detecta todos los DS18B20 en el bus y genera sus direcciones de un solo cable en el monitor en serie.

Se recomienda que solo conecte un sensor a la vez para poder determinar la dirección de cada sensor y asignarle un nombre.

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// variable to hold device addresses
DeviceAddress Thermometer;

int deviceCount = 0;

void setup(void)
{
  // start serial port
  Serial.begin(9600);

  // Start up the library
  sensors.begin();

  // locate devices on the bus
  Serial.println("Locating devices...");
  Serial.print("Found ");
  deviceCount = sensors.getDeviceCount();
  Serial.print(deviceCount, DEC);
  Serial.println(" devices.");
  Serial.println("");
  
  Serial.println("Printing addresses...");
  for (int i = 0;  i < deviceCount;  i++)
  {
    Serial.print("Sensor ");
    Serial.print(i+1);
    Serial.print(" : ");
    sensors.getAddress(Thermometer, i);
    printAddress(Thermometer);
  }
}

void loop(void)
{}

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("");
}

Ahora abra el Monitor serie. Verás algo como esto.

Anota todas las direcciones ya que las necesitaremos en el siguiente boceto.

Leer DS18B20s por dirección

El siguiente esquema utiliza las direcciones de los DS18B20 para leer las temperaturas. Antes de comenzar a cargar el boceto, debe reemplazar las direcciones de los DS18B20 con las que se encuentran en el boceto anterior.

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// Addresses of 3 DS18B20s
uint8_t sensor1[8] = { 0x28, 0xEE, 0xD5, 0x64, 0x1A, 0x16, 0x02, 0xEC };
uint8_t sensor2[8] = { 0x28, 0x61, 0x64, 0x12, 0x3C, 0x7C, 0x2F, 0x27 };
uint8_t sensor3[8] = { 0x28, 0x61, 0x64, 0x12, 0x3F, 0xFD, 0x80, 0xC6 };

void setup(void)
{
  Serial.begin(9600);
  sensors.begin();
}

void loop(void)
{
  sensors.requestTemperatures();
  
  Serial.print("Sensor 1: ");
  printTemperature(sensor1);
  
  Serial.print("Sensor 2: ");
  printTemperature(sensor2);
  
  Serial.print("Sensor 3: ");
  printTemperature(sensor3);
  
  Serial.println();
  delay(1000);
}

void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  Serial.print(tempC);
  Serial.print((char)176);
  Serial.print("C  |  ");
  Serial.print(DallasTemperature::toFahrenheit(tempC));
  Serial.print((char)176);
  Serial.println("F");
}

El resultado del boceto anterior se ve así:

Explicación del código:

El boceto comienza como de costumbre incluyendo bibliotecas, declarando el pin al que está conectado el bus del sensor y creando un objeto de biblioteca DallasTemperature.

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

A continuación, ingresamos las direcciones previamente determinadas para cada sensor de temperatura.

uint8_t sensor1[8] = { 0x28, 0xEE, 0xD5, 0x64, 0x1A, 0x16, 0x02, 0xEC };
uint8_t sensor2[8] = { 0x28, 0x61, 0x64, 0x12, 0x3C, 0x7C, 0x2F, 0x27 };
uint8_t sensor3[8] = { 0x28, 0x61, 0x64, 0x12, 0x3F, 0xFD, 0x80, 0xC6 };

En el área de configuración inicializamos la comunicación serie con el PC y la llamamos. begin() Función. El begin() La función inicializa el bus, detecta todos los DS18B20 conectados y establece la resolución de bits para cada uno en 12 bits.

void setup(void) {
  Serial.begin(9600);
  sensors.begin();
}

En la sección de bucle del código usamos el requestTemperatures() Función para indicar a todos los sensores del bus que realicen una conversión de temperatura.

Finalmente, llamamos a la función definida por el usuario. printTemperature(deviceAddress) para imprimir la temperatura del sensor deviceAddress se pasa como parámetro.

void loop(void)
{
  sensors.requestTemperatures();
  
  Serial.print("Sensor 1: ");
  printTemperature(sensor1);
  
  Serial.print("Sensor 2: ");
  printTemperature(sensor2);
  
  Serial.print("Sensor 3: ");
  printTemperature(sensor3);
  
  Serial.println();
  delay(1000);
}

La función personalizada printTemperature() solo llama a la biblioteca getTempC(deviceAddress) Función para mostrar la temperatura en grados Celsius y DallasTemperature::toFahrenheit() Función para mostrar la temperatura en Fahrenheit.

void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  Serial.print(tempC);
  Serial.print((char)176);
  Serial.print("C  |  ");
  Serial.print(DallasTemperature::toFahrenheit(tempC));
  Serial.print((char)176);
  Serial.println("F");
}

Conexión de múltiples sensores de temperatura digitales DS18B20 a Arduino

Uno de los atributos del DS18B20 es que múltiples DS18B20 pueden coexistir en el mismo bus de 1-Wire. Debido a que cada DS18B20 está preprogramado con un código serial único de 64 bits, pueden distinguirse entre sí.

¿Qué necesitas saber antes de conectarte?

Antes de continuar con este tutorial, debes estar familiarizado con los conceptos básicos del sensor de temperatura DS18B20 de un solo cable. Te recomendamos leer el tutorial a continuación primero: Enlace al tutorial de Interfaz de Sensor de Temperatura Digital DS18B20 con Arduino

Conexión de múltiples sensores DS18B20 a Arduino

Las conexiones son bastante sencillas:

1. Comienza conectando todos los DS18B20 en paralelo, compartiendo todos los pines VDD, GND y de señal.
2. Luego conecta VDD a la salida de 5V de Arduino, GND a tierra de Arduino y el pin de señal al pin digital 2 en Arduino.
3. Para mantener estable la transferencia de datos, agrega una resistencia pull-up de 4.7k para todo el bus entre el pin de señal y el pin de energía.

Instalación de biblioteca para DS18B20

El protocolo de 1-Wire es un poco complicado, y requiere mucho código para hacerlo funcionar. La biblioteca DallasTemperature.h se encarga de abstraer esta complejidad innecesaria, permitiéndonos emitir comandos simples para obtener lecturas de temperatura del sensor.

Para instalar la biblioteca, navega a Sketch > Include Library > Manage Libraries… Espera a que el Administrador de Bibliotecas descargue el índice de bibliotecas y actualice la lista de bibliotecas instaladas.

Filtra tu búsqueda ingresando ‘ds18b20’. Debería haber un par de entradas. Busca DallasTemperature de Miles Burton. Haz clic en esa entrada y luego elige Instalar.

Dallas Temperature es una biblioteca específica de hardware que maneja funciones de nivel inferior. Debe ser emparejada con la Biblioteca One Wire para comunicarse con cualquier dispositivo de un solo cable, no solo con el DS18B20. Instala esta biblioteca también.

Métodos para leer múltiples DS18B20

Existen dos métodos para leer múltiples DS18B20 conectados al mismo bus.

1. Por Índice: En este método, utilizamos un índice (asignado por la biblioteca) para señalar cada sensor y leer su temperatura.
2. Por Dirección: En este método, leemos cada sensor individualmente aprovechando el hecho de que cada sensor tiene su propia dirección de 64 bits (preprogramada).

Aquí te dejamos un esquema simple que localiza todos los DS18B20 en el bus y muestra la temperatura de cada uno.

        
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into digital pin 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire device
OneWire oneWire(ONE_WIRE_BUS); 

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

int deviceCount = 0;
float tempC;

// Resto del código...
        
    

Recuerda que para ver el código completo y las explicaciones detalladas, te recomendamos revisar el tutorial original aquí.