Início / Projetos Arduino / Projetos Squids / Básico / Projeto 43 - Biblioteca para sensor de temperatura LM35

---

Projeto 43 - Biblioteca para sensor de temperatura LM35

Angelo Luis Ferreira | 06/08/2018 Acessos: 7.427

Objetivo

Neste projeto vamos apresentar uma biblioteca para o sensor de temperatura LM35, facilitando sua utilização. Com esta biblioteca não será preciso fazer cálculos para obter a temperatura ambiente através de uma simples leitura ou através da média de várias leituras. Os valores lidos serão mostrados em um display de LCD 16 X 2. Também neste projeto vamos adicionar um botão (push button) que quando acionado alterna a exibição de Celsius para Fahrenheit e Kelvin

Obs. 1: Esta biblioteca não utiliza o recurso de programação analogReference(INTERNAL) que altera a tensão de referência das portas analógicas do Arduino de 5V para 1,1V (ver Projeto 39 - Display LCD como mostrador de temperatura).

Obs. 2: Utilizar o sensor dessa maneira resulta em uma precisão um pouco menor em comparação ao uso da mudança da referência analógica.

Obs. 3: Parantir maior precisão e suavizar variações abruptas você pode optar por estabelecer médias de várias leituras para cada valor exibido no display. A biblioteca para o sensor de temperatura LM35 permite este recurso como veremos no projeto a seguir.

Aplicação

Para fins didáticos e projetos com sensores de temperatura e display de cristal líquido.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 830 pontos
Jumpers	Kit cabos ligação macho / macho	1
Display LCD	Display LCD 16X2 com pinos soldados	1		LCD que utilize o controlador HD44780 (veja na descrição ou datasheet do componente) O display poderá ser de qualquer cor (fundo verde, azul ou vermelho)
Potenciômetro	Potenciômetro 1OK	1		O valor do potenciômetro aumenta quando giramos o eixo do componente na direção do polo negativo para o polo positivo. Obs.: Se não possuir potenciômetro de 10KΩ você poderá utilizar um de outro valor, de 1kΩ até 100kΩ.
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. datasheet
Push Button	Push button 6X6X5mm	1
Arduino UNO R3	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

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.

Atenção

1. Neste projeto vamos utilizar um display LCD 16x2 com controlador HD44780, que se adapta aos mais diversos projetos com vários modelos de placas e microcontroladores. Este display possui 16 colunas por 2 linhas com backlight (luz de fundo) verde, azul ou vermelha e tem 16 pinos para a conexão. Atenção: Utilize um display LCD com os pinos soldados.

2. Preste muita atenção na montagem do dsiplay LCD. Observe que utilizamos os 6 primeiros pinos do LCD, pulamos os 4 próximos e então utilizamos mais 6 pinos. Veja a tabela abaixo:

3. Cuidado para não ligar o sensor de temperatura invertido. Ele deve ficar com a face reta virada para frente, conforme a imagem abaixo, e a face arredondada virada para trás, de forma que o positivo fique ao lado esquerdo do sensor e o negativo ao lado esquerdo do sensor.

4. Monte o botão (push button) sem o resistor, pois através da programação vamos habilitar o resistor pull-up interno do arduino. Desta forma, quando o botão estiver pressionado, o Arduino retornará "LOW" ou "0". Assista o vídeo Arduino: Botão e Resistor de Pull Up Interno

5. Observe que nesse projeto o potenciômetro foi montado como um divisor de tensão, onde utilizamos os 3 terminais do componente:

Obs.: Ao girar o eixo do potenciômetro, o valor da tensão deverá aumentar do negativo para o positivo, ou seja, se a tensão do circuito for 5V, o potenciômetro irá variar de 0 a 5V.

5.1. No nosso exemplo, girando-se o eixo do potenciômetro no sentido horário, aumentamos a tensão na entrada do pino 3 do display e diminuímos o contraste dos caracteres com o back light (luz de fundo) até que não é mais possível visualizá-los. Fazendo o contrário, ou seja, diminuindo a tensão até o zero, teremos um contraste máximo entre os caracteres e a luz de fundo.

6. A montagem do nosso projeto foi realizada em um protoboard com linhas de alimentação não contínuas, onde acrescentamos jampers para a ligação. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas.

Incluindo bibliotecas no IDE do Arduino

Neste projeto vamos mostrar como adicionar uma biblioteca no IDE do Arduino. Uma das grandes vantagens das placas Arduino é a diversidade de bibliotecas disponíveis que podem ser utilizadas em seus programas. Estas bibliotecas podem ser criadas para a linguagem "C" ou especificamente para o Arduino, reduzindo drasticamente o tempo gasto com programação. Veja a tabela Coletânea de bibliotecas para sensores.

