Termostato Arduino com Sensor de Temperatura DS18B20 e Relé

Você sabe como construir um termostato ON/OFF inteligente e com uma interface homem-máquina, para configuração de seus parâmetros ? Saiba tudo em nosso artigo!

Termostato Arduino

As prensas térmicas, chocadeiras e diversos equipamentos que trabalham com sistema de aquecimento necessitam de um controle de temperatura. Esse controle é utilizado, para manter a temperatura em um valor ajustado pelo usuário. Para isto, utilizamos um termostato.

Por meio dele, realizamos o controle de temperatura e configuramos o valor de setpoint. O setpoint é um valor de referência para controle da temperatura do sistema.

Quando o valor de temperatura do ambiente for maior ou igual ao setpoint, o sistema desativa o aquecedor. Caso seja menor, o sistema liga o aquecedor.

De acordo com seu funcionamento, desenvolveremos um termostato ON/OFF com Arduino, a fim de realizar o controle do sistema. Assim como, utilizaremos o sensor de temperatura DS18B20, para monitorar a temperatura do sistema e apresentar na tela de LCD.

Portanto, de acordo com valor de temperatura lido, ativaremos ou desativaremos o relé, para controlar o aquecimento do sistema.

A seguir, apresentaremos todo o projeto de construção do termostato ON/OFF.

 

Desenvolvendo o Termostato Arduino ON/OFF

De acordo com o princípio de funcionamento do dispositivo, serão implementadas as seguintes funcionalidades:

  1. Criação de tela de confirmação, para alteração do valor da temperatura;
  2. Implementar função para salvar o valor de temperatura ajustada pelo usuário, mesmo que o sistema desligue e ligue novamente;
  3. Criação de um teclado para configurar o valor da temperatura, de modo a utilizar apenas 2 botões;
  4. Trabalhar com o sensor de temperatura DS18B20;
  5. Criação de Menus no LCD 16 x 2.

E antes de começarmos, disponibilizamos toda a lista de materiais necessários para construir esse projeto.

 

Lista de Materiais

Todos os componentes eletrônicos abaixo serão utilizados:

A seguir, será apresentaremos o circuito Termostato com o Arduino.

 

O Circuito do Termostato

No circuito da Figura 1, temos 3 push buttons. O 1 (+) e o 2 (-), respectivamente, são utilizados para incremento e decremento do valor de ajuste da temperatura.

O botão 3 (set) é utilizado para entrar nas configurações de temperatura ou salvar a temperatura ajustada pelo usuário.

O LCD será utilizado para receber e apresentar as telas e informações de temperatura do sensor DS18B20 Arduino (4).

 

Esquema Eletrônico do Termostato

Figura 1 – Esquema Eletrônico do Circuito do Termostato.

Quando a temperatura do sistema for menor que o valor ajustado pelo usuário, o relé será acionado. Dessa forma, o aquecedor ligará, para manter a temperatura do sistema.

E agora, analisaremos todo o código desenvolvido para controle do termostato Arduino.

 

Análise do Código

Para este projeto, incluímos as bibliotecas dos periféricos e dispositivos utilizados no projeto, conforme apresentado nas linhas 001 a 004.

Os pinos do LCD foram configurados  (Linhas 006 e 007) e iniciamos o processo de configuração do sensor DS18B20.

O Sensor DS18B20 Arduino

O Sensor DS18B20 é um sensor digital que utiliza o protocolo 1-Wire (Saiba mais nesse outro artigo).

Portanto, é um sensor digital com boa precisão, confiável e com característica parasite power (Saiba mais sobre Parasite Power).

Nas linhas 009 a 017, fizemos a configuração de funcionamento do sensor DS18B20.

E observe que na linha 10, o valor 8 é definido com o nome ONE_WIRE_BUS. Isto serve para usarmos esse nome como referência ao pino digital 8, onde conectaremos o sensor de temperatura.

Logo em seguida, criamos uma instância chamada oneWire e passamos o pino digital que o nosso sensor está conectado (ONE_WIRE_BUS ).

No protocolo 1-Wire, o dispositivo se comunica por um único fio e permite a comunicação de diversos dispositivos no mesmo barramentos (Leia este Application Note).

