Aprimorando um projeto – Termômetro com registro de temperatura mínima e máxima

utilizando um display de LCD, leitura de temperatura exibindo resultado no computador e Leitura de temperatura exibindo resultado no LCD 

Faça a montagem da placa como mostrado no projeto de leitura de temperatura exibida no LCD,
este novo projeto somente implementa novas funções ao antigo e no final citará algumas dicas para tornar este projeto algo ainda melhor, podendo até servir de base para algum trabalho de conclusão de curso técnico.

Função para arredondar um valor lido.

 

Dúvidas em relação ao uso de funções? recomendo o seguinte site: 
http://www.inf.pucrs.br/~pinho/LaproI/Funcoes/AulaDeFuncoes.htm (acessado no dia 05/07/2011)


Se quisermos mostrar valores dentro de uma faixa pré determinada podemos tratar os valores lidos pelo sensor e estipular uma regra de controle.
Enviamos um valor a função (parâmetro) este valor será do tipo float portanto utilizaremos do seguinte estratagema para calcular somente o valor fracional.

Vamos supor que o sensor envia o seguinte valor para a função “30,25”
Decalaramos uma variável temporária do tipo int para armazenar o valor de 30,25
como a váriavel é do tipo int ela ignorará o valor fracional.


float arredondado=30,25;
int temp_aux=0;
arredondado=30,25;
temp_aux=arredondado; 


Ao lermos o valor da variável temp_aux leremos somente 30
Então para calcular somente o valor fracional faremos arredonda-temp_aux que seria (30,25)-(30)=0,25



 float arredondamento(float arredonda)
{
int temp_aux=0;
float temp_fracional=0;
float temp_final=0;
temp_aux=arredonda;
temp_fracional=(arredonda-temp_aux);

if (temp_fracional>=0.125 && temp_fracional<0.375)
{
temp_fracional=0.25;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}
}


O bloco IF acima testa se um valor é maior ou igual a 0,125 e menor que 0,375, se as duas condições forem satisfeitas a temperatura retornada terá um valor de 0,25 adicionada ao seu valor inteiro.

Exibindo valores mínimos e máximos no display LCD

Para exibir toda essa gama de valores precisaremos de um display de 20×4, caso você possua um display de somente duas linhas, altere o código para exibir somente os valores que desejar.

A grande pergunta que deve ser feita neste projeto é como descobrir e manter atualizado os valores mínimos e máximos de temperatura durante um período,  para realizar esse controle utilizaremos uma lógica condicional muito simples.
Primeiro devemos declarar duas variáveis que irão armazenar os valores máximos e mínimos definiremos um valor inicial para as mesmas que garantirão uma condição inicial verdadeira.

float temp_maxima=-150;  // valor muito BAIXO para condição de temp MAX
float temp_minima=300;  // valor muito ALTO para condição de temp MIN


Repare que as variáveis declaradas são do tipo float pois estas receberão valores reais fracionários dentro do laço de controle se a condição for verdadeira


 Bloco responsável por imprimir a temperatura máxima
    if (temp_maxima<valor_arredondado)
{
temp_maxima=valor_arredondado;
lcd.setCursor(0,2);
lcd.print(“Temp max: ” );
lcd.print(temp_maxima);
lcd.write(0); // Imprime o caractere º
lcd.print(“C”);
}


 Bloco responsável por imprimir a temperatura mínima

   if (temp_minima>valor_arredondado)
{
temp_minima=valor_arredondado;
lcd.setCursor(0,3);
lcd.print(“Temp min: ” );
lcd.print(temp_minima);
lcd.write(0); // Imprime o caractere º
lcd.print(C”);
} 


O funcionamento deste bloco de código segue a mesma linha do anterior, temp_minima terá um valor inicial muito alto o que garantirá uma condição inicial verdadeira, todo o controle de impressão no LCD e de posicionamento está no bloco do if para somente ser executado quando uma condição verdadeira for detectada, garantindo maior velocidade ao programa.

 Repare que como declaramos temp_maxima com o valor de -150 a primeira condição sempre vai ser verdadeira, por ser verdadeiros o laço do IF será executado e a variável temp_máxima receberá o primeiro valor enviado pelo programa e nas próximas execuções irá atualizar o valor somente se temp_maxima<valor_arredondado.
 

Código fonte

#define sensor 0
#include <LiquidCrystal.h>
/* Biblioteca com funcoes para uso de um LCD baseado no Hitachi HD 44780 */
LiquidCrystal lcd(1, 0, 5, 4, 3, 2); // deve ser colocada fora do setup() para valer em todos os blocos do programa
/* Define os pinos de ligação do LCD ao arduino com esta ordem LiquidCrystal(rs, enable, d4, d5, d6, d7)  */

float temp_maxima=-150;  // valor muito BAIXO para condição de temp MAX
float temp_minima=300;  // valor muito ALTO para condição de temp MIN

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!”);