Download dos arquivos da biblioteca do LM35

DOWNLOAD - LM35.zip

Para saber detalhes desta biblioteca clique aqui.

Instalando a biblioteca pelo IDE do Arduino

Após fazer o download do arquivo LM35.zip com todos os arquivos da biblioteca compactados no formato zip, abra o IDE do Arduino e siga o tutorial: Como incluir uma biblioteca no IDE do Arduino.

Ligando o display LCD

Para visualizar o display funcionando, digite o código abaixo no ambiente de desenvolvimento IDE do Arduino. Faça a verificação e o upload:

/*******************************************************************************
*
*          Testando o Display LC 16 X 2
*            http://squids.com.br/arduino
*
*******************************************************************************/
//Carrega a biblioteca LiquidCrystal
#include <LiquidCrystal.h>

//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
//Define LCD 16 colunas por 2 linhas
lcd.begin(16, 2);

//Posiciona o cursor na coluna 0, linha 0;
lcd.setCursor(0,0);
//Envia o texto entre aspas para o LCD
lcd.print("Ola, meu nome e:");

//Posiciona o cursor na coluna 1, linha 1;
lcd.setCursor(1,1);
//Envia o texto entre aspas para o LCD
lcd.print("Squids Arduino");
}

void loop() {

}

ATENÇÃO: Se o display acender e não mostrar os caracteres provavelmente é em função do contraste. Gire o eixo do potenciômetro no sentido anti-horário para aumentar o contraste. Se mesmo assim o display não mostrar os caracteres, corrija a montagem do circuito e/ou o código.

Comandos do display LCD para a biblioteca LiquidCrystal

No projeto vamos utilizar alguns comandos de controle do display LCD através da biblioteca LiquidCrystal que já vem embutida na IDE do Arduino. Para conhecer todos os comandos desta biblioteca, acesse o link: Comandos display LCD para biblioteca LiquidCrystal e LiquidCrystal Library (Arduino Reference).

Obs.: Para acessarmos uma biblioteca embutida na IDE do arduino, assim como, para acessarmos um biblioteca local através de um header file, utilizaremos a diretiva #include.

Código do Projeto (Sketch)

1) Faça o dowload e abra o arquivo projeto43.ino no IDE do Arduino:  DOWNLOAD - projeto43.ino

Ou se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    Projeto 43 - Biblioteca para sensor de temperatura LM35
*                       http://squids.com.br/arduino
*
*******************************************************************************/
//Carrega as bibliotecas lm34 e LiquidCrystal
#include <lm35.h>
#include <LiquidCrystal.h>

//Objeto lmt da biblioteca lm35.h
lmt sensor(A0); //LM35 conectado na porta A0 do Arduino

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int buttonPin = 8;
int seletor = 2;
uint32_t timer = 0;
float temperature[] = {1,2,3};
int x = 1; String t = "C";

void setup() {
pinMode(buttonPin, INPUT_PULLUP);

Serial.begin(9600);
lcd.begin(16, 2);

//primeira leitura
temperature[x] = sensor.tCelsius(); // leitura em ºC
temperature[2] = sensor.tFahrenheit(); // leitura em ºF
temperature[3] = sensor.tKelvin();// leitura em ºK
}

void loop() {

//mostra temperaturas a cada segundo
if(millis() - timer>= 1000) {  
  temperature[1] = sensor.tCelsius(); // leitura em ºC
  temperature[2] = sensor.tFahrenheit(); // leitura em ºF
  temperature[3] = sensor.tKelvin();// leitura em ºK
  timer = millis(); // Atualiza a referência
}
imprimir();

//verifica se o botão foi acionado
if (!digitalRead(buttonPin)) {
      // Espera soltar o botão seletor
      while (!digitalRead(buttonPin)) {  }           
      delay(10); // 
    switch (seletor) {
    case 1:
      x=1, t="C";
      seletor++;
      break;
    case 2:
      x=2, t="F";
      seletor++;
      break;
    case 3:
      x=3, t="K";
      seletor=1;
      break;  
  }
 }
}
 