Por fim, passaremos oneWire como referência para que o objeto sensors possa saber que utilizaremos o sensor DS18B20 conectado ao pino digital 8. Logo, todos os dados do sensor serão lidos e manipulados pelas funções da biblioteca DallasTemperatura.

Consequentemente, para que possamos trabalhar com esses dados e dispositivos de entradas, necessitamos criar diversos tipos de variáveis para manipular os dados de projeto.

 

Declaração de Variáveis e Definição de Dados

Foram declaradas diferentes variáveis para armazenar os dados dos botões, estado dos botões e sensor, de acordo como comentado em cada variável. E além da variável, fizemos 2 definições de extrema importância no código.

Definimos o valor 120 como EndVerif e o valor 125 como EndTemp (Linhas 035 e 038).

Esses dois valores serão utilizados para salvarmos dados nas posições 120 e 125 da memória EEPROM, referente ao nosso sensor de temperatura.

Mas antes de iniciarmos a apresentação da lógica de gravação dos dados na memória, devemos compreender o processo de configuração de cada dispositivo e sensor na função void setup.

Função void setup

Na função void setup, inicializamos o nosso LCD como 16 x 2 (Linha 043) e aguardamos um tempo de 500 ms para a sua inicialização (Linha 045). Em seguida, imprimimos a mensagem Loja UsinaInfo por 3 segundos (Linhas 047 a 052), conforme apresentada na Figura 2.

Mensagem Loja UsinaInfo.

Figura 2 – Apresentação da mensagem Loja UsinaInfo.

Em seguida, realizamos 4 comandos de configuração:

  1. Inicialização do sensor DS18B20 Arduino (Linha 055);
  2. Limpeza da tela do LCD 16 x 2 (Linha 057).
  3. Configuração do pino de conexão do relé como saída digital (Linha 059);
  4. Leitura do valor de temperatura salvo na memória (Linha 061).

O ponto quarto comando de configuração é bastante útil. Através desse comando, conseguimos resgatar  na inicialização, o valor de temperatura ajustado pelo usuário. A seguir, explicaremos como realizar o processo de salvar o valor na memória.

Após esta etapa, iniciaremos a apresentação de toda a lógica e configuração de parâmetros do termostato ON/OFF.

#include <LiquidCrystal.h> //Inclusao da biblioteca do LCD
#include <EEPROM.h> //Inclusao da biblioteca para manipulacao das funcoes da memoria EEPROM
#include <OneWire.h>  //Inclusao da biblioteca para manipulacao das funcoes de dispositivos OneWire
#include <DallasTemperature.h> //Inclusao da biblioteca para manipulacao das funcoes do sensor DS18B20

const int rs = 2, en = 3, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

//Fio de dados de temperatura é conectado ao pino 11 no Arduino 
#define ONE_WIRE_BUS 8 
/********************************************************************/
//Configura uma instância oneWire para se comunicar com qualquer dispositivo OneWire 
OneWire oneWire(ONE_WIRE_BUS); 
/********************************************************************/

//Endereçamento do dispositivo sensor DS18B20
DeviceAddress sensor1;

//Passar nossa referência oneWire para Dallas Temperature.
DallasTemperature sensors(&oneWire);

//Variavel para verificar se o usuário já configurou a temperatura durante a inicialização do sistema
unsigned int verificador = 0;

//Variaveis utilizadas para realizar a leitura dos botoes de configuracao do sistema
bool incremento, decremento, set = 0;

//Variaveis utilizadas para armazenar o estado de acionamento dos botoes
bool EstadoIncremento = 0, EstadoDecremento = 0, EstadoSet = 0;

//Variavel para armazenar o valor de ajuste de temperatura
unsigned int temperatura = 0;

//Variavel utilizada para armazenar o tempo de execucao atual do codigo
unsigned long int tempo_atual = 0;

//Variavel utilizada para armazenar o ultimo valor armazenado na variavel tempo_atual
unsigned long ultimo_tempo = 0; 

byte ValorAnterior = 0;

//Definicao da palavra memoria para representar o valor 120
#define EndVerif 120
#define EndTemp  125

void setup()
{

    Serial.begin(9600);
    //put your setup code here, to run once:
    lcd.begin(16, 2);

      delay(500);

    lcd.setCursor(6,0);
    lcd.print("Loja");
    lcd.setCursor(4,1);
    lcd.print("UsinaInfo");

      delay(3000);

      //Inicialização do funcionamento do Sensor DS18B20
      sensors.begin();
      lcd.clear();

      pinMode(13, OUTPUT);
      
}

