Início / Projetos Arduino / Projetos Squids / Básico / Projeto 42 - Comparando sensores de temperatura NTC 10K, DHT11 e LM35

---

Projeto 42 - Comparando sensores de temperatura NTC 10K, DHT11 e LM35

Angelo Luis Ferreira | 16/07/2018 Acessos: 9.520

Objetivo

Neste projeto vamos comparar temperaturas ambiente lidas através de 3 sensores diferentes: Termistor NTC 10K, DHT11 e LM35, onde:

Termistor NTC (coeficiente negativo de temperatura) é um resistor sensível a temperatura. Sua resistência elétrica diminui à medida que a temperatura aumenta. Um termistor NTC de 10K significa que na temperatura de 25ºC sua resistência elétrica é de 10.000Ω (10KΩ). Neste projeto utilizaremos a biblioteca Thermistor.zip que calcula diretamente os valores lidos no sensor transformando-os em valores reais através do método Método Steinhart-Hart.

Veja a baixo a curva típica de um termistor NTC 10K:

DHT11 é um sensor básico de baixo custo utilizado para a medição de temperatura e umidade do ar ambiente através de um termistor e um sensor capacitivo. Existem várias versões diferentes do DHT11 com a mesma aparência e número de pinos. Portanto é importante verificar o "datasheet" do componente para obter suas características principais. Neste projeto utilizaremos a biblioteca DHTlib.zip que calcula diretamente os valores lidos no sensor transformando-os em valores reais.

Sensor LM35 é um circuito integrado que atua como sensor de precisão, no qual apresenta uma tensão de saída proporcional e linear à temperatura em que ele se encontrar no momento, tendo em sua saída um sinal de 10mV para cada Grau Célsius de temperatura.

ATENÇÃO: Como utilizaremos outros componentes com leitura analógica, não poderemos utilizar neste projeto 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. A diferença de se usar o sensor desta forma é que ele não fica tão preciso quanto ficaria se usássemos a mudança da referência analógica.

Para conhecer melhor cada sensor, acesse os projetos: Projeto 41 - Usando o sensor de temperatura termistor NTC 10K com LCD, Projeto 40 - Sensor de temperatura e umidade DHT11 com display LCD e Projeto 09 - Sensor de temperatura LM35.

Aplicação

Para fins didáticos e projetos onde é necessária a medição e monitoramento de temperaturas do ambiente.

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Ω.
Push Button	Push button 6X6X5mm	1
Sensor de Temperatura - Termistor NTC 10K	Sensor de Temperatura Termistor NTC 10K	1		Características do termistor NTC 10K: Modelo: MF521033950 (NTC 10K) Tipo: 103 (resistência elétrica de 10KΩ a 25ºC) Faixa temperatura: -55ºC ~ 125ºC Dissipação: > 2.0mw/ºC Valor de Beta: 3.950K (+/- 2%) dimensão: 3mm ou 5mm datasheet
Resistor	Resistor de 10KΩ	1		1 Resistor de 10KΩ (sensor NTC 10K)
Sensor de Temperatura e Umidade DHT11	Sensor de Temperatura Termistor NTC 10K			Características do DHT11 utilizado neste exemplo: Tensão de alimentação: 3V a 5V Umidade relativa: 20% a 90% (precisão de 5%) Temperatura: 0 a 50 ºC (precisão de 2%) Intervalo entre medições: mínimo 2s Corrente de utilização: 2,5mA datasheet
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
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 6pinos. Veja a tabela abaixo:

3. Monte o thermistor NTC como um divisor de tensão de acordo com o esquema abaixo:

3.1. O sensor NTC varia sua resistência inversamente a temperatura ambiente, ou seja, quando a temperatura aumenta, a resistência diminui. Como pretendemos obter um circuito que forneça tensões mais altas quando aumentamos a temperatura, precisaremos criar um divisor de tensão com o termistor NTC na posição mostrada no esquema acima, ou seja, um terminal conectado ao positivo e o outro no nó entre a saída analógica do Arduino e o resistor de 10KΩ. Para saber mais sobre divisão de , leia Usando um termistor NTC ou NTC como parte de um divisor de tensão.

Atenção.: Se você inverter o circuito acima, o comportamento das leituras será também invertido, ou seja, o circuito irá fornecer tensões mais baixas quando aumentarmos a temperatura. Assim, quando utilizarmos o método Steinhart-Hart para calcularmos a temperatura real, os valores não serão corretos.

3.2. Veja a montagem do circuito no protoboard:

3.3. O sensor de temperatura termistor NTC 10K, assim como um resistor comum, não tem polaridade.

4. Cuidado para não ligar o sensor de temperatura invertido. Ele deve ficar com a face reta virada para frente e conectado da seguinte forma:

4.1 Veja como deve ser a montagem no Arduino:

5. 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 direito do sensor.

6. Veja a montagem dos sensores do nosso exemplo:

7. 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.

8. 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.

8.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.

9.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 é necessário ter adicionado no IDE do Arduino as seguintes bibliotecas:  Thermistor.zip e DHTlib.zip

Se você ainda não instalou estas bibliotecas, siga o nosso tutorial: Como incluir uma biblioteca no IDE do Arduino.

Obs.: após fazer o download dos arquivos .zip, abra o IDE do Arduino e siga o tutorial acima.

Ligando o display LCD

1. 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.

Sketch do projeto

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

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

/*******************************************************************************
*
*    Projeto 42 - Comparando sensores de temperatura NTC 10K, DHT11 e LM35
*                       http://squids.com.br/arduino
*
*******************************************************************************/
#include <Thermistor.h>
#include <dht.h>
#include <LiquidCrystal.h>

Thermistor temp(2); // termistor conectado na porta A2 (cria o objeto)
dht DHT; // Cria um objeto da classe dht

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

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

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

Serial.begin(9600);
lcd.begin(16, 2);
//fazendo a primeira leitura
temperature[1] = temp.getTemp(); //calcula a temperatura do termistor
DHT.read11(A1); // sensor DHT11 conectado na porta A1
temperature[2] = DHT.temperature;
temperature[3]= (float(analogRead(A0))*5/(1023))/0.01;
seletor++;
}

void loop() {

if(millis() - timer>= 2000) {
   
   temperature[1] = temp.getTemp(); //calcula a temperatura do termistor
   DHT.read11(A1); // sensor DHT11 conectado na porta A1
   temperature[2] = DHT.temperature; 
   for (int i=0;i<1000;i++) {
   temperature[3]= temperature[3] + (float(analogRead(A0))*500/(1023));
   }
   temperature[3] = temperature[3] / 1000;
   timer = millis(); // Atualiza a referência
}

imprimir();

if (!digitalRead(buttonPin)) {
      // Espera soltar o botão seletor
      while (!digitalRead(buttonPin)) {  }           
      delay(10); // 
    switch (seletor) {
    case 1:
      x=1;
      seletor++;
      break;
    case 2:
      x=2;
      seletor++;
      break;
    case 3:
      x=3;
      seletor=1;
      break;  
  }
}
}
 
void imprimir() {
//Imprimindo no monitor serial
Serial.print("NTC10K: ");
Serial.print(temperature[1]);
Serial.print("°C | ");
Serial.print("DHT11: ");
Serial.print(temperature[2]);
Serial.print("°C | ");
Serial.print("LM35: ");
Serial.print(temperature[3]);
Serial.println("°C");

//imprimindo no LCD
lcd.clear();
lcd.setCursor(0,0); // Define o cursor na posição de início
if (x==1) {lcd.print("NTC = ");}
else if (x==2) {lcd.print("DHT = ");}
else {lcd.print("LM35 = ");}
lcd.print(temperature[x]);
lcd.write(B11011111); // Imprime o símbolo de grau
lcd.print("C");
} 

Vídeo

Como o projeto deve funcionar

1. Ao executar o programa, a temperatura atual em Celsius lida pelo Termistor NTC será exibida no display LCD.

2. Ao apertar e soltar o botão (push button) será lida a temperatura através do sensor DHT11.

3. Ao apertar e soltar novamente o botão, será lida a temperatura através do sensor LM35, e assim, sucessivamente, Termistor NTC, DHT11 e LM35.

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 Thermistor.h , dth.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, os arquivos da biblioteca Thermistor.h e dht.h devem ser inseridos 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 Thermistor temp(1) instancia o objeto definido pela classe temp inserida na biblioteca Thermistor.h como conectado na porta analógica A2. Isto irá possibilitar a utilização dos métodos (funções) da biblioteca para uso no programa.

1.3. O comando dht DHT cria o objeto DHT que que faz parte da biblioteca dth.h. Isto possibilita a utilização os métodos (funções) da classe DHT no sketch.

1.4. 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.5. 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. Definimos a variável seletor tipo int que recebe o valor 1. A variável seletor irá definir o tipo de sensor que queremos fazer a leitura da temperatura ambiente.

1.8. Definimos a variável timer tipo uint32_t que recebe o valor 0.

1.9. Definimos o array temperature tipo float que recebe os valores {1, 2, 3}.  O array definirá o tipo de leitura, sendo: temperature[1] - leitura do thermistor, temperature[2] - leitura do sensor DHT11 e temperature[3] - leitura do sensor de temperatura LM35.

1.10. Finalmente, definimos a variável x tipo int como 1.

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. A variável temperature[1] recebe o valor lido pelo termistor através da método temp.getTemp() que faz parte da biblioteca Thermistor.h.

