27 de mai de 2011

Leitura de temperatura (termometro) com o arduino exibindo resultado no LCD

Antes de iniciar está leitura recomendo que leiam os artigos anteriores especialmente estes:

Os artigos acima são a base para integrar um LM35 (sensor de temperatura) com um display de LCD. Recomendo que em caso de dúvidas utilizem os comentários e na medida do possível irei respondê-las.

Para a realização deste projeto, será necessário algumas adaptações nos códigos, e algumas explicações adicionais, como por exemplo:
1) Imprimir um caractere personalizado no LCD.
2) Imprimir uma variável no LCD.
3) Redução os erros.

Imprimindo caracteres personalizados.

Em um display LCD se repararmos atentamente podemos ver que os caracteres são formados por pequenos pontos. Cada um desses pontos é organizado em "blocos" de 5 colunas por 8 linhas, em um display de 20x04
temos 20 "blocos" por linha ou um total de 80 "blocos".

 
Figura 1 - Display LCD de 20x04 com alto nível de contraste.
  
Figura 2 - Zoom em um bloco  

 Para darmos um acabamento mais profissional ao termômetro utilizaremos um recurso que nos permite criar um caractere customizado para indicarmos a temperatura em graus Celsius ( ºC )

Figura 3 - Caractere personalizado seguido da letra C. 

Para criarmos nosso caractere precisamos definir quais pontos ou pixels deixaremos ligados. Isto é facilmente implementado utilizando um vetor. O exemplo abaixo mostra como criar um bloco sólido isto é com todos os pixels ligados.
 
byte a[8]= 
{

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,
}

Repare que temos 8 linhas e cada linha é preenchida cinco vezes com números 1, isto soa familiar não?
O próximo passo é armazenar esse vetor em uma posição de memória para isto utilizaremos a seguinte função:
lcd.createchar(0,a);
 
 E para mostrarmos no display nosso caractere personalizado usaremos 

lcd.write(0);
Sendo 0 a posição de memória do caracter, se tivermos mais de um caracter personalizado devemos armazená-lo em outra posição. Existe um limite de 7 caracteres para os controladores de LCD mais comuns,
nuca se esqueça de respeitar esse limite  
               lcd.createchar(7,a);

Imprimindo uma variável no LCD.

Até agora somente escrevemos no LCD dados fixos que não se alteravam com o passar do tempo, este tipo de solução não irá nos satisfazer visto que sensores sempre estão captando variações no ambiente e atualizando sua saída de tensão , corrente, etc.

Para imprimir dados estáticos se utiliza a função lcd.print("Texto a ser impresso ");
Quando um valor se atualiza constantemente este deve ser armazenado em uma variável e esta deve ser impressa no LCD para isto declararemos uma variável e atribuiremos um valor a mesma.
float temperatura=0;
lcd.print(temperatura); // imprime no LCD o conteúdo da variável temperatura

Para aumentar a precisão do termômetro a variável temperatura foi declarado com o tipo float para permitir leitura e impressão de números fracionais.

Reduzindo os erros por software.

Para evitarmos mudanças repentinas durante a exibição da temperatura podemos ler por diversas vezes a temperatura e depois tirarmos uma média dos valores lidos e imprimir a média obtida. Outro ponto válido seria excluir o valor máximo e mínimo lidos e tirarmos a média dos restantes.

O último exemplo ficará para uma aplicação futura, mostrarei apenas o código para tirar a média dos valores.

    valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
    temperatura1=(valor_lido*5*100)/1024; /* Conversao do valor lido */
    delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
    valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
    temperatura2=(valor_lido*5*100)/1024; /* Conversao do valor lido */
    delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
    valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
    temperatura3=(valor_lido*5*100)/1024; /* Conversao do valor lido */
    delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
    valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
    temperatura4=(valor_lido*5*100)/1024; /* Conversao do valor lido */
    temperatura=(temperatura1+temperatura2+temperatura3+temperatura4)/4;


Para  melhorar a visualização e entendimento do código é recomendado o uso de funções, nos próximos projetos farei uso desta caracteristica da linguagem C.

Montagem do circuito

A montagem segue o mesmo padrão dos artigos utilizando um display de LCD e leitura de temperatura. Porém combinaremos as duas.Para poupar o trabalho de consultar os artigos anteriores siga as imagens abaixo. Lembre-se de consultar o datasheet de seu Display LCD para conferir a compatibilade do seu módulo com o usado neste projeto.