void loop() 
{
    
         set = digitalRead(12);
         
         if(set == 1)
         {

           lcd.clear();
           lcd.setCursor(2,0);
           lcd.print("Reconfigurar?");

           lcd.setCursor(0,1);
           lcd.print("Sim (+)  Nao (-)");
           
           do
           {
           
           incremento = digitalRead(10); //Leitura do estado do pino digital do botao incremento
           decremento = digitalRead(11); //Leitura do estado do pino digital do botao decremento
           
           delay(50);

              if(incremento == 1 && decremento == 0)
              {
               verificador = 0;
               EEPROM.write(EndVerif,0);
              }
              
           }while(incremento == 0 && decremento == 0);

               delay(200);
               lcd.clear();
         }
    
          verificador = EEPROM.read(EndVerif);

      if(verificador != 75)
      {
        
        lcd.setCursor(3,0);
        lcd.print("Configurar");
        lcd.setCursor(0,1);
        lcd.print("Temperatura:");

              temperatura = EEPROM.read(EndTemp); //Leitura do valor da posicao EndTemp
        
            do
            {
              incremento = digitalRead(10); //Leitura do estado do pino digital do botao incremento
              decremento = digitalRead(11); //Leitura do estado do pino digital do botao decremento
              set        = digitalRead(12); //Leitura do estado do pino digital do botao set
              
                delay(50);

                  if(incremento == 1 && EstadoIncremento == 0)
                  {
                    temperatura++; //Incrementa o valor da temperatura
                    EstadoIncremento = 1; //Armazena 1 na variavel incremento 
                    lcd.setCursor(13,1); //Configura o cursor na posição da segunda linha e coluna 13
                    lcd.print("   ");
                  }

                  if(incremento == 0 && EstadoIncremento == 1)
                  {
                    EstadoIncremento = 0; //Armazena 0 na variavel decremento para indicar o estado atual do botao incremento - desacionado  
                  }

                  if(decremento == 1 && EstadoDecremento == 0)
                  {
                    temperatura--; //Decrementa o valor da temperatura
                    EstadoDecremento = 1; //Armazena 0 na variavel decremento para indicar o estado atual do botao decremento
                    lcd.setCursor(13,1); //Configura o cursor na posição da segunda linha e coluna 13
                    lcd.print("   ");    
                  }

                  if(decremento == 0 && EstadoDecremento == 1)
                  {
                    EstadoDecremento = 0; //Armazena 0 na variavel decremento para indicar o estado atual do botao decremento - desacionado
                  }

             lcd.setCursor(13,1); //Configura o cursor na posição da segunda linha e coluna 13
             lcd.print(temperatura); //Imprime o valor da temperatura na tela     

            }while(set != 1);

            lcd.clear();
            EEPROM.write(EndVerif,75); //Salva o valor 75 na posição EndVerif
            EEPROM.write(EndTemp, temperatura); //Salva o valor da temperatura configurada na posição EndTemp
      }
             
             //lcd.clear();//Limpar a tela do LCD

             //Configurar o sensor DS18B20 e fazer a leitura do seu valor digital
             Serial.print(" Solicitando temperatura..."); 
             sensors.requestTemperatures(); // Envia o comando para obter leituras de temperatura 
             Serial.println("Leitura realizada!"); 
            /********************************************************************/
             Serial.print("A Temperature e:"); 
             Serial.println(sensors.getTempCByIndex(0)); 
             //O Index e utilizado, pois pode existir mais de um sensor conectado ao barramento
             
             float TempSensor = sensors.getTempCByIndex(0);
             //float temperatura = sensors.getTempC(sensor1);
                
                if(TempSensor != ValorAnterior)
                {
                 lcd.setCursor(2,0);
                 lcd.print("Temperatura");
                 lcd.setCursor(4,1);
                 lcd.print(TempSensor);
                 lcd.print((char)223);
                 lcd.print("C");
             
                 ValorAnterior = TempSensor;

                  if(TempSensor >= temperatura)
                  {
                    digitalWrite(13, HIGH);  
                  }

                  if(TempSensor < temperatura)
                  {
                    digitalWrite(13, LOW);  
                  }
                }                         
               
 
}
Lógica de funcionamento na função loop do código principal do termostato Arduino