float le_temp(float x_sensor);
float arredondamento(float arredonda);
}

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
float temperatura_lida, valor_arredondado;

// Bloco responsável por imprimir a temperatura atual
temperatura_lida=le_temp(sensor); //chama a função le_temp() e passa como parametro a variavel sensor
valor_arredondado = arredondamento(temperatura_lida); //chama a função arredondamento e passa como parametro temperatura_lida
lcd.setCursor(0,1);
lcd.print(“Temp atual: ” );
lcd.print(valor_arredondado);
lcd.write(0); // Imprime o caractere º
lcd.print(“C”);

// Bloco responsavel por imprimir a temperatura maxima
if (temp_maxima<valor_arredondado)
{
temp_maxima=valor_arredondado;
lcd.setCursor(0,2);
lcd.print(“Temp max: ” );
lcd.print(temp_maxima);
lcd.write(0); // Imprime o caractere º
lcd.print(“C”);
}

// Bloco responsavel por imprimir a temperatura mínima
if (temp_minima>valor_arredondado)
{
temp_minima=valor_arredondado;
lcd.setCursor(0,3);
lcd.print(“Temp min: ” );
lcd.print(temp_minima);
lcd.write(0); // Imprime o caractere º
lcd.print(“C”);
}
}

float le_temp(float x_sensor)
{
float temperatura=0;
float temperatura1=0;
float temperatura2=0;
float temperatura3=0;
float temperatura4=0;
float valor_lido=0;

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

/* Código responsável pelo arredondamento */
float arredondamento(float arredonda)
{
int temp_aux=0;
float temp_fracional=0;
float temp_final=0;
temp_aux=arredonda;
temp_fracional=(arredonda-temp_aux);

if (temp_fracional>=0 && temp_fracional<0.125)
{
temp_fracional=0.00;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}

if (temp_fracional>=0.125 && temp_fracional<0.375)
{
temp_fracional=0.25;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}

if (temp_fracional>=0.375 && temp_fracional<0.625)
{
temp_fracional=0.50;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}

if (temp_fracional>=0.625 && temp_fracional<0.875)
{
temp_fracional=0.75;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}

if (temp_fracional>=0.875 && temp_fracional<1)
{
temp_fracional=1;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}
}

Resultado final

 

Figura 1 – Display LCD 20×4 informando temperatura lida em um período.

 

Dicas para melhorar um projeto com termômetro.

Uma função adicional de fácil aplicação seria instalar um buzzer no arduino e disparar um alarme toda vez que uma temperatura pré determinada for atingida. Outra aplicação interessante mas um pouco mais complexa seria fazer um controlador de temperatura, onde se usaria uma resistência para gerar calor, existem duas maneiras simples de controlar a temperatura, a primeira seria controle ON/OFF e a segunda controle por PWM, lembrando que o arduino possui pinos dedicados a essa função.

 

 

byte a[8]= 

{

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

}

lcd.createchar(0,a);

lcd.write(0);

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

[vc_row][vc_column][vc_column_text]

Construindo um termometro com um LM35 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:

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

Para uma variação de 1ºC o LM35 DZ 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 LM35 DZ 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

O fundo de escala do LM35 DZ é 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

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:

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.

#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);
}

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

[/vc_column_text][/vc_column][/vc_row]

Teoria sobre LCD displays de cristal líquido.

 

Sinais Enviados para o LCD

O display requer três sinais de controle que devem ser enviados pelo micro controlador.

Enable (E) – Este sinal permite acessar o display através das instruções R/W e RS.

Quando enable tem nível lógico baixo o display ignora os sinais vindos de R/W e RS, quando enable tem nível lógico alto o display checa os estados desses dois controladores, e responde de acordo.

Read/Write (R/W) Ler e Escrever- Determina a direção em que os dados fluem entre o LCD e o micro controlador, quando R/W tem nível lógico baixo os dados enviados pelo micro controlador são escritos no LCD, quando R/W tem nível lógico alto os dados são lidos do LCD.

Register select (RS) Seletor de Registros – De acordo com os dados nesse controlador o display interpreta o tipo de dado que está sendo enviado pelo micro controlador.

Quando RS tem nível baixo uma instrução está sendo escrita no display, quando o nível é alto um caractere ou mais está sendo escrito.

E = 0 Acesso ao LCD desabilitado

  = 1 Acesso ao LCD habilitado

R/W = 0 Escrevendo dados no LCD

  = 1Lendo dados do LCD

RS= 0 Uma instrução foi enviada ao LCD

    = 1 Um caractere foi enviado ao LCD

Escrevendo dados no LCD

Enviar dados para o display requer alguns passos:

1) Setar o bit R/W bit como 0 (zero).

2) Setar o bit RS como 0 (zero) ou 1 (um) (instrução ou caractere).

3) Enviar dados para as linhas de dado.