void imprimir() {
//Imprimindo no monitor serial
Serial.print("T. Celsius: ");
Serial.print(temperature[1]);
Serial.print("°C | ");
Serial.print("T. Fahrenheit: ");
Serial.print(temperature[2]);
Serial.print("°F | ");
Serial.print("T. Kelvin: ");
Serial.print(temperature[3]);
Serial.println("°K");

//imprimindo no display LCD
lcd.clear();
lcd.setCursor(0,0); // Define o cursor na posição de início
if (x==1) {lcd.print("C = ");}
else if (x==2) {lcd.print("F = ");}
else {lcd.print("K = ");}
lcd.print(temperature[x]);
lcd.write(B11011111); // Imprime o símbolo de grau
//lcd.print((char)223); Também imprime o símbolo de grau
lcd.print(t);
lcd.setCursor(1,1); // Define o cursor na posição de início
lcd.print("Squids Arduino");
} 

Como usar o recurso de cálculo da média de várias leituras para cada valor exibido no display

Para garantir maior precisão e suavizar variações abruptas na visualização, podemos estabelecer uma média de várias leituras para cada valor exibido no display. Isto pode ser realizado pela biblioteca LM35, como é demonstrada no link: Média de várias leituras.

Por exemplo, no nosso projeto queremos obter maior precisão da temperatura lida fazendo a média de 50 leituras para cada valor exibido no display. Para isto, basta fazer a seguinte alteração no projeto:

temperature[1] = sensor.tCelsius(50); // leitura em ºC
temperature[2] = sensor.tFahrenheit(50); // leitura em ºF
temperature[3] = sensor.tKelvin(50);// leitura em ºK

Observe que apenas colocamos o valor de leituras que desejamos, no caso 50, no método de obtenção de dados da biblioteca LM35. Desta forma, podemos utilizar este recurso para obtermos a o valor médio da temperatura para cada valor exibido em Celcius, Fahrenheit ou Kelvin.

Vídeo

Como o projeto deve funcionar

1. Ao executar o programa, a temperatura atual em Celsius será exibida na linha de cima do LCD.

2. Ao pressionar e soltar o botão (push button), será alterada a escala de temperatura de Celsius para Ferenheit.

3. Ao pressionar e soltar novamente o botão, a escala de temperatura passa para Kelvin, e assim sucessivamente.

4. Para visualizar a leitura das temperaturas registradas, clique no ícone monitor serial, como mostra a figura abaixo:

Explicando o código do projeto

1. Primeiro definimos e declaramos as bibliotecas, constantes e variáveis globais do projeto.

1.1. Através do comando #include incluímos as bibliotecas lm35.h e LiquidCrystal.h para serem compiladas junto ao sketch (não utilize ponto e vírgula no final de uma diretiva #include).

1.1.1. A diretiva #include é utilizada para incluir bibliotecas externas em um sketch. Isso dá ao programador acesso a um grande grupo de bibliotecas C padrão (grupos de funções pré definidas) e também bibliotecas específicas para o Arduino.

1.1.2. Como já mencionamos anteriormente, o arquivo da biblioteca lm35.h deve ser inserido no IDE do Arduino. Se tiver dúvidas leia o artigo Como incluir uma biblioteca no IDE do Arduino.

1.1.3. A biblioteca LiquidCrystal.h já vem incluída no IDE do Arduino e contém todos os comandos e recursos para controlar um display LCD.

1.2. O comando lmt sensor(A0) instancia o objeto definido pela classe lm inserida na biblioteca lmt35.h como conectado na porta analógica A0 do Arduino. Isto irá possibilitar a utilização dos métodos (funções) da biblioteca que serão usados no programa.

1.3. Através da instrução LiquidCrystal lcd(12, 11, 5, 4, 3, 2); a biblioteca do LCD faz com que o programa do Arduino saiba que ao dar o comando LiquidCrystal lcd iremos utilizar um display, e faremos a comunicação utilizando os seguintes pinos do Arduino: 12, 11, 5, 4, 3, conforme mostra a tabela abaixo:

1.4. Observe que utilizamos constantes e variáveis int, uint32_t e float. Veja na tabela abaixo as diferenças nos tipos de constantes e variáveis:

1.6. Definimos a constante buttonPin tipo int que recebe o valor 8. Isto significa que o pino do push button deverá estar conectado à porta digital 8 do Arduino.

1.7. A variável seletor tipo int recebe o valor 2. A variável seletor é responsável por indicar a escala de temperatura que será exibida no display de LCD.

1.8. A variável tipo uint32_t  timer recebe o valor zero.

1.9. Definimos o objeto array temperature tipo float com os valores 1, 2 e 3. Estes valores irão definir a escala de temperatura lida, ou seja, Celsius, Fahrenheit ou Kelvin.

1.10. Finalmente definimos as variáveis int x igual a 1 e a String t como "C".

Obs.: Sting é um tipo de dados que define uma sequência de caracteres - Leia mais em String() - Referência Arduino.