No início, realizamos a leitura do pino do botão de configuração (Linha 068). Isto serve para verificar se o usuário pressionou o botão e, consequentemente, entrar no menu de configuração da temperatura.

 

Tela de Menu para ajuste de temperatura do termostato

Então, caso o usuário pressione o botão (Linha 070), o sistema apresentará uma mensagem. Então, aparecerá a mensagem Reconfigurar o Sistema com duas opções Sim e Não (Linhas 073 a 078). A tela de reconfiguração é apresentada na Figura 3.

Figura 3 – Tela de Reconfiguração da Temperatura do Sistema.

Portanto, o usuário poderá configurar a temperatura ou sair do menu, caso tenha pressionado o botão de forma acidental.

Após pressionar o botão e a mensagem for impressa, o sistema fica em loop no laço (Linhas 080 a 093). Nesse momento, realizará o processo de leituras dos botões incremento e decremento.

Além de utilizar esses botões como valor de ajuste, também utilizamos com outra finalidade, para reduzir a quantidade de botões. Isto torna a interface do usuário mais simples!

Logo após a leitura dos botões (Linhas 083 e 084), realizamos o tratamento de debounce com um delay (Linha 086). Por fim, analisamos uma condição (Linha 088), para verificar se o botão incremento está pressionado e o decremento não pressionado.

Portanto, caso a condição seja verdade, o valor 0 será salvo na posição EndVerif (120) da memória EEPROM. Em seguida, sairá do laço, já que a condição de permanência será falsa. A outra forma de saída do laço é quando o botão decremento (Não) é pressionado pelo usuário (Linha 093).

 

Importância do uso da EEPROM em máquinas com ajustes de parâmetros

Conforme é possível observar na linha 90, gravamos o valor 0 na posição de memória EndVerif(120). Afinal, por que gravar este valor na memória EEPROM ?

Este procedimento está presente em muitas máquinas. Ele é útil quando ocorre um processo de desligamento da máquina. Dessa forma, os dados de parâmetros permanecerão armazenados e serão lidos quando a máquina for ligada novamente.

Portanto, sempre que o dispositivo for ligado, ele verifica se o ajuste de temperatura da máquina já foi realizado (Linha 098).

Ele faz a leitura do valor da posição EndVerif (120) da memória EEPROM (Linha 098). Caso o valor lido seja diferente de 75, automaticamente o sistema entrará na condição (Linha 101). Portanto, o usuário realizará o processo de ajuste da temperatura do termostato.

O valor 75 foi escolhido de forma arbitrária. Logo, ele será salvo quando o usuário configurar a temperatura ou sinalizará que o sistema já está configurado.

É importante garantir que o sistema entre automaticamente na condição (Linha 100), na primeira vez que o equipamento for ligado. Dessa maneira, faça uma limpeza zerando todas as posições de sua memória EEPROM. Deste modo, o valor lido será 0, que é diferente de 75.

Diante disso, utilize este código (Clear EEPROM Memory) para limpar a memória EEPROM. antes de gravar o código do projeto.

 

Configuração do parâmetro de temperatura do Termostato Arduino

Após a entrada na condição (Linha 100), aparecerá a mensagem Configurar Temperatura (Linhas 103 a 106). Em seguida, é realizada a leitura do valor de temperatura armazenada na posição EndTemp (125) da memória EEPROM.

Logo após a leitura, o valor lido será 0, pois a memória EEPROM estará com todas as posições zeradas inicialmente. Em seguida, o valor será apresentado na tela, conforme apresentado na Figura 4.

Tela de Configuração da Temperatura

Figura 4 – Tela de Configuração de Temperatura.

Caso a temperatura já tenha sido configurada outra vez, aparecerá o último valor ajustado pelo usuário.

Então, o sistema ficará em loop realizando a leitura dos botões. A lógica de leitura verifica o botão pressionado e armazena seu estado anterior, para evitar incrementar mais de uma vez. Portanto, essa lógica simula um contador com incremento e decremento utilizando botões (Linhas 118 a 138).

A partir da modificação dos valores, o sistema apresenta o valor na tela.