O código

#define sensor 0
#include <LiquidCrystal.h>

 /* Biblioteca com funcoes para uso de um LCD baseado no Hitachi HD 44780 */
 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 /* Define os pinos de ligacaoi do LCD ao arduino com esta ordem LiquidCrystal(rs, enable, d4, d5, d6, d7)  */

 float temperatura=0;
 float temperatura1=0;
 float temperatura2=0;
 float temperatura3=0;
 float temperatura4=0;
 float valor_lido=0;

void setup()
{
   /*lcd.begin(cols, rows) */
   lcd.begin(20, 4); /* Tipo de LCD usado no meu caso de 20 colunas por 4 linhas */
   lcd.setCursor(0, 0); /* O Cursor iniciara na coluna zero linha 0 */
   lcd.print("    Central AVR!");
  
     
}
void loop()
    {
    byte a[8] = {  B01110,  B01010,  B01010,  B001110,  B00000,    B00000,  B00000,  B00000}; // Caractete criado
    lcd.createChar(0,a); // define nosso caractere º como uma variável
       
    valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
    temperatura1=(valor_lido*5*100)/1024; /* Conversao do valor lido */
    delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
    valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
    temperatura2=(valor_lido*5*100)/1024; /* Conversao do valor lido */
    delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
    valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
    temperatura3=(valor_lido*5*100)/1024; /* Conversao do valor lido */
    delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
    valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
    temperatura4=(valor_lido*5*100)/1024; /* Conversao do valor lido */
    temperatura=(temperatura1+temperatura2+temperatura3+temperatura4)/4;
   
    lcd.setCursor(0, 2); /* O Cursor iniciara na coluna zero linha 2 */
    lcd.print("Temperatura= ");
    lcd.print(temperatura); // imprime no LCD o conteúdo da variável temperatura
    lcd.write(0); // Imprime º na tela do LCD
    lcd.print("C");
    delay(600);
    }


O resultado final

 Figura 4 - Resultado Final


 Figura 5 - Sensor LM35DZ




Video 1 - Resultado Final

1 de mai de 2011

Leitura de temperatura (termometro) com o arduino e comunicação serial

Construindo um termometro e enviando a temperatura lida a um computador.

Nos artigos anteriores observamos que o arduino é capaz de detectar tensões aplicadas nos seus pinos e informá-las através da função digitalRead().
Porém este tipo de indicação é binário ou seja somente nos indica nível alto (5V) ou nível baixo (0V). Existem outros tipos de aplicações que necessitam de mais precisão e nos mostram tensões com maior índice de variações. Os componentes que são capazes de transformar variações físicas do ambiente (temperatura, pressão, umidade) em grandezas que podemos interpretar facilmente (tensão e corrente) são chamados de sensores.