2. Através da estrutura void setup(), definimos:

 2.1. A função pinMode() define a porta digital referente à variável buttonPin, conexão do push button (botão), configurada como INPUT_PULLUP.

2.1.1. INPUT_PULLUP habilita o resistor pull-up interno do Arduino, eliminando a necessidade de colocarmos um resistor de 10K ligado ao VCC (5V).

Obs.: Os resistores pull-up e pull-down garantem um nível lógico estável quando, por exemplo, uma tecla não está pressionada. Geralmente utiliza-se um resistor de 10KΩ para esse propósito. A seguir é exibida a ligação desses resistores no circuito para leitura de tecla do botão:

2.2. A função Serial.begin() serve para dizer ao Arduino que será coletado dados para o computador a partir da porta serial e o cabo USB. O número entre os parênteses significa qual é a taxa de dados que a placa vai se comunicar com o computador. Utilizaremos a taxa padrão de 9600bps (bits-per-second).

2.3. Através da instrução lcd.begin(16,2); a biblioteca do LCD informa ao Arduino que será utilizado um display com 16 colunas e 2 linhas.

2.4. Através do array temperature[] e métodos da biblioteca lm35 definimos as leituras iniciais, como sendo:

2.4.1. temperature[1], pois x =1. armazena a temperatura ambiente em º Celsius, através do método sensor.tCelsius().

2.4.2. temperature[2] armazena a temperatura ambiente em º Fahrenheit, através do método sensor.tFahrenheit().

2.4.1. temperature[3] armazena a temperatura ambiente em º Kelvin, através do método sensor.tKelvin().

3. Através da estrutura void loop() , definimos:

3.1.  A expressão condicional if(millis() - timer >=1000) determina que os comandos inseridos nela sejam executados a cada segundo (1.000ms) , sendo que:

3.1.1. A função millis() retorna o número de milissegundos passados desde que a placa Arduino começou a executar o programa atual. Esse número irá sofrer overflow (chegar ao maior número possível e então voltar pra zero), após aproximadamente 50 dias.

3.1.2. A variável timer  tipo uint32_t, recebe inicialmente o valor zero (linha 17 do sketch).