Quando o usuário pressiona o botão set, a condição será falsa e a execução sairá do loop (Linha 145). Após isto, a tela do LCD será limpa e o valor 75 será salvo na posição EndVerif da EEPROM. Logo, esse valor será utilizado para sinalizar que a temperatura está ajustada no sistema.

Em seguida, o valor de ajuste da temperatura é salvo na posição EndTemp (Linha 149). Isto serve para manter o valor salvo em caso de falta de energia. Portanto, evitará a perda da informação, quando o sistema for ligado novamente. O valor salvo será lido novamente na inicialização do sistema (Linha 061).

 

Requisição de Temperatura e acionamento do aquecedor do Termostato

Após isto, o sistema voltará para execução nomal. Desse modo, fará a requisição de temperatura e receberá o valor pelo index 0. Este index representa o único sensor utilizado (Linha 154).

Por fim, apresentamos o valor da temperatura quando a condição (Linhas 156) é verdadeira, conforme apresentado na Figura 5. Esta condição é utilizada para evitar que o sistema apresente o mesmo valor anterior de temperatura.

Figura 5 – Apresentação da Temperatura do Sistema.

Em seguida, será verificado se o valor é diferente do anterior. Portanto, se for verdade, apresentará a temperatura na tela do LCD 16 x 2. Em seguida, pegará o valor atual e guardará na variável ValorAnterior para ser utilizada como referência na próxima comparação.

Após isto, o sistema compara a temperatura do ambiente com o valor de ajuste. Com base na comparação, ele acionará ou desligará o relé do aquecedor do sistema (Linhas 167 a 175).

 

Conclusão

Finalmente, através do sistema desenvolvido para o Termostato Arduino com Sensor de Temperatura DS18B20, foi possível obter o resultado esperado e implementar diversas funcionalidades. Portanto, entre as funcionalidades, foi possível criar um dispositivo termostato inteligente com os seguintes recursos:

  1. Criação de tela de confirmação, para alteração do valor da temperatura;
  2. Função para salvar o valor de temperatura ajustada pelo usuário, mesmo que o sistema desligue e ligue novamente;
  3. Criação de um teclado para configurar o valor da temperatura, de modo a utilizar apenas 2 botões;
  4. Trabalhar com o sensor de temperatura DS18B20;
  5. Criação de Menus no LCD 16 x 2.

Logo, todos os requisitos do sistema foram implementados e podem ser modificados para criação de um novo projeto.

Conheça toda Linha de Produtos Arduino na UsinaInfo.

 

Referências Bibliográficas

Todas as referências utilizadas, encontram-se disponíveis em links ao longo do nosso artigo.

Categorias
ArduinoProjetos

Técnico em Automação Industrial e graduando do curso de Tecnologia em Mecatrônica Industrial pelo Instituto Federal do Ceará. E, atualmente, trabalha como desenvolvedor de projetos, sistemas inteligentes e criador de conteúdo por meio da empresa Silícios Lab para o seu canal e para o blog da UsinaInfo. Nas horas livres, desenvolve alguns projetos com Microcontroladores e Arduino.
Sem Comentários

Enviar Resposta

*

*

Sobre nós

Hoje a Usinainfo é um dos maiores ecommerces de Ferramentas, Peças para Eletrônica, Componentes Eletrônicos, Sensores e Arduino do Brasil, contando com uma grande diversidade de produtos na linha de eletrônica.

Sugestões
  • Continuando a série de tutoriais sobre Micropython ESP32, iremos desenvolver alguns projetos para exemplificar o seu uso. Em todos os exemplos, estaremos utilizando o uPyCraft IDE. O entendimento do...
  • Micropython ESP32 é uma linguagem de programação compacta, porém eficiente, derivada de Python 3. Ela inclui diversas subfunções da biblioteca padrão do Python e é otimizada para rodar em...
  • Nesse projeto iremos usar o Sensor AM2302 para exibir informações de temperatura e umidade no display integrado do NodeMCU ESP32 Display OLED. Veremos como utilizar a biblioteca DHT para...
  • Termostato Arduino As prensas térmicas, chocadeiras e diversos equipamentos que trabalham com sistema de aquecimento necessitam de um controle de temperatura. Esse controle é utilizado, para manter a temperatura...

Artigos Relacionados