Para facilitar a coompreensão vamos analisar o funcionamento de um LDR (do inglês Light Dependent Resistor ou em português Resistor Dependente de Luz).
O LDR é um tipo de resistor cuja resistência varia conforme a intensidade de radiação eletromagnética do espectro visível (luz) que incide sobre ele.
Um LDR é um transdutor de entrada (sensor) que converte a luz em valores de resistência. É feito de sulfeto de cádmio (CdS) ou seleneto de cádmio (CdSe). Sua resistência diminui quando a luz é muito alta, e quando a luz é baixa, a resistência no LDR aumenta. Um multímetro pode ser usado para encontrar a resistência na escuridão ou na presença de luz intensa. Estes são os resultados típicos para um LDR padrão:
• Escuridão : resistência máxima, geralmente acima de 1M ohms.
• Luz muito brilhante : resistência mínima, aproximadamente 100 ohms.
O LDR é muito frequentemente utilizado nas chamadas fotocélulas que controlam o acendimento de poste de iluminação e luzes em residências. Também é utilizado em sensores foto-elétricos assim como foto-diodos. (fonte wikipedia http://pt.wikipedia.org/wiki/LDR)
Vimos que um LDR varia sua resistência de acordo com a quantidade de luz que incide sobre ele, se fizermos uma montagem utilizando uma resistência fixa em série com um LDR criamos um simples divisor de tensão como visto na figura abaixo:

Figura 1 - Divisor de tensão com um LDR.  http://www.feiradeciencias.com.br/sala15/15_05.asp acessado em 24/07/2011


Construindo um termometro com o arduino e um Sensor de temperatura.


Na parte inferior direita da placa do arduino encontramos 6 entradas analógicas:
A0, A1, A2, A3, A4 e A5. Trata-se de pinos especiais que podem nos dizer exatamente qual a tensão aplicada a eles, sendo que para ler essa tensão usaremos uma nova função chamada de analogRead().
Esta função retorna um número entre 0 e 1023, que representa uma voltagem entre 0V e 5V. Por exemplo se uma voltagem de 2,5V é aplicada a uma das entradas analógicas o valor retornado pela função é de 512.


No mundo físico, parâmetros como temperatura, força, pressão, umidade, velocidade entre outros são sinais analógicos. Essas grandezas físicas são convertidas em sinais elétricos, sendo que, para podermos trabalhar com esses dados com o auxilio de micro controladores, devemos converter esses sinais usando um conversor analógico digital (ADC) que é um componente eletrônico que converte sinais para uma forma discreta. Os conversores analógicos digitais são os dispositivos mais usados no mundo para a aquisição de dados.


O sensor LM35DZ

O sensor LM35 é um sensor de precisão, fabricado pela National Semiconductor
(www.national.com), que apresenta uma saída de tensão linear relativa à temperatura em
que ele se encontrar no momento em que for alimentado por uma tensão, tendo em sua saída um sinal de 10mV para cada grau Celsius de temperatura, sendo assim, apresenta uma boa vantagem com relação aos demais sensores de temperatura calibrados em “KELVIN”, não necessitando nenhuma subtração de variáveis  para que se obtenha uma escala de temperatura em Graus Celsius.
O sensor LM35 é apresentado com vários  tipos de encapsulamentos, sendo o mais
comum o TO-92, que mais se parece com um  transistor, e oferece ótima relação custo
benefício, por ser o mais barato dos modelos e propiciar a mesma precisão dos demais. A
grande diversidade de encapsulamentos se  dá devido à alta gama de aplicações deste
integrado.
Figura 2 - Tipos de encapsulamento de um LM35.


 Para uma variação de 1ºC o LM35DZ gera uma tensão de saída de 10mV, se a temperatura ambiente for de 23ºC a saída do LM35 será de 0,23V ou 230mV (23*10mV).
O LM35DZ é capaz de indicar temperaturas de 0ºC a 100ºC este tipo de informação é importante pois ao trabalharmos com sensores e conversores analógicos para digitais (ADC) temos que saber o fim de escala isto é o último valor informado pelo sensor e sua tensão final de saída.
Neste caso o LM35DZ se mostra de fácil entendimento pois 100ºC equivale a 1V (100*10mV), o ADC do arduino trabalha normalmente com um fundo de escala de 5V então teremos que nos ajustar para esse requisito, o que pode ser feito via software ou hardware.
O foco deste artigo é tomar sempre o caminho mais simples, portanto seguirei com o ajuste por software, mas darei uma dica sobre o ajuste por hardware, procure na internet ou na própria referência do arduino o ajuste de valor de referência do ADC.

 Mais sobre o LM35 em http://hermes.ucs.br/ccet/demc/vjbrusam/inst/temp51.pdf acessado em 24/07/2011

Conversão de tensão em uma grandeza física TEMPERATURA.


O fundo de escala do LM35DZ é de 100ºC ou 1V que é exatamente 5 vezes menor que a tensão de referência, portanto para termos uma leitura padrão faremos o valor lido vezes 5 vezes 100, e dividiremos o resultado por 1024 que é o número de retorno da função para termos um valor de retorno unitário. Assim corrigimos o fundo de escala e temos um valor de saída conhecido.

Agora vamos comprovar teoricamente a eficiência da conversão.
10mV é o passo unitário do sensor ou sua sensibilidade
5V é a tensão de referência do ADC que possui resolução de 10 bits (2^10 = 1024).
5V/1024 = 0,00488 que é a sensibilidade do ADC.

Para 1ºC temos:
valor lido = 10mV/0,00488 = 2,04 como esse resultado será armazenado em valor_lido uma variável do tipo int valor_lido será igual a 2.
Agora faremos os ajustes de fundo de escala e de conversão fisíca que se resume a uma simples multiplicação por 500 (5*100*valor_lido)

Resultado final

(Valor_lido *5 *100)/1024

(2*5*100)/1024 = 0,97ºC como nosso resultado sera apresentado como número inteiro teremos exibido 1ºC

Para 100ºC temos:
100ºC retorna o valor 1023 pela função analogRead; (que vai de 0 a 1023 no total 1024 passos )
como temos um valor 5 vezes menor devido a discrepância entre as referências teremos o seguinte
valor_lido= 1023/5 = 204,6

Agora aplicando a formula final:

(Valor_lido *5 *100)/1024

(1024*5*100)/1024 = 99,9ºC como nosso resultado sera apresentado como número inteiro teremos exibido 100ºC




Resolução de um ADC

A conversão D/A (digital / analógica) ou A/D (analógica / digital) gera ou utiliza um sinal digital composto por bits. A quantidade  de bits utilizada pela palavra digital na conversão determina o que é chamado de resolução. Quanto maior a resolução de uma interface, mais exata será sua percepção em relação aos sinais analógicos externos e mais precisa será sua representação digital.
De acordo com a ANALOG DEVICES resolução é o número de bits que o ADC utiliza para
representar o sinal analógico. Quanto maior a resolução, maior o número de divisões em que a faixa do sinal será representada, sendo assim quanto maior a resolução mais sensível é o ADC para as variações de tensão em uma mesma faixa de entrada e ganho. A menor variação de tensão detectável (também chamada de largura de código – code width) para um dispositivo de aquisição de dados  ideal é determinada por:

Menor variação de tensão detectável = faixa / (ganho*2resolução)

Considerando o ADC0808 com uma resolução de apenas 8 bits teremos apenas 256 passos, isso significa que o ADC só acusará mudanças de estado quando a tensão de entrada variar na ordem de 20mV.

Faixa / (ganho*2resolução) = 5V/2^8 = 20mV.

Agora considerando um ADC com 10 bits como o da linha de micro controladores da ATMEL série AVR (arduino), poderíamos notar diferenças de tensão na ordem de 5V/2^10= 5mV.

Abaixo podemos ver as características elétricas referentes a erros no ADC0808 (cito o ADC 0808 como um exemplo, visto que não é este o ADC dentro de um arduino)

Figura 3 - Características Elétricas ADC0808 (National Semiconductor  - Data sheet ADC0808 – Outubro de 1999).

Montagem do circuito

Figura 4 - Diagrama de montagem.

Exibindo o resultado

Para este artigo o resultado será exibido na tela de seu computador, a partir do protocolo de comunicação serial.
O arduino pode tanto receber comandos de um computador como também enviar. Para este objetivo iremos utilizar um objeto serial ( um objeto é uma coleção de habilidades que são postas juntas para a conveniência das pessoas que escrevem os códigos ou sketches).
Este objeto contém todo o código necessário para o envio/recebimento de dados.
A função para escrever dados serialmente é a Serial.println, mais informações sobre a mesma podem ser encontradas na pasta de referência do arduino.
Para habilitar a visualização dos dados envidos serialemtne pelo arduino, clique no ícone "Serial Monitor" e configure a taxa de transferência para 9600 baud.


Figura 5 - Tela de verificação de comunicação serial

O código:

#define sensor 0

int temperatura=0;
int valor_lido=0;

void setup()
{
 Serial.begin(9600);
}
void loop(){
  if (Serial.available())
  {
valor_lido=analogRead(sensor);
temperatura=(valor_lido*5*100)/1024;
Serial.println((long)temperatura);
  }
  delay(1000);
 }

O resultado Final

Para visualizar o valor lido clique no campo para entrada de dados do serial monitor e aperte ENTER, se tudo ocorreu perfeitamente um valor de temperatura será enviado pelo arduino, no meu caso em um dia chuvoso a temperatura lida foi de 21ºC


Figura 6 - Temperatura enviada pelo arduino.

 O código acima não é eficiente e muitas vezes pode até retornar valores totalmente confusos, pois as variáveis foram declaradas com o tipo INT. Ao se fazer isso se despreza parte dos resultados além de esta não ser uma prática recomendada de programação.
Fica a cargo do leitor a opção de corrigir o código (sim é muito fácil) e para aqueles que gostam de ler e querem ver tudo funcionando corretamente, leiam o próximo post onde farei a interface com um Display de LCD desta vez totalmente funcional.