Objetivo

Criar um termômetro com barra gráfica de leds e um alarme de temperatura. Quando a temperatura de onde o sensor estiver localizado for maior ou menor que um valor definido, o alarme será acionado. A variação de temperatura poderá ser visualizada através da barra gráfica (bargraph), onde os leds se acendem quando a temperatura é aumentada ou se apagam quando a temperatura é reduzida.

Obs.: Caso não possua barra gráfica de leds (bargraph), substitua o componente por leds, conforme mostramos no projeto Projeto 12a - Termômetro com leds e sensor de temperatura

Aplicação

Para fins didáticos. Simula processos industriais onde as temperaturas devem ser controladas.

Componentes necessários

Referência

Componente

Quantidade

 Imagem

Observação

 Protoboard  Protoboard 830 pontos 1 Resultado de imagem para protoboard 830v No mínimo utilizar protoboard com 830 pontos
Resistor  Resistor 300Ω  1 Se precisar usar outros valores, calcule o resistor apropriado para o led utilizado - Calcular Resistor
  Sensor de Temperatura LM35  Sensor de Temperatura LM35  1   Utilizamos um sensor, segundo o datasheet do fabricante, com faixa de temperatura de -55ºC  até +150ºC e incremento de
10mV/ºC, ou seja, cada vez que a temperatura ambiente aumenta 1ºC, o sensor aumenta em 10mV a tensão no pino de saída.
Buzzer  Buzzer 5V  1  
Barra Gráfica (bargraph) Barra Gráfica de Leds 1

 
Arduino UNO R3 Arduino UNO  1  

Obs.: Utilizar também Cabos de ligação (mínimo 28 cabos).

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da força enquanto você monta o circuito. Veja a simulação do projeto no link (utilizando leds no lugar do bargraph) --> Projeto 12a - simulação online.

Atenção:

1) A montagem abaixo foi realizada em um protoboard com linhas de alimentação contínuas. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas - saiba mais em protoboard

2) Cuidado para não ligar o sensor de temperatura invertido. Ele deve ficar com a face reta virada para frente, conforme a imagem acima, e a face arredondada virada para trás.

3) A barra gráfica (bargraph) possui polaridade. O lado com chanfro recebe ligação positiva.

4) O buzzer também tem polaridade: se retirar o adesivo superior do buzzer poderá ver um sinal de positivo (+). Este sinal mostra onde está o pino positivo do componente. 

5) Se você não tiver uma barra gráfica (bargraph) substitua este componente por leds, como mostramos na simulação: Projeto 12a - Termômetro com leds e sensor de temperatura.

Código do Projeto

Digite o código abaixo no ambiente de desenvolvimento do Arduino. Faça a verificação e o upload.

Observação: Se necessário, ajustes as temperaturas de controle do alarme (32ºC) e dos leds.

/*******************************************************************************
*
*    Projeto 12 – Termômetro com barra gráfica ou leds e sensor de temperatura com alarme
*
*******************************************************************************/

const int LM35 = 1;
float temperatura = 0;
int ADClido = 0;
const int Buzzer = 2;
const int LED[] = {
4,5,6,7,8,9,10,11,12,13};

void setup(){
analogReference(INTERNAL); //No Mega, use INTERNAL1V1, no Leonardo remova essa linha
pinMode(Buzzer, OUTPUT);
for(int x = 0; x < 10; x++){
pinMode(LED[x], OUTPUT);
}
}
void loop(){
ADClido = analogRead(LM35);
temperatura = ADClido * 0.1075268817204301; //no Leonardo use 0.4887585532
if(temperatura > 23.50){
digitalWrite(LED[0], HIGH);
}
else{
digitalWrite(LED[0], LOW);
}
if(temperatura > 24.00){
digitalWrite(LED[1], HIGH);
}
else{
digitalWrite(LED[1], LOW);
}
if(temperatura > 24.50){
digitalWrite(LED[2], HIGH);
}
else{
digitalWrite(LED[2], LOW);
}
if(temperatura > 25.00){
digitalWrite(LED[3], HIGH);
}
else{
digitalWrite(LED[3], LOW);
}
if(temperatura > 25.50){
digitalWrite(LED[4], HIGH);
}
else{
digitalWrite(LED[4], LOW);
}
if(temperatura > 26.00){
digitalWrite(LED[5], HIGH);
}
else{
digitalWrite(LED[5], LOW);
}
  
if(temperatura > 26.50){
digitalWrite(LED[6], HIGH);
}
else{
digitalWrite(LED[6], LOW);
}
if(temperatura > 27.00){
digitalWrite(LED[7], HIGH);
}
else{
digitalWrite(LED[7], LOW);
}
if(temperatura > 27.50){
digitalWrite(LED[8], HIGH);
}
else{
digitalWrite(LED[8], LOW);
}
if(temperatura > 32.00){
digitalWrite(LED[9], HIGH);
digitalWrite(Buzzer,HIGH);
}
else{
digitalWrite(LED[9], LOW);
digitalWrite(Buzzer,LOW);
}
}