3.1.3. Quando a diferença entre a função millis() e zero (valor inicial de timer) for maior que 1.000, a expressão condicional será verdadeira e todos comandos inerentes a ela serão executados. Isto significa que o programa roda durante 1 segundo sem executar os comandos definidos pela expressão if(millis() - timer >= 1000;  fazendo com que estes comandos somente sejam executados a cada segundo.

Obs.: É importante salientar que a utilização da função millis() como condicional é diferente de utilizamos a função pause() que paralisa totalmente o programa por um determinado período. Leia mais: função millis() e Como usar temporizadores no Arduino.

3.2. Caso a expressão condicional if(millis() - timer >= 1000) seja atendida, os seguintes comandos são realizados:

3.2.1. A variável temperature[1] recebe o valor lido pelo sensor LM35 em ºC (Celsius) através da método sensor.tCelsius() que faz parte da biblioteca lm35.h.

3.2.2. A variável temperature[2] recebe o valor lido pelo sensor LM35 em ºF (Fahrenheit) através da método sensor.tFahrenheit() que faz parte da biblioteca lm35.h.

3.2.3. A variável temperature[3] recebe o valor lido pelo sensor LM35 em ºK (Kelvin) através da método sensor.tKelvin() que faz parte da biblioteca lm35.h.

3.3. Após atualizar as temperaturas, acionamos a função imprimir() para exibir os valores no display LCD e/ou no monitor serial.

3.4. A próxima rotina muda a posição do seletor a cada vez que o botão é pressionado, sendo:

3.5. Se o botão for pressionado: if(!digitalRead(buttonPin), temos:

Obs.: A expressão !digitalRead(buttonPin), lê o estado do botão e verifica se ele está configurado com LOW. Lembre-se que a montagem do botão foi realizada com resistor pull-up. Leia:  Como usar push button com Arduino (programação).

3.5.1. Criamos um loop infinito para que o programa aguarde o usuário soltar o botão, através do comando while (!digitalRead(buttonPin) { }. Isto é necessário para que o seletor seja alterado somente quando o botão for liberado. Leia: Projeto 04a - Push Button como interruptor - liga e desliga (padrão para pull-down ou pull-up)

3.5.2. Através da função delay(10) geramos uma pausa de 10ms no programa para evitarmos que ocorra qualquer interferência no sinal digital após liberarmos o botão.

3.5.3. Usamos agora o comando "switch...case" para controlarmos a seleção de qual sensor de temperatura queremos mostrar no display LCD.  Leia mais sobre o comando witch...case - Referência Arduino.

3.5.3.1. O comando switch(seletor) recebe o valor da variável seletor. Inicialmente o valor da variável seletor é 2. Portanto, ao clicarmos o botão pela primeira vez, o valor de x também será 2 e visualizaremos no display a temperatura lida em Fahrenheit no sensor LM35 , de acordo com a função imprimir() que veremos mais abaixo.

3.5.3.2. Por sua vez, a variável seletor passa a receber o valor 3, através do comando seletor++. Assim, na próxima vez que clicarmos o botão, o valor de x será 3 e visualizaremos a temperatura lida em Kelvin obtida pelo sensor LM35.

3.5.3.3. A palavra-chave break interrompe o comando switch, e é tipicamente usada no final de cada case. Sem um comando break, o comando  switch irá continuar a executar as expressões seguintes (desnecessariamente) até encontrar um break, ou até o final do comando switch ser alcançado. - trecho obtido do artigo witch...case - Referência Arduino.

3.5.3.4. Finalmente, ao clicarmos de novo o botão visualizaremos a temperatura lida no termistor novamente.

4. Através da imprimir(), definimos:

4.1. No monitor serial do IDE do Arduino, através das funções Serial.print() e Serial.println(), exibiremos os valores lindos no sensor LM35 em Celsius, Fahrenheit ou Kelvin, sendo:

4.1.1. O comando println diferentemente do comando print diz ao monitor serial que se deve pular uma linha após escrever o valor definido entre parêntesis.

4.1.2. Veja abaixo como devem aparecer as temperaturas no monitor serial:

4.2. Para imprimir no display LCD, defina os comandos a seguir:

Obs.: Para saber mais detalhes da biblioteca LiquidCrystal, leia: Biblioteca LiquidCrystal - Comandos display LCD

4.2.1. O método lcd.clear() limpa o display e posiciona o cursor no canto superior esquerdo do display.

4.2.2. Através do comando lcd.setCursor(0,0) definimos a posição do cursor no primeiro caractere da primeira linha do display.

4.2.3. De acordo com a condicional if / else, visualizaremos:

4.2.3.1. Se x = 1, será exibido no display LCD o texto "C = ", através do comando lcd.print().

4.2.3.1. Se x = 2, será exibido no display LCD o texto "F = ", através do comando lcd.print().

4.2.3.1. Se x = 1, será exibido no display LCD o texto "K = ", através do comando lcd.print().

4.2.4. Através do método lcd.print(termperture[x]) e dependendo do valor de x, podemos visualizar as temperaturas lidas no sensor LM35 em Celsius, Fahrenheit ou Kelvin. O array temperature[] foi definido anteriormente na estrutura loop void.

4.2.5 Através do comando lcd.write(B11011111) é exibida o símbolo de grau (º):

4.2.5.1. Diferentemente de lcd.print(), que imprime uma string no display, a função lcd.write() imprime um caractere.

4.2.5.2. Utilizamos um valor binário para definir o nosso caractere (11011111). Em C++, precisamos utilizar o prefixo "B" antes de um número binário, por isso lcd.write(B11011111) . Veja a tabela abaixo:

Obs1.: Leia a referência para usos de constantes com base binário, octal ou hexadecimal  - Constantes Inteiras

Obs2: Se você converter o valor binário 11011111 para decimal e hexadecimal encontrará os valores 223 (decimal) e DF (hexadecimal). Assim, você poderia escrever lcd.write(B11011111) como lcd.write(223) ou lcd.write(0xDF) que o símbolo de grau seria exibido de qualquer forma. Teste: Teste as conversões na Calculadora para Converter número Decimal para Binário, Octal e Hexadecimal.

4.2.5.2. O valor do caractere utilizado foi obtido na tabela de caracteres Tabela de caracteres para display LCD. Usamos o prefixo 1101 (linha horizontal) com o final xxxx1111 (linha vertical) e obtemos o valor binário 11011111. (Nota do Autor: Lembre-se, um caractere tem 1byte, ou seja, 8 bits).

4.2.6. Através do comando lcd.print(t) exibimos os valores de t, sendo C, F ou K.

4.2.7. Através do comando lcd.setCursor(1,1) definimos a nova posição do cursor no segundo caractere da segunda linha do display.

2.2.8. Finalmente, é exibida no display LCD a frase "Squids Arduino" através da função lcd.print("squids Arduino").

Desafios

Com base neste projeto, resolva o seguinte desafio:  Desafio 25

Comentários