4) Setar o bit E como 1 (um).

5) Setar o bit E como 0 (zero).

Lendo dados

1) Setar o bit R/W como 1 (um)

2) Setar o bit RS como 0 (zero) ou 1 (um) (instrução ou caractere).

3) Ler dados das linhas de dados

4) Setar o bit E como 1 (um).

5) Setar o bit E como 0 (zero).

 

Pinagem do LCD

Display  20×4 dimensões e pinagem (Data Sheet MGD2004D-FL-YBS – 26 de junho de 2006)

 

 

Display CD 20×4 – descrição dos pinos. (Data Sheet MGD2004D-FL-YBS – 26 de junho de 2006)

Inicialização do LCD

Antes de usar o display para nosso objetivo, ele deve ser inicializado via reset interno ou pelo envio de um conjunto de instruções. Como nosso projeto foi concebido com a idéia de conectar o display a um micro controlador, escolhemos a inicialização por instruções.

Inicializar um display LCD com instruções é um processo simples, abaixo temos um fluxograma que indica todos os passos.

Fluxograma de inicialização por instruções do Display LCD (Ajay Bhargav – http://www.8051projects.net/)

De acordo com o fluxograma podemos observar que o display LCD é inicializado conforme a seguinte seqüência

1)    Enviar o comando 0x30 – Usando a interface de 8 bits

2)    Esperar 20ms

3)    Enviar o comando 0x30 – Usando a interface de 8 bits

4)    Esperar 20ms

5)    Enviar o comando 0x30 – Usando a interface de 8 bits

6)    Esperar 20ms

7)    Enviar o conjunto de instruções.

8)    Enviar o comando 0x01 para limpar a tela

Definir o modo de incremento.

Interface com o Arduino

Prossiga montando seu circuito de acordo com o esquema abaixo.

LCD 16×2 ou 20×4 possuem físicamente os mesmos pinos, o que muda durante seu uso são as instruções enviadas aos mesmos e é claro o limite de linhas e colunas.

O potênciometro é utilizado para ajustar o contraste dos caracteres no display, o regule conforme seu próprio critério, as setas >> indicam para que pinos do arduino os pinos do LCD devem ser ligados, não se esqueça de verificar se o datasheet do seu LCD é compatível com o meu esquemático.

O código

 Código fonte: (em itálico)

 #include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
/*
Pino 12 = RS
Pino 11 = EN
Pino 05 = D4
Pino 04 = D5
Pino 03 = D6
Pino 02 = D7
*/
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!”);
lcd.setCursor(0, 1); // O Cursor iniciara na coluna zero linha 1
}
void loop()
{
//lcd.setCursor(col, row)
lcd.setCursor(0, 2); // O Cursor iniciara na coluna zero linha 1
lcd.print(millis()/1000); // Função para contar em segundos
lcd.print(”  segundos”);  // Exibe e atualiza o tempo desde a entrada no loop
}

O código acima é escrito em linguagem C, e faz uso de bibliotecas integradas do arduino como por exemplo a função LiquidCrystal lcd(); que seta os pinos do lcd que serão conectados ao arduino. 

Na pasta de instalação do arduino subpasta reference podemos consultar uma explicação básica em inglês de todas as funções padrões, vou pegar a referência LiquidCrystal função LiquidCrystal() para exemplificar.

LiquidCrystal()

 

Description

 

Creates a variable of type LiquidCrystal. The display can be controlled using 4 or 8 data lines. If the former, omit the pin numbers for d0 to d3 and leave those lines unconnected. The RW pin can be tied to ground instead of connected to a pin on the Arduino; if so, omit it from this function’s parameters.

 

Syntax

 

LiquidCrystal(rs, enable, d4, d5, d6, d7)
LiquidCrystal(rs, rw, enable, d4, d5, d6, d7)
LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
LiquidCrystal(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)

 

Parameters

 

rs: the number of the Arduino pin that is connected to the RS pin on the LCD

rw: the number of the Arduino pin that is connected to the RW pin on the LCD (optional)

enable: the number of the Arduino pin that is connected to the enable pin on the LCD

d0, d1, d2, d3, d4, d5, d6, d7: the numbers of the Arduino pins that are connected to the corresponding data pins on the LCD. d0, d1, d2, and d3 are optional; if omitted, the LCD will be controlled using only the four data lines (d4, d5, d6, d7).

 Neste procedimento foi utilizado um display de LCD de 20×4 com comunicação a 4 fios, portanto foi utilizada a função LiquidCrystal(rs, enable, d4, d5, d6, d7); Com os devidos valores substituídos pelos pinos do arduino.

LiquidCrystal(rs, enable, d4, d5, d6, d7);

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

 Pino 12 = RS
Pino 11 = ENABLE
Pino 05 = D4
Pino 04 = D5
Pino 03 = D6
Pino 02 = D7

O resultado final pode ser visto no vídeo abaixo