Vídeo

Como o projeto deve funcionar

1. Ao rodar o programa, o software irá a medir a temperatura ambiente onde está localizado o sensor de temperatura LM35.

2. Para verificarmos o funcionamento do alarme, precisamos aumentar a temperatura. Para isso, encoste o dedo no sensor. Observe na barra gráfica que a temperatura começa a aumentar imediatamente, acendendo os leds da esquerda para a direita. Para acionar o alarme a temperatura deverá estar acima do valor de controle, que no nosso caso é 32ºC.

3. Quando a temperatura do sensor ultrapassar o valor de controle, o buzzer é acionado.

4. Tire o dedo do sensor, e quando a temperatura voltar a ficar abaixo do valor de controle, o buzeer é desligado imediatamente. Observe na barra gráfica que a temperatura começa a diminuir, apagando os leds da direita para a esquerda.

Ajustar os valores de controle conforme a temperatura ambiente

Se você está em um lugar mais quente ou mais frio, ajuste a temperatura de controle para que possa testar o alarme corretamente. Também pode ser necessário ajustar  as temperaturas de controle dos leds da barra gráfica para que a faixa de temperatura seja visualizada.

Dica: Utilize o Monitor Serial  para fazer a leitura da temperatura ambiente e ajustar corretamente os valores de controle:

a) Acrescente o comando Serial.begin(9600) logo após a estrutura void setup(){

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

b) Acrescente os comandos Serial.println(temperatura) e delay(1000) para fazer a leitura a cada segundo.

void loop(){
ADClido = analogRead(LM35);
temperatura = ADClido * 0.1075268817204301; //no Leonardo use 0.4887585532
Serial.println(temperatura);
delay(1000);

c) Para visualizar a leitura das temperaturas, clique no ícone monitor serial, como mostra a figura abaixo:

d) Observe que o sensor LM35 faz a leitura da temperatura ambiente, que no nosso exemplo estava em torno de 28ºC.

e) Faça os ajustes necessários no código e verifique-o fazendo novas leituras. Não esqueça que após alterar o código é necessário carregar novamente o Arduino.

f) Após concluído os ajustes, e exclua as linhas acrescentadas para a leitura no monitor serial. (Em projetos de automação é necessário que o alarme funcione da forma mais rápida possível, ou seja, o alarme deve ser acionado no momento exato que a temperatura atingir o valor de controle)

Explicando o Código do Projeto (sem delay e leitura)

1. Primeiro declaramos as constantes (LM35, Buzzer e Led[ ]) e as variáveis (temperatura  e ADClido).

const int LM35 = 1;
float temperatura = 0;
int ADClido = 0;
const int Buzzer = 2;
const int LED[] = {
4,5,6,7,8,9,10,11,12,13};

1.1. Observe que utilizamos a variável tipo "float" (ponto flutuante) para temperatura. Esta variável, no nosso exemplo, começa valendo zero e tem uma precisão de duas casas decimais. Veja na tabela abaixo as diferenças nos tipos de constantes e variáveis mais comuns:

 Tipo   Valores Válidos para Variáveis e Constantes
char letras e símbolos:   'a',  'b', 'H', '^', '*','1','0'
int de -32767 até 32767 (apenas números inteiros)
float de -3.4 x 1038 até +3.4 x 10+38com até 6 dígitos de precisão
double de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de precisão

1.2. A constante LM35 se refere ao sensor de temperatura LM35 que deverá estar conectado no pino analógico A1. A constante Buzzer se refere ao componente buzzer 5V que deverá estar conectado no pino digital 2.

1.3. A variável ADClido irá armazenar o valor lido diretamente pelo pino analógico depois da conversão feita pelo ADC (Analog to Digital Converter - conversor analógico para digital), sem tratamento nenhum. É do tipo inteiro pois este valor vai de 0 a 1023. A variável ADClido começa valendo zero. 