2.5. Definimos através do método Dht.read11(A1) que o sensor de temperatura DHT11 deverá estar conectado à porta analógica A1.

2.6. A variável temperature[2] recebe o valor lido pelo sensor DHT11 através do método DHT.temperature que faz parte da biblioteca dht.h.

2.7. A variável temperature[3] recebe o valor tipo float lido pelo sensor de temperatura LM35 através da expressão (analogRead(A0)*5/1023)/0.01 que significa:

 2.7.1. A função analogRead(A0) faz a leitura real do sensor LM35 através da porta analógica A0 do Arduino. Esta leitura é realizada pelo ADC do Arduino (Analog to Digital Convert, ou, Conversor de Analógico para Digital) resultando em valores de 0 a 1023, ou seja, 2¹⁰ = 1024 valores inteiros (referente à resolução de 10 bits do ADC para controladores Arduino UNO, Mega e Leonardo). Portanto, se a tensão máxima for equivalente à 5V, teremos como leitura 1023 e a tensão mínima zero.

2.7.2. Em função da leitura do sinal na porta A0, que varia de 0 a 1023 (0V a 5V) e como sabemos que a cada aumento de 1ºC na temperatura ambiente o sensor LM35 aumenta 10mV (0,01V) na entrada do Arduino, conforme datasheet do componente, criamos a seguinte relação:

Tensão em A0 = (Valor lido em A0)*(5/1023)

Temperatura = Tensão em A0/10mV

logo:

Temperatura =  ((Valor lido em A0)*5/1023)/0,01

2.7.3. Atenção: Neste projeto não devemos utilizar a função analogReference(INTERNAL) para alterar o valor de referência da tensão máxima que pode entrar nas portas analógicas de 5V para 1,1V, pois utilizamos outros componentes analógicos junto com o sensor LM35 que poderão não funcionar corretamente devido a tensão modificada. A função analogReference(INTERNAL) é recomenda quando utilizamos apenas o sensor LM35 como componente analógico - Projeto 39 - Display LCD como mostrador de temperatura.

2.8. A expressão seletor++, incrementa o valor da variável seletor, passando de 1 para 2. Portando, seletor receberá o valor 2.

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

3.1.  A expressão condicional if(millis() - timer >=2000) determina que os comandos inseridos nela sejam executados a cada 2 segundos (2.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.

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

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 >= 2000) seja atendida, os seguintes comandos são realizados:

3.2.1. A variável temperature[1] recebe o valor lido pelo termistor através da método temp.getTemp() que faz parte da biblioteca Thermistor.h.

3.2.2. Definimos através do método Dht.read11(A1) que o sensor de temperatura DHT11 deverá estar conectado à porta analógica A1.

3.2.3. A variável temperature[2] recebe o valor lido pelo sensor DHT11 através do método DHT.temperature que faz parte da biblioteca dht.h.

3.2.4. Através do loop for(int i=0;i<1000;i++) os comando abaixo é repetido por 1000 vezes, sendo:

3.1.1. A expressão temerature[3] = temperature[3] + (float(analogRead(A0))*500/1023) faz a somatória das leituras do sensor LM35 durante o ciclo de 1000 repetições.

3.2.5. Após finalizar o loop, calculamos a média das leituras do sensor LM35 através da equação: temperature[3] = temperature[3] / 1000.

Obs.1: Como já mencionamos anteriormente, não podemos utilizar a função analogRead(A0) neste projeto. Em razão disto, as leituras do sensor LM35 poderão apresentar variações discrepantes. A média de várias leituras, no entanto, resolve este problema e gera resultados bem precisos.

Obs.2: Ao utilizarmos o loop com um ciclo de 1000 repetições, aumentaremos o tempo de atualização das leituras em 1 segundo. Portanto, as leituras de temperatura serão atualizadas a cada 3 segundos, ou seja, 2 segundos para satisfazer a condicional if e 1 segundo para concluir o loop for.

3.2.6. A expressão timer = millis(); faz com que a variável timer receba agora o valor de millis() após 2000ms, reiniciando a contagem para a próxima exibição dos valores que atualizará as leituras dos sensores.

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.3.1. Para saber mais sobre funções, leia: Como criar e utilizar Funções para organizar seu código em Arduino.

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.

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 no sensor DHT11, 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 obtida pelo sensor LM35. Também, a variável seletor receberá o valor de 1.

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 função 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 termistor, DHT11 e LM35, 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 deve 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 "NTC = ", através do comando lcd.print().

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

4.2.3.1. Se x = 1, será exibido no display LCD o texto "LM35 = ", 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 termistor, DHT11 ou LM35. 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. Finalmente a letra "C", de Celsius, é exibida através do método lcd.print().

Desafios

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

Comentários