Leitura de temperatura (termometro) com o arduino exibindo resultado no LCD
Antes de iniciar está leitura recomendo que leiam os artigos anteriores especialmente estes:
utilizando um display de LCD e leitura de temperatura.
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) */
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);
}
É um jogo consiste em quatro botões grandes que acendem em sequência e o jogador precisa memorizar esta sequência e repetí-la. A cada rodada a sequência aumenta em 1 elemento. O jogo termina quando o jogador erra a sequência apresentada ou, no nosso caso, quando a sequência chega a 100 elementos.
MONTANDO OS CIRCUITOS
Para implementar este jogo, utilizaremos 4 sensores de pressão para representar os botões, quatro LEDs coloridos para indicar qual botão da sequência deve-se pressionar, um LED para indicar que o jogador deve começar a pressionar os botões, e um auto-falante para emitir o som de cada botão.
Primeiro vamos conectar os LEDs às saídas digitais do Arduino. Escolhemos conectá-los às saídas digitais PWM, pois desta forma poderemos incrementar o nosso jogo posteriormente, adicionando efeitos nos LEDs, com escrita analógica nestas portas. Assim, os LEDs vermelho, verde, azul e amarelo serão conectados às portas 5, 6, 9 e 10, respectivamente. O LED que indica a vez do jogador repetir a sequência será conectado à porta 2. Adicionamos as seguintes diretivas de pré-processamento para facilitar a leitura do código:
// LEDs em portas de saída PWM digital
#define LED_RED 5
#define LED_GREEN 6
#define LED_BLUE 9
#define LED_YELLOW 10O circuito para ligar os LEDs às portas é composto do LED propriamente dito e um resistor de 220Ω em série para limitar a corrente no LED, como pode ser visto na figura abaixo:
Os sensores de pressão que utilizamos são resistores que variam sua resistência de acordo com a força aplicada sobre ele. Sem nenhuma força exercida sobre ele, sua resistência é acima de 1MΩ, e com 10Kg sua resistência é próxima de 0Ω. Assim, ligaremos o sensor de pressão com um resistor de 10kΩ para formar um divisor de tensão, que vai variar a tensão de entrada na porta analógica de acordo com a força aplicada ao sensor de pressão. Ligaremos cada sensor de pressão (que chamaremos de PAD no código) a uma das portas analógicas de acordo com a definição abaixo:
// PADs nas portas de entrada analógica
#define PAD_RED 0
#define PAD_GREEN 1
#define PAD_BLUE 2
#define PAD_YELLOW 3
#define MAX_PADS 4
O circuito para os sensores de pressão está mostrado na figura abaixo:
Para emitir os sons do jogo, utilizaremos um pequeno auto-falante, destes encontrados em headphones. Este auto-falante será conectado à porta 12 do Arduino. Abaixo segue a diretiva de pré-processamento com a definição desta porta:
// Speaker on digital out port 12
#define SPEAKER 12
Caso seja necessário, podemos adicionar um resistor de baixo valor (100Ω ou menos) para reduzir o volume do auto-falante. O Genius utiliza notas musicais para indicar o acionamento de cada botão. Sabemos que o som de uma nota musical é a variação do deslocamento do ar em uma única frequência. Assim, se ligarmos e desligarmos a porta em que o auto-falante está conectado, na frequência desejada, o auto-falante emitira o som da nota correspondente. As notas que utilizaremos para cada um dos botões são: Lá para o vermelho, Lá, uma oitava acima (o dobro da frequência) para o verde, Ré para o azul e Sol para o amarelo. Para ligar e desligar o auto-falante na frequência desejada, precisamos calcular o período, que é o inverso da frequência. O auto-falante deverá permanecer meio período ligado e meio período desligado, tantas vezes quanto for a duração da nota. Assim, temos as seguintes definições para o meio período de cada nota a ser tocada:
// Notas desempenhado por cada PAD
// O valor de cada constante representa o período de cada
// Note que será tocado quando um bloco é pressionado.
// A relação de cada almofada com uma nota é o seguinte:
#define NOTE_HPERIOD_RED 1136 // Uma nota - 440Hz
#define NOTE_HPERIOD_GREEN 568 // Uma nota e uma oitava acima do RED - 880Hz
#define NOTE_HPERIOD_BLUE 1700 // D-note - 294Hz
#define NOTE_HPERIOD_YELLOW 1275 // G-note - 392Hz
#define NOTE_HPERIOD_ERROR 5000 // 100Hz
Abaixo segue a função para tocar uma nota, bem como o circuito para ligar o auto-falante à porta.
// Plays a note according to its half periodvoid playNote(long hperiod, long duration)
{
long elapsed_time = 0;
// Jogou menos tempo do que 'duração'
while (elapsed_time < duration)
{
// turno para a metade do período
digitalWrite(SPEAKER, HIGH);
delayMicroseconds(hperiod);
// turno fora por metade do período
digitalWrite(SPEAKER, LOW);
delayMicroseconds(hperiod);
// Adiciona um período de tempo decorrido
elapsed_time += (hperiod*2);
}
}
Ao juntar todos estes circuitos e conectá-los ao Arduino, temos a nossa configuração de hardware pronta. A figura abaixo mostra como ficou este circuito montado em uma protoboard.
FUNÇÕES DO JOGO
A logica do jogo é bastante simples. Primeiro temos que sortear um elemento (pad) e adicioná-lo à sequência de pads. Depois executamos toda a sequência para que o jogador a memorize, e depois esperamos pelo pressionamento dos pads e comparamos os pads pressionado com a sequência salva. Caso o jogador acerte a sequência, começamos este ciclo novamente. Se não, sinalizamos o erro e o jogo recomeça.
Para o nosso jogo, definimos um conjunto de constantes, que representam o tempo que cada LED permanece aceso, o intervalo entre o acendimento dos LEDs, a sensibilidade dos PADs, etc. Além disto, definimos duas tabelas para converter um valor de PAD para a porta do respectivo LED e o valor do PAD em um periodo da nota a ser tocada. Também temos variáveis para representar o fim do jogo e para armazenar a sequência de pads a serem pressionados. Abaixo seguem estas definições e as funções setup() e loop() do nosso jogo:
////////////////////////////////////////////////////////////
// Definição de constantes
////////////////////////////////////////////////////////////
// Notas desempenhado por cada PAD
// O valor de cada constante representa o período de cada
// Note que será tocado quando um bloco é pressionado.
// A relação de cada almofada com uma nota é o seguinte:
#define NOTE_HPERIOD_RED 1136 // Uma nota - 440Hz
#define NOTE_HPERIOD_GREEN 568 // Uma nota e uma oitava acima do RED - 880Hz
#define NOTE_HPERIOD_BLUE 1700 // D-note - 294Hz
#define NOTE_HPERIOD_YELLOW 1275 // G-note - 392Hz
#define NOTE_HPERIOD_ERROR 5000 // 100Hz
// Número máximo de toques na PAD, para terminar o jogo
#define MAX_NUM_TOUCHES 100
// Duração máxima de cada toque em milisegundos
#define MAX_TOUCH_DURATION 500
// Intervalo máximo de cada toque em milisegundos
#define MAX_TOUCH_INTERVAL 250
// Sensibilidade do sensor de toque
#define TOUCH_SENSIBILITY 1000
// Porta analógica para a leitura do inicializador randomSeed
#define RANDOM_SEED_PORT 5
////////////////////////////////////////////////////////////
// Definição de variáveis globais
////////////////////////////////////////////////////////////
// Tabela de pesquisa para converter PAD para um LED
unsigned char PAD_TO_LED[MAX_PADS];
// Tabela de pesquisa para converter PAD para um período NOTA
unsigned long PAD_TO_NOTE_HPERIOD[MAX_PADS];
// Jogo mais variável
boolean gameOver;
// Seqüência de pastilhas de ser tocado
unsigned char padSequence[MAX_NUM_TOUCHES];
// O número atual de usuários toca deve executar
int currentNumTouches;
// Duração de cada toque (irá diminuir ao longo do tempo)
long currentTouchDuration;
// Intervalo de tempo entre os toques (vai diminuir ao longo do tempo)
int currentTouchInterval;
////////////////////////////////////////////////////////////
// Declarações de função
////////////////////////////////////////////////////////////
// Função para repor o estado do jogo
void restartGame();
// Função para preencher nex aleatório para ser pressionado e inseri-lo em seqüência pad
void nextRound();
// Função que reproduz a seqüência de teclado atual
void playSequence();
// Função que verifica a entrada do jogador contra a seqüência salvo
void verifySequence();
// Função para aguardar uma entrada de teclado
int readPads();
// Função para transformar o bloco em correspondig levou,
// E jogar bloco de notas correspondentes
void turnPadOn(int pad);
// Função que reproduz o som da vitória
void playVictorySound();
// Função que reproduz o som de erro
void playErrorSound();
// Função para tocar uma nota com base no seu período de meia
void playNote(long period, long duration);
// Coloque todos os leds no teclado
void turnAllLedsOn();
// Coloque todos os leds apagados pad
void turnAllLedsOff();
////////////////////////////////////////////////////////////
// Configuração do Arduino () função
////////////////////////////////////////////////////////////
void setup()
{
// Definindo portas LED como SAÍDAS
pinMode(LED_PLAYING, OUTPUT);
// Definindo como porta SPEAKER OUTPUT
pinMode(SPEAKER, OUTPUT);
// Não há necessidade de usar pinMode para definir as entradas PADs
// Porque eles estão ligados as entradas analógicas
// (Na verdade você não pode fazer isso porque pinMode
// Afecta apenas as portas digitais) RS Rs se liga mané!
// Inicializando a PAD para LED tabela de pesquisa
PAD_TO_LED[PAD_RED] = LED_RED;
PAD_TO_LED[PAD_GREEN] = LED_GREEN;
PAD_TO_LED[PAD_BLUE] = LED_BLUE;
PAD_TO_LED[PAD_YELLOW] = LED_YELLOW;
// Inicializando a almofada NOTA tabela de pesquisa
PAD_TO_NOTE_HPERIOD[PAD_RED] = NOTE_HPERIOD_RED;
PAD_TO_NOTE_HPERIOD[PAD_GREEN] = NOTE_HPERIOD_GREEN;
PAD_TO_NOTE_HPERIOD[PAD_BLUE] = NOTE_HPERIOD_BLUE;
PAD_TO_NOTE_HPERIOD[PAD_YELLOW] = NOTE_HPERIOD_YELLOW;
restartGame();
}
////////////////////////////////////////////////////////////
// Loop Arduino () função
////////////////////////////////////////////////////////////
void loop()
{
// Gera almofada próxima aleatória e acrescenta que a seqüência pad
nextRound();
// Executar a seqüência de teclado atual
playSequence();
delay(currentTouchInterval);
// Aguarda pela entrada do jogador e verificar se a entrada do jogador
// Corresponde a seqüência de teclado
verifySequence();
// Se o jogo tiver terminado, reiniciar o jogo
if(gameOver)
{
restartGame();
}
}
Para a geração de números aleatórios, utilizamos as seguintes funções do Arduino: randomSeed(), que inicializa o gerador de números aleatórios; e random() que retorna um numero aleatório dentro de um intervalo. Para inicializar a função randomSeed() usamos o valor lido de uma porta analógica não utilizada (conectada), que vai flutuar (variar) de acordo com as ondas eletromagnéticas do ambiente. Esta inicialização e a inicialização as variáveis do jogo é feita na função restartGame(), apresentada abaixo:
void restartGame()
{
// Reset global variables
gameOver = false;
currentNumTouches = 0;
currentTouchDuration = MAX_TOUCH_DURATION;
currentTouchInterval = MAX_TOUCH_INTERVAL;
// turn off all leds
turnAllLedsOff();
// Restart random number generation
randomSeed(analogRead(RANDOM_SEED_PORT));
}
Abaixo seguem as funções para calcular o próximo pad a ser pressionado, executar a sequência de pads para que o usuário memorize e verificar se os pads pressionados pelo usuário estão na sequência correta.
////////////////////////////////////////////////////////////
// Game functions
////////////////////////////////////////////////////////////
void nextRound()
{
// Increments the number of pad touches for this round
currentNumTouches++;
// If pad touches reaches the maximum, the player has finished the game
// So, play the victory sounds
if (currentNumTouches >= MAX_NUM_TOUCHES)
{
playVictorySound();
}
// Else, adds a new random pad to the sequence
else
{
padSequence[currentNumTouches - 1] = random(0, MAX_PADS);
}
}
void playSequence()
{
// go through the stored PAD sequence turn on corresponding LED and
// playing corresponding note
for (int i=0; i < currentNumTouches; i++)
{
turnPadOn(padSequence[i]);
}
}
void verifySequence()
{
int pad = 0;
// Turn the playing LED on
// This notifies the player that it is time to press the pads
digitalWrite(LED_PLAYING, HIGH);
// Run though pad sequence waiting for player input and
// verifying the input against the sequence
for(int i=0; i< currentNumTouches; i++)
{
// Waits for pad input
pad = readPads();
// Verify if the correct pad was pressed
if (pad == padSequence[i])
{
// If the pad is correct, turn the corresponding LED
// on and play its note
turnPadOn(pad);
}
else
{
// if pressed pad is a wrong pad, the player looses the game
// so, play the Error sound
playErrorSound();
gameOver = true;
break;
}
}
// Turn the playing LED off
digitalWrite(LED_PLAYING, LOW);
}
Quando o jogador pressiona um pad, sua resistência diminui, levando o valor de tensão na porta correspondente do arduino para baixo também. Assim, para verificar os pads pressionados, devemos ler cada uma das portas dos pads em sequência. Caso o valor lido seja menor que o nosso valor de sensibilidade (no nosso caso 1000, para uma sensibilidade bem alta), consideramos este pad pressionado. A função que faz esta leitura está descrita abaixo:
int readPads()
{
boolean padPressed = false;
int pad = 0;
do{
// Verifica a porta de cada bloco, verificando se
// Foi pressionado
for(int i=0; i
{
// Lê a porta de almofada
int pressure = analogRead(i);
// Se a pressão atravessa o threashold, bloco atual é pressionado
if(pressure < TOUCH_SENSIBILITY)
{
padPressed = true;
pad = i;
break;
}
}
}while (!padPressed);
return pad;
}
As outras funções do código são funções auxiliares bastante simples
OK, agora que estamos claros sobre o tipo de LCD que estamos falando, é hora de olhar também para as diferentes formas que vêm em
Embora eles exibem apenas o texto, eles fazem alguns em muitas formas: da parte superior esquerda temos uma 20x4 com texto branco sobre fundo azul, uma 16x4 com texto preto em verde, 16x2 com texto branco em azul e uma 16x1 com texto preto em cinza.
A boa notícia é que todas essas exposições são 'swap' - se você construir seu projeto com um pode desligá-lo e utilizar outro tamanho. Seu código pode ter que ajustar para o tamanho maior, mas, pelo menos, a fiação é a mesma!
Para esta parte do tutorial, vamos estar usando LCDs com uma faixa única de 16 pinos, como mostrado acima.Existem também alguns com duas linhas de 8 pinos da seguinte forma:
Estes são muito mais difíceis de breadboard. Se você quiser alguma ajuda na fiação estes acima, confira esta página
OK agora você tem o seu LCD, você também vai precisar de algumas outras coisas. Primeiro é um potenciômetro 10K. Isso permitirá que você ajuste o contraste. Cada LCD terá configurações de contraste um pouco diferente assim que você deve tentar obter algum tipo de trimmer. Você também vai precisar de algum cabeçalho de 0,1 "- 16 pinos longos
Se o cabeçalho é muito longo, apenas corte / encaixe-curta!
Em seguida, você vai precisar soldar o cabeçalho para o LCD. Você deve fazer isso, não é OK para apenas tentar 'encaixe' do LCD!
A maneira mais fácil, sabemos de fazer isso é furar o cabeçalho em uma breadboard e depois sentar em cima do LCD, enquanto a soldagem. isso mantém-se firme.
OK agora vamos para a parte interessante! Obtenha seu LCD ligado na breadboard
Agora vamos fornecer energia ao breadboard. Conectar +5 V para o trilho vermelho e terra para o trilho azul.
Em seguida, vamos conectar-se a luz de fundo para o LCD. Conectar o pino 16 para terra e pin 15-5 V através de um resistor em série. Para calcular o valor do resistor em série, procure a luz de fundo corrente máxima ea queda de tensão típica luz de fundo da folha de dados. Subtraia a queda de tensão de 5 volts, em seguida, dividir pela corrente máxima, em seguida, volta até o valor do resistor próximo padrão. Por exemplo, se a queda de tensão é 3.5V backlight típica e corrente nominal é de 16mA, então o resistor deve ser (5-3,5) / 0,016 = 93,75 ohms ou 100 ohms quando arredondado para um valor padrão. Se você não consegue encontrar a folha de dados, então deve ser seguro usar um resistor de 220 ohm, apesar de um valor tão alto pode fazer a luz de fundo em vez dim.
Conectar o Arduino até o poder, você verá as luzes se backlight
Note que alguns LCDs de baixo custo não vêm com uma luz de fundo. Obviamente que nesse caso você deve apenas continuar.
Em seguida, vamos colocar o pot outro lado, ele vai para o lado mais próximo do pino 1
Conecte um lado do pote de +5 V e outro para a terra (não importa o que vai sobre o lado). No meio da panela (limpa) conecta ao pino 3
Agora vamos conectar a lógica do LCD - este é separada da luz de fundo! O pino 1 aterrado eo pino 2 é +5 V
Agora ligue o Arduino, você vai ver a luz backlight para cima (se houver), e você também pode torcer o pot para ver a primeira linha de retângulos aparecer.
Isto significa que você tem a lógica de retroiluminação e contraste tudo certo. Não continue a menos que você tem este figurado para fora!
Agora vamos terminar a fiação ligando as linhas de dados. Existem 11 linhas de ônibus: D0 através D7 (8 linhas de dados) e RS , PT , e RW . D0-D7 são os pinos que os dados brutos que enviamos para o visor. O RS pino permite que o microcontrolador dizer o LCD se quer exibir os dados (como em um ASCII de caracteres) ou se é um byte de comando (como, alterar posistion do cursor). O PT é o pino 'enable' linha usamos isso para dizer o LCD quando os dados está pronto para a leitura. A RW pino é usado para definir a direção - se queremos escrever para o display (comum) ou ler a partir dele (menos comum)
A boa notícia é que nem todos estes pinos são necessários para nos conectar ao microcontrolador (Arduino). RW por exemplo, não é necessário se estamos apenas escrevendo para o display (que é a coisa mais comum de fazer de qualquer maneira), de modo podemos 'tie-lo' a terra. Há também uma maneira de falar com o LCD utilizando apenas 4 pinos de dados em vez de 8. Isso economiza nos 4 pinos! Por que você nunca quer usar 8 quando você pode usar 4?Não estamos 100% de certeza, mas pensamos que, em alguns casos, a sua mais rápido usar 8 - que leva o dobro do tempo de usar 4 - e que a velocidade é importante. Para nós, a velocidade não é tão importante, então vamos poupar alguns pinos!
Então, para recapitular, precisamos de 6 pinos: RS, EN, D7, D6, D5, e D4 para falar com o LCD.
Nós estaremos usando o LiquidCrystal biblioteca para falar com o LCD assim que um monte de trabalho chato de pinos de fixação e como é cuidado. Outra coisa legal sobre esta biblioteca é que você pode usar qualquer pino do Arduino para conectar-se os pinos de LCD. Então, depois de passar por este guia, você encontrará mais fácil de trocar em torno dos pinos, se necessário
Como mencionado, não estará usando o RW pino, para que possamos amarrá-lo ir chão. Isso é o pino 5 como bere mostrado:
Em seguida é a RS pin # 4. Vamos usar um fio marrom para conectá-lo ao pino digital do Arduino # 7
Em seguida é a EN pin # 6, vamos usar um fio branco para conectá-lo ao Arduino digital # 8
Agora vamos conectar os pinos de dados. DB7 é o pino # 14 no LCD e se conecta com um fio de laranja para Arduino # 12
Em seguida, estão os restantes três linhas de dados, DB6 (amarelo) DB5 (verde) e DB4 (azul) que se conectar a
Arduino # 11, 10 e 9
Isto é o que você terá em sua mesa:
Abra o Arquivo → Exemplos → LiquidCrystal → HelloWorld esboço exemplo
Agora vamos precisar atualizar os pinos. Procure esta linha:
LiquidCrystal lcd ( 12 , 11 , 5 , 4 , 3 , 2 ) ;
E mude para:
LiquidCrystal lcd ( 7 , 8 , 9 , 10 , 11 , 12 ) ;
Para coincidir com a mesa de pinos que nós fizemos. Agora você pode compilar e fazer o upload do esboço
Ajustar o contraste, se necessário
Você pode, naturalmente, utilizar qualquer tamanho ou LCD a cores, tal como um LCD 20x4:
Ou um preto em verde:
A coisa agradável sobre o negro em verdes é que você pode remover a luz de fundo. Às vezes, eles não vêm com um!
Uma coisa que você vai querer prestar atenção para é como o LCD controla as mensagens grandes e múltiplas linhas.Por exemplo, se você mudou esta linha
lcd. print ( "Olá, mundo!" ) ;
A esta:
lcd. print ( "Olá, mundo esta é uma mensagem muito longa!" ) ;
O LCD 16x2 vai cortar nada de passado o 16 º caractere:
Mas o LCD 20x4 vai 'quebrar' a primeira linha para a terceira linha! (Da mesma forma a linha 2 corre para o quarto) Isso parece realmente bizarro, mas a sua memória como o LCD configurado no interior. Isso provavelmente deve ter sido feito diferente, mas hey, que é o que temos de viver. Esperamos que vamos ter uma biblioteca LCD futuro que é muito inteligente e linhas de wraps, mas por agora estamos presos. Então, ao escrever longas filas para o LCD contar seus personagens e se certificar de que você não acidentalmente saturação das linhas!
Temos agora um pouco diferentes ações backlight RGB LCDs . Estes trabalhos LCDs como o tipo de caractere normal, mas a luz de fundo tem três LEDS (vermelho / verde / azul) para que você possa gerar qualquer cor que você quiser. Muito útil quando você quer ter alguma informação veiculada ambiente.
Depois de ter ligado o LCD e testou-o como descrito acima, você pode conectar os LEDs à analógica PWM fora pinos do Arduino para precisamente definir a cor. Os pinos PWM são fixos em hardware e há 6 deles, mas três já são usadas por isso vamos usar os restantes três pinos PWM. Conectar o pino LED vermelho para Digital 3, o pino de LED verde (pino 17 do LCD) para digital 5 eo pino LED azul (pino 18 do LCD) para digital 6. Você não precisa de nenhum resistências entre os pinos LED e os pinos do Arduino porque resistores são já soldada sobre o LCD personagem para você!
/*
Led RGB e Display LCD : HSB loop
Makes an RGB led to loop on all colors and displays
the RGB values into an LCD display. The color loop
is achieved varying the Hue value from 0 to 255 and
converting the HSB value into RGB values.
The circuit:
* LCD RS pin to digital pin 13
* LCD Enable pin to digital pin 12
* LCD D4 pin to digital pin 5
* LCD D5 pin to digital pin 4
* LCD D6 pin to digital pin 3
* LCD D7 pin to digital pin 2
* 10K resistor:
* ends to +5V and ground
* wiper to LCD VO pin (pin 3)
* RGB Led Red pin to PWM pin 9
* RGB Led Green pin to PWM pin 10
* RGB Led Blue pin to PWM pin 11
* RGB Led GND pin to GND
* 220 resistors:
* on each led's color pin
Based on the Arduino Liquid Crystal tutorial and
the HSBtoRGB function from Paul V. (Arduino Forum).
* http://www.arduino.cc/en/Tutorial/LiquidCrystal
* http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1235225449/13#13
Resolvemos usar esse exemplo do video Super máquina para entendermos melhor essa questão da Programação Sequencial
Que é aquela que é executada sequencialmente, da primeira à última linha de código, seguindo-se rigorosamente a ordem em que foi escrito o programa.
Por vezes é confundida com Programação Procedural (baseada em procedimentos e funções) ou com Programação Modular (aquela que é baseada em pequenos blocos de códigos, isolados ou não, que podem ser executados a qualquer momento).
Toda linguagem Script é, conceitualmente, sequencial: repare que uma linguagem script (seja ela qual for) sempre executa diversas rotinas em uma ordem pré estabelecida.
no exemplo são usados 6 LEDs que são conectados entre os pinos 2 e 7 da placa.