1.4. A constante Led[ ] se refere à uma Array. Isto significa que no nosso exemplo, a constante LED será declarada com valores de 4 a 13, ou seja, os LEDs da Barra Gráfica deverão estar conectados do pino digital 4 até ao pino digital 13 sucessivamente, como mostra o esquema de montagem do circuito acima. Uma barra gráfica (bargraph) nada mais é do que uma barra de leds que acendem conforme algum parâmetro.

2. Através do comando void setup(), definimos:

void setup(){
analogReference(INTERNAL); //No Mega, use INTERNAL1V1, no Leonardo remova essa linha
pinMode(Buzzer, OUTPUT);
for(int x = 0; x < 10; x++){
pinMode(LED[x], OUTPUT);
}

 2.1. Comando analogReference(INTERNAL): Resulta em um intervalo maior de valores no ADC (Analog to Digital Converter, conversor analógico para digital) do Arduino. Desta forma, altera-se a tensão máxima que pode entrar nas portas analógicas do Arduino de 5V para 1,1V. Portanto, se a tensão máxima de leitura ficar definida como 1,1V, poderemos calibrar o nosso sensor para ler no máximo 110ºC, ou seja, 1100mV (sabemos que o incremento é de 10mV/ºC, conforme informações do fabricante do sensor que utilizamos - veja em observação na tabela de componentes).

Observação: Utilize INTERNAL para Arduino UNO, INTERNAL1 para Ardino Mega. Não utilize o comando analogReference() para o Arduino Leonardo.

2.2. O Buzzer foi definido como conectado na saída do controlador Arduino (OUTPUT).

2.3.  Através a estrutura for loop, de o a 9 (10 repetições), definimos os índices da constante array LED, sendo: LED[0] até LED[9] conectados na saída (OUTPUT) do controlador. Portanto no nosso exemplo, a constante LED[0] ficará definida como saída do pino digital 4, LED[1] como saída do pino digital 5, e sucessivamente até LED[9] definido como saída do pino digital 13.

3. Através do loop void loop(), obtemos:

void loop(){
ADClido = analogRead(LM35);
temperatura = ADClido * 0.1075268817204301; //no Leonardo use 0.4887585532
if(temperatura > 23.50){
digitalWrite(LED[0], HIGH);
}
else{
digitalWrite(LED[0], LOW);
}

3.1. Valores lidos diretamente pelo pino analógico através da variável ADClido realizado pela função analogRead(). Esta leitura é feita pelo ADC (Analog to Digital Converter). A variável foi definida como tipo inteiro, vai de 0 a 1023, ou seja, 210 = 1024 valores inteiros (referente à resolução de 10 bits do ADC para controladores Arduino UNO, Mega e Leonardo).

3.2. Valores da variável temperatura calculados por ADClido * índice de conversão. Como 110º C a(valor máximo para 1,1V na porta analógica) equivale a 1023 (valor máximo de leitura do ADClido), pela regra de três, o valor da variável temperatura será igual a ADClido * (110/1023). Portanto,  temperatura = ADClido * 0.1075268817204301.

Observação: Para Arduino Leonardo, utilize o valor 0.4887585532 como índice de conversão. Como a variável temperatura é uma variável tipo float, podemos visualizar este valor no monitor serial com 2 casas decimais. Para entender melhor como funciona o Sensor de temperatura LM35, clique em Sensor de Temperatura LM35.

3.3. A estrutura condicional IF verifica se o valor da variável temperatura é maior que 23.50ºC (utilizado no nosso exemplo). Se sim, o controlador indicará que o LED[0] da barra gráfica, conectado no pino 4 do Arduino, ACENDERÁ através do comando digitalWrite(LED[0],HIGH). Isto é verificado em todas os leds da barra gráfica, acendendo-os quando o valor da temperatura lido for maior que os valores de controle.

3.4 Quando o valor da variável temperatura for maior a 32ºC, o buzzer e todos os leds da barra gráfica são acionados. Caso contrário o buzzer e o LED[9] são desligados através do comandos digitalWrite(Buzzer,LOW); e digitalWrite(LED[9], LOW);.

if(temperatura > 32.00){
digitalWrite(LED[9], HIGH);
digitalWrite(Buzzer,HIGH);
}
else{
digitalWrite(LED[9], LOW);
digitalWrite(Buzzer,LOW);
}

 

Você está preparado?

JSN Epic template designed by JoomlaShine.com