Interface de vários sensores de temperatura DS18B20 com o Arduino

Tempo de leitura: 6 minutes

Interface de vários sensores de temperatura DS18B20 com o Arduino:

Neste projeto, aprenderemos sobre a interface de vários sensores de temperatura DS18B20 com o Arduino. Simplesmente conectaremos vários sensores de temperatura DS18B20 ao Arduino e exibiremos os valores de temperatura de todos os sensores em graus Celsius ou Fahrenheit. Apenas um pino digital do Arduino é necessário para conectar vários sensores de temperatura. Podemos conectar no máximo 1024 sensores usando o protocolo I2C. Mas aqui eu mostrei a conexão de 3 sensores de temperatura DS18B20 ao Arduino.

O sensor de temperatura DS18B20 é um sensor de temperatura digital de 1 fio. Isso vem com um pacote selado que permite medir com precisão as temperaturas em ambientes úmidos com uma interface simples de 1 fio. Ele se comunica em um barramento comum. Isso significa que ele pode conectar vários dispositivos e ler seus valores usando apenas um pino digital do Arduino.

 

DS18B20 Sensor de temperatura digital à prova d’água:

Esta é uma versão pré-cabeada e à prova d’água do sensor DS18B20. Útil para quando você precisa medir algo distante ou em condições úmidas. O sensor pode medir a temperatura entre -55 a 125°C (-67°F a + 257°F). O cabo é revestido em PVC.

Por ser digital, não há degradação do sinal mesmo em longas distâncias. Esses sensores de temperatura digitais de 1 fio são bastante precisos, ou seja, ± 0,5°C em grande parte da faixa. Ele pode fornecer até 12 bits de precisão do conversor digital para analógico integrado. Eles funcionam muito bem com qualquer microcontrolador usando um único pino digital.

A única desvantagem é que eles usam o protocolo Dallas 1-Wire, que é um tanto complexo e requer um monte de código para analisar a comunicação. Colocamos um resistor de 4,7k, que é necessário como um pullup de DATA para a linha VCC ao usar o sensor.

Componentes necessários:

1. Placa Arduino UNO
2. Vários sensores de temperatura à prova d’água DS18B20
3. Display LCD 16*2
4. Resistor de 4,7K
5. ProtoBoard
6. Conexão de fios de jumper

 

Diagrama de circuito e conexões:

Conecte o pino 11,12,5,4,3,2 do Arduino ao pino 4,6,11,12,13,14 do LCD.

Conecte o pino VDD do DS18B20 a 5V e o pino GND ao aterramento. Conecte o pino de dados de todo o DS18B20 ao pino digital 9 do Arduino e também ao resistor de 4,7 K (conecte a outra extremidade do resistor de 4,7 K a 5 V) conforme mostrado na figura abaixo.

 

Hardware e Design:

Ao conectar todos os sensores a um pino digital do Arduino, simplesmente projetamos o termômetro digital para medir temperaturas múltiplas. Portanto, a imagem abaixo mostra como fizemos a interface de vários sensores de temperatura DS18B20 com o Arduino e como a temperatura está sendo exibida.

 

Código-fonte / Programa:

Para fazer a interface de vários sensores de temperatura DS18B20 com o Arduino, você precisa de duas bibliotecas diferentes
1. Baixe a Biblioteca 1 Wire
2. Baixe a Biblioteca de Temperatura de Dallas

#include <LiquidCrystal.h>
LiquidCrystal lcd(11, 12, 5, 4, 3, 2);
#include <OneWire.h>
#include <DallasTemperature.h>
 
#define ONE_WIRE_BUS 9 // O fio de dados está conectado à porta 9 no Arduino
#define precision 12 // Sensor Dallas de precisão OneWire
int sen_number = 0; // Contador de sensores Dallas
 
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire); // Passe nossa referência oneWire para Dallas Temperature.
DeviceAddress T1, T2, T3, T4, T5, T6, T7, T8; // arrays para manter endereços de dispositivos

void setup(void)
{
  lcd.begin(16,2);
  Serial.begin(9600); //Iniciar porta serial
  Serial.println("Biblioteca de controle de IC de temperatura de Dallas");
  // Inicie a biblioteca
  sensors.begin();
  // localizar dispositivos no ônibus
  Serial.print("Found: ");
  Serial.print(sensors.getDeviceCount(), DEC);
  Serial.println(" Devices.");
  // relatar requisitos de energia do parasita
  Serial.print("Parasite power is: ");
  if (sensors.isParasitePowerMode()) 
      Serial.println("ON");
  else Serial.println("OFF");
  // Procure dispositivos no barramento e atribua com base em um índice.
  if (!sensors.getAddress(T1, 0)) Serial.println("Sensor não encontrado 1");
  if (!sensors.getAddress(T2, 1)) Serial.println("Sensor não encontrado 2");
  if (!sensors.getAddress(T3, 2)) Serial.println("Sensor não encontrado 3");
  if (!sensors.getAddress(T4, 3)) Serial.println("Sensor não encontrado 4");
  if (!sensors.getAddress(T5, 4)) Serial.println("Sensor não encontrado 5");
  if (!sensors.getAddress(T6, 5)) Serial.println("Sensor não encontrado 6");
  if (!sensors.getAddress(T7, 6)) Serial.println("Sensor não encontrado 7");
  if (!sensors.getAddress(T8, 7)) Serial.println("Sensor não encontrado 8");
 
  // mostra os endereços que encontramos no ônibus
  for (int k =0; k < sensors.getDeviceCount(); k++) {
      Serial.print("Sensor "); 
      Serial.print(k+1);
      Serial.print(" Address: ");
      if (k == 0) { printAddress(T1); Serial.println();
      } else if (k == 1) { printAddress(T2); Serial.println();
      } else if (k == 2) { printAddress(T3); Serial.println();
      } else if (k == 3) { printAddress(T4); Serial.println();
      } else if (k == 4) { printAddress(T5); Serial.println();
      } else if (k == 5) { printAddress(T6); Serial.println();
      } else if (k == 6) { printAddress(T7); Serial.println();
      } else if (k == 7) { printAddress(T8); Serial.println(); }
  }

  // defina a resolução para 12 bits por dispositivo
  sensors.setResolution(T1, precision);
  sensors.setResolution(T2, precision);
  sensors.setResolution(T3, precision);
  sensors.setResolution(T4, precision);
  sensors.setResolution(T5, precision);
  sensors.setResolution(T6, precision);
  sensors.setResolution(T7, precision);
  sensors.setResolution(T8, precision);
  for (int k =0; k < sensors.getDeviceCount(); k++) {
      Serial.print("Sensor "); Serial.print(k+1);
      Serial.print(" Resolution: ");
      if (k == 0) { Serial.print(sensors.getResolution(T1), DEC); Serial.println();
      } else if (k == 1) { Serial.print(sensors.getResolution(T2), DEC); Serial.println();
      } else if (k == 2) { Serial.print(sensors.getResolution(T3), DEC); Serial.println();
      } else if (k == 3) { Serial.print(sensors.getResolution(T4), DEC); Serial.println();
      } else if (k == 4) { Serial.print(sensors.getResolution(T5), DEC); Serial.println();
      } else if (k == 5) { Serial.print(sensors.getResolution(T6), DEC); Serial.println();
      } else if (k == 6) { Serial.print(sensors.getResolution(T7), DEC); Serial.println();
      } else if (k == 7) { Serial.print(sensors.getResolution(T8), DEC); Serial.println(); }
  }
}

// função para imprimir um endereço de dispositivo
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    // zero preencha o endereço se necessário
    if (deviceAddress[i] < 16) 
      Serial.print("0");
      Serial.print(deviceAddress[i], HEX);
    }
  }
}

// função para imprimir a temperatura de um dispositivo
void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  Serial.print("Temp : ");
  Serial.print(tempC);
  Serial.print(" celcius degrés ");
  // Serial.print(" Temp F: ");
  // Serial.print(DallasTemperature::toFahrenheit(tempC));
}

// função para imprimir a resolução de um dispositivo
void printResolution(DeviceAddress deviceAddress)
{
}
 
void printData(DeviceAddress deviceAddress)
{
  Serial.print("Device Address: ");
  printAddress(deviceAddress);
  Serial.print(" ");
  printTemperature(deviceAddress);
  Serial.println();
}
 
void loop(void)
{
  // call sensors.requestTemperatures() para emitir uma solicitação de temperatura global para todos os dispositivos no barramento
  Serial.print("Reading DATA..."); 
  sensors.requestTemperatures(); 
  Serial.println("DONE");
  // imprimir as informações do dispositivo
  for (int k =0; k < sensors.getDeviceCount(); k++) {
     Serial.print("Sensor "); 
     Serial.print(k+1); 
     Serial.print(" ");
     if (k == 0) { 
        printData(T1);
     } else if (k == 1) {
   	    printData(T2);
     } else if (k == 2) { 
        printData(T3);
     } else if (k == 3) { 
        printData(T4);
     } else if (k == 4) { 
        printData(T5);
     } else if (k == 5) { 
        printData(T6);
     } else if (k == 6) { 
        printData(T7);
     } else if (k == 7) { 
        printData(T8);
     }
  }
  if (sen_number == sensors.getDeviceCount()) {
    sen_number = 0; // Reiniciar contador
    // lcd.clear(); // limpar a tela no LCD
  }
  lcd.setCursor(0,0);
  lcd.print("Sensor Number ");
  lcd.print(sen_number+1);
  lcd.setCursor(0,1);
  lcd.print(" Temp: ");
  if (sen_number == 0) { lcd.print(sensors.getTempC(T1)); lcd.write((char)223); lcd.print("C ");
  } else if (sen_number == 1) { lcd.print(sensors.getTempC(T2)); lcd.write((char)223); lcd.print("C "); 
  } else if (sen_number == 2) { lcd.print(sensors.getTempC(T3)); lcd.write((char)223); lcd.print("C ");
  } else if (sen_number == 3) { lcd.print(sensors.getTempC(T4)); lcd.write((char)223); lcd.print("C ");
  } else if (sen_number == 4) { lcd.print(sensors.getTempC(T5)); lcd.write((char)223); lcd.print("C ");
  } else if (sen_number == 5) { lcd.print(sensors.getTempC(T6)); lcd.write((char)223); lcd.print("C ");
  } else if (sen_number == 6) { lcd.print(sensors.getTempC(T7)); lcd.write((char)223); lcd.print("C ");
  } else if (sen_number == 7) { lcd.print(sensors.getTempC(T8)); lcd.write((char)223); lcd.print("C ");
  }
  Serial.print("Sensor Number="); Serial.println(sen_number);
  delay(2000);
  sen_number++ ;
}

 

Trabalho de vários sensores de temperatura DS18B20 com Arduino:

O DS18B20 fornece leituras de temperatura de 9 a 12 bits (configuráveis) que indicam a temperatura do dispositivo. Ele se comunica por meio de um barramento de 1 fio que, por definição, requer apenas uma linha de dados (e terra) para comunicação com um microprocessador central. Além disso, ele pode derivar energia diretamente da linha de dados (“energia parasita”), eliminando a necessidade de uma fonte de alimentação externa.

A funcionalidade central do DS18B20 é seu sensor de temperatura direto para digital. A resolução do sensor de temperatura pode ser configurada pelo usuário em 9, 10, 11 ou 12 bits, correspondendo a incrementos de 0,5 ° C, 0,25 ° C, 0,125 ° C e 0,0625 ° C, respectivamente. A resolução padrão na inicialização é de 12 bits.

Cada DS18B20 tem um endereço de dispositivo específico no formato HEX como {0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0}. Portanto, o programa é projetado com base na leitura da temperatura de um endereço de dispositivo específico. Portanto, primeiro o Arduino verifica o número de sensores. Vamos supor que 3 sensores estejam conectados aqui. Portanto, ele exibirá apenas valores de 3 leituras diferentes. Se mais sensores estiverem conectados, a leitura mudará para vários valores. O valor da temperatura lido por cada sensor é exibido após intervalo de 2 segundos como Temperatura do Sensor Número 1, Temperatura do Sensor Número 2 e até o valor do número de sensores conectados.

Visits: 2 Visits: 1200115