Escolar Documentos
Profissional Documentos
Cultura Documentos
Display 7 seguimentos
Abaixo temos um pequeno exemplo de conexo de 4 displays de 7 seguimentos que
mostram o resultado de uma operao Fatorial. O funcionamento do circuito no
importante neste exemplo, basta observarmos a necessidade de reserva de 11 pinos do
microcontrolador para mostrarmos apenas 4 caracteres apenas numricos. Para cada
dgito acrescentado, precisamos de mais um pino do microcontrolador.
Estes LCDs so conhecidos como 57, uma vez que a linha inferior reservada para o
cursor.
A disposio dos pinos pode variar de modelo para modelo, veja abaixo uma outra
disposio muito comum nos LCDs. Na dvida consulte o datasheet do fabricante.
O pino (3) controla o contraste do LCD, para isso basta aplicar um sinal de 0V
+5Vcc. Podemos utilizar um potencimetro entre 10k e 20k para este ajuste
conforme a figura abaixo:
O pino (4) RS o seletor de Registros. Isso quer dizer que quando este pino est em
nvel lgico baixo (0) os dados enviados para o LCD so tratados como comandos e os
dados lidos do LCD indicam o seu estado atual (status). Quando este pino est em nvel
lgico alto (1), os dados so tratados como caracteres, tanto para leitura como para
escrita.
Nvel lgico (0): Comandos
Nvel lgico (1): Dados
O pino (5) R/W controla se a operao ser de leitura (1) ou gravao (0)
O pino (6) Enable, habilita os comandos do LCD em borda de descida (de 1 para 0).
utilizado para iniciar a transferncia de comandos ou caracteres entre o mdulo e as
linhas de dados. Quando estiver escrevendo para o display, os dados sero transmitidos
apenas a partir de uma transio de high para low (H -> L) deste sinal. No entanto, para
ler informaes do display, as informaes estaro disponveis imediatamente aps uma
transio L -> H e permanecer l at que o sinal volte para o nvel lgico baixo (0)
novamente.
Os pinos (7) (14) so o barramento de dados ( 8 bits). Ele trabalha com os oito sinais
em paralelo ou ainda pode trabalhar com um barramento de 4 vias (normalmente D4 a
D7), mas os dados devem ser transmitidos em dois pacotes. Cada pacote de quatro bits
conhecido como nibble. Este um excelente recurso para minimizar o uso de pinos de
I/O do microcontrolador, mas ocupa um pouco mais de memria. A deciso de utilizar 8
vias ou 4 vias exclusiva do desenvolvedor do projeto.
Ao alimentar o LCD, a primeira linha fica toda preenchida indicando que o LCD est
alimentado corretamente e que no existe nenhum pixel queimado.
Baseados na tabela anterior verificamos que existem diversas configuraes que podem
ser atribudas ao LCD. A tabela a seguir mostra as opes disponveis.
Lembre-se que, antes de qualquer operao com o LCD ele precisa ser inicializado
utilizando estas informaes da tabela acima. importante salientar que no existe uma
ordem especfica para os itens de configurao especificados acima. Eles podem ser
enviados em qualquer ordem, uma vez que o bit mais significativo de cada categoria
indica o seu grupo de configurao. No entanto para o processo de inicializao,
importante que antes de entrarmos nos grupos acima, existe uma ordem que deve ser
respeitada. Isso ser visto em um captulo especfico que ir abordar a rotina de
inicializao do display.
Como parte integrante do controlador que o LCD utiliza, h uma tabela de caracteres
pr-programados que esto prontos para uso imediato. Com isso, todo o trabalho de
definir pixel por pixel para os caracteres foi eliminado. Mas h uma desvantagem.
Como a maioria dos LCDs so produzidos na sia, ele vem com um conjunto de
caracteres especficos. A figura a seguir mostra a tabela existente na maioria dos LCDs.
Ela conhecida como ROM Code A00.
Existe outra tabela que tambm encontrada nos LCDs, mas so mais raras. Geralmente
os LCDs mais caros possuem esta opo. Novamente, sempre muito importante ler o
data sheet do seu mdulo de LCD antes de prosseguir com o desenvolvimento do
projeto. A tabela a seguir ilustra os caracteres pertencentes ao ROM Code A02:
Como voc pode reparar, os caracteres acentuados que temos em portugus somente
estaro disponveis nesta verso de ROM. Os LCDs so fornecidos com apenas um
tabela de caracteres.
Para evitar que os mdulos sejam rgidos no que diz respeito a caracteres exibidos,
todos eles possuem uma rea especfica para caracteres criados pelo usurio. Esta
rea chama-se CG RAM e voltil, ou seja, se desligarmos o LCD ou o reiniciarmos,
todas estas informaes sero perdidas. Termos um captulo especfico sobre a
CGRAM.
Os endereos 000 007 so reservados para caracteres criados pelo usurio.
So gravados em memria RAM (CGRAM) e se perdem ao desligar o LCD.
Enviamos para o LCD a condio (0 ou 1) de cada pixel do caracter.
Sero enviados 8 bytes para cada caracter.
Para cri-lo, definimos como ser nosso caracter com base em uma matriz 58:
Cada linha tratada como um byte em separado. Cada ponto preenchido representa 1
e cada ponto apagado representa 0
Pelo fato de um byte ter 8 bits e cada linha apenas 5, os 3 bits mais significativos
sero sempre 0;
Agora, basta escrever os bytes:
Aps ligarmos o LCD e o iniciarmos, o cursor ir para a primeira posio que a 000
(primeira linha x primeira coluna). De acordo com que vamos imputando dados nele, o
cursor ir deslocar para as posies seguintes. Este auto-incremento uma facilidade
muito interessante, pois dispensa especificar cada posio para cada caractere em
separado, economizando (e muito) em linhas de cdigos necessrias.
Mas, e se quisermos escrever em um ponto especfico do LCD?
Neste caso, podemos especificar exatamente qual o endereo que o cursor dever estar
para exibir o caractere desejado. Este dado ser passado para o LCD pelas mesmas vias
de dados que passamos um caractere, s que dessa vez ser um comando. De acordo
com a Tabela, para entrarmos com um comando para setar um endereo na DDRAM do
LCD precisaremos ter o pino RS e RW em nvel lgico baixo e o bit mais significativo
precisa estar obrigatoriamente em nvel lgico alto. Com isso podemos enderear at
128 posies e, ao passar o endereo, deveremos somar este bit, ou seja, precisaremos
somar o valor 080 ao endereo desejado.
Para ilustrar, o endereamento de um display LCD 16X02 o seguinte:
Como devemos, obrigatoriamente fazer com que o bit mais significativo do endereo
seja 1, o valor que devemos passar para o LCD obedece figura abaixo:
Para facilitar as contas, segue abaixo o endereamento para a maioria dos LCDs
comerciais:
Independente do tamanho do LCD existem sempre 80 posies por linha que podem ser
usadas. Como no existem posies suficientes no mostrador do LCD, o texto
rotacionado ou deslocado, tanto para a direita como para a esquerda. Portanto este
processo deve ser feito cuidadosamente para que no haja confuses durante o
endereamento.
O LCD baseado nos controladores HD44780 ou KS0066U possui 8 vias de dados que
so enviado de forma paralela;
Estes LCDs foram construdos para serem compatveis com microntroladores antigos
de 4 bits;
Essa caracterstica nos permite decidir se usaremos o LCD com 4 ou 8 vias de dados;
Lembre-se: os dados continuaro a ter 8 bits, apenas optamos por transmiti-los usando
4 ou 8 vias
Para iniciarmos o LCD no modo de transferncia em 8 bits enviamos o comando:
3 Tranado
4 Carcaa de vidro com a pelcula de eletrodo comum , com sulcos horizontais para
alinhar com o filtro horizontal.
Vamos analisar o cdigo, todo comentado, necessrio para exibir uma mensagem no
LCD, utilizando o PORTD de um PIC16F877a
/************************************* INICIO
************************************/
#include
// microcontrolador utilizado
#fuses xt,nowdt,noprotect,put,brownout,nolvp,nocpd,nowrt // configurao dos fusveis
#use delay(clock=4000000)
#byte porta = 005
#byte portb = 006
#byte portc = 007
#byte portd = 008
// limpa LCD
limpa_lcd();
comando_lcd(0x0c);
comando_lcd(006);
return;
}
// limpa LCD
// display sem cursor
// desloca cursor para a direita
// retorna
// inicializa os ports
porta=000; // limpa porta
portb=000; // limpa portb
portc=000; // limpa portc
portd=000; // limpa portd
porte=000; // limpa porte
inicializa_lcd(); // inicializa o LCD
/************************* Rotina principal **************************/
while(TRUE) // rotina principal
{
//Local onde o programa ser escrito
}
}
Para simplificar o projeto, podemos manter o pino R/W do LCD aterrado, habilitando
assim, apenas o modo de gravao que nos importa;
No poderemos ler o STATUS BIT para saber quando p LCD est pronto para o
prximo dado;
Basta apenas esperar o tempo mnimo para cada funo e executar a prxima;
Isso no uma deficincia do projeto e sim uma caracterstica da maioria dos projetos
comerciais;
Antes de comearmos a programao, precisamos informar quais os pinos de I/O
sero utilizados pelo LCD;
Isso facilitar a portabilidade do projeto para outros PICs ou LCDs
#define lcd_enable pin_e1
#define lcd_rs pin_e0
#define lcd_db4 pin_d4
#define lcd_db5 pin_d5
#define lcd_db6 pin_d6
#define lcd_db7 pin_d7
/*****************************************************************/
/* Envio de Nibble para o LCD */
/*****************************************************************/
//Esta rotina l o Nibble inferior de uma varivel e envia para o LCD.
void envia_nibble_lcd(int dado)
{
//Carrega as vias de dados (pinos) do LCD de acordo com o nibble lido
output_bit(lcd_db4, bit_test(dado,0)); //Carrega DB4 do LCD com o bit DADO
output_bit(lcd_db5, bit_test(dado,1)); //Carrega DB5 do LCD com o bit DADO
output_bit(lcd_db6, bit_test(dado,2)); //Carrega DB6 do LCD com o bit DADO
output_bit(lcd_db7, bit_test(dado,3)); //Carrega DB7 do LCD com o bit DADO
//Gera um pulso de enable
output_high(lcd_enable);
delay_us(1);
output_low(lcd_enable);
return;
}
// ENABLE = 1
// Recomendado para estabilizar o LCD
// ENABLE = 0
// Retorna ao ponto de chamada
/*****************************************************************/
/* Envio de Byte para o LCD */
/*****************************************************************/
//Esta rotina ir enviar um dado ou um comando para o LCD conforme abaixo:
// ENDEREO = 0 -> a varivel DADO ser uma instruo
// ENDEREO = 1 -> a varivel DADO ser um caractere
void envia_byte_lcd(boolean endereco, int dado)
{
output_bit(lcd_rs,endereco);
delay_us(100);
LCD
output_low(lcd_enable);
envia_nibble_lcd(dado>>4);
envia_nibble_lcd(dado & 0x0f);
do
delay_us(40);
return;
}
/*****************************************************************/
/* Funo para limpar o LCD */
/*****************************************************************/
void limpa_lcd()
{
envia_byte_lcd(0,001);
delay_ms(2);
return;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
* Inicializa o LCD * /
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void inicializa_lcd()
{
output_low(lcd_db4);
output_low(lcd_db5);
output_low(lcd_db6);
output_low(lcd_db7);
output_low(lcd_rs);
output_low(lcd_enable);
delay_ms(15);
envia_nibble_lcd(003);
delay_ms(5);
envia_nibble_lcd(002);
o
inicial
delay_ms(1);
envia_byte_lcd(0,028);
bits,
envia_byte_lcd(0,0x0c);
cursor
limpa_lcd();
envia_byte_lcd(0,006);
direita
return;
}
// Limpa o LCD
// ENTRY MODE SET Desloca o cursor para a
// Retorna ao ponto de chamada da funo
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* DEFINIO E INICIALIZAO DOS PORTS *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#byte porta = 005
#byte portb = 006
#byte portc = 007
#byte portd = 008
#byte porte = 009
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
************
* ENVIO DE NIBBLE PARA O LCD *
***********************************************
* * * * * * * * * * * */
//Esta rotina l o Nibble inferior de uma varivel e envia para o LCD.
//1byte = 8 bits = 2 Nibbles
//Sero enviados para os pinos db4, db5, db6, db7 do LCD
void envia_nibble_lcd(int dado)
{
//Carrega as vias de dados (pinos) do LCD de acordo com o nibble lido
output_bit(lcd_db4, bit_test(dado,0));
//Carrega DB4 do LCD com o bit
DADO
output_bit(lcd_db5, bit_test(dado,1));
//Carrega DB5 do LCD com o bit
DADO
output_bit(lcd_db6, bit_test(dado,2));
//Carrega DB6 do LCD com o bit
DADO
output_bit(lcd_db7, bit_test(dado,3));
//Carrega DB7 do LCD com o bit
DADO
//Gera um pulso de enable
output_high(lcd_enable);
// ENABLE = 1delay_us(1);
// Recomendado para estabilizar o
LCD
output_low(lcd_enable);
// ENABLE = 0
return;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
***********
* ENVIO DE BYTE PARA O LCD *
***********************************************
* * * * * * * * * * * */
// Esta rotina ir enviar um dado ou um comando para o LCD conforme abaixo:
// ENDEREO = 0 -> a varivel DADO ser uma instruo
// ENDEREO = 1 -> a varivel DADO ser um caractere
void envia_byte_lcd(boolean endereco, int dado)
{
output_bit(lcd_rs,endereco);
// Seta o bit RS para instruo ou caractere
delay_us(100);
// Aguarda 100 us para estabilizar o pino
do LCD
output_low(lcd_enable);
// Desativa a linha ENABLE
envia_nibble_lcd(dado>>4);
// Envia a parte ALTA do dado/comando
envia_nibble_lcd(dado & 0x0f);
// Limpa a parte ALTA e envia a parte
BAIXA do
//dado/comando
delay_us(40);
// Aguarda 40us para estabilizar o LCD
return;
// Retorna ao ponto de chamada da funo
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
** * * * * * * ** * *
* ENVIO DE CARACTER PARA O LCD *
***********************************************
***********/
// Esta rotina serve apenas como uma forma mais fcil de escrever um caractere no
display.
void escreve_lcd(char c)
{
envia_byte_lcd(1,c);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
* * * * * * ** * *
* FUNO PARA LIMPAR O LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **
* * * * * * ** * * /
// Como esta operao pode ser muito utilizada, transformando-a em funo
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
************
* INICIALIZA O LCD *
***********************************************
***********/
void inicializa_lcd()
{
output_low(lcd_db4);
output_low(lcd_db5);
output_low(lcd_db6);
output_low(lcd_db7);
output_low(lcd_rs);
output_low(lcd_enable);
(low)
delay_ms(15);
envia_nibble_lcd(002);
zerar o
inicial (080)
delay_ms(1);
envia_byte_lcd(0,020);
tabela
envia_byte_lcd(0,0x0C);
sem cursor
tabela
limpa_lcd();
envia_byte_lcd(0,006);
posio
// Limpa o LCD
// ENTRY MODE SET A cada caracter, incrementa uma
// 0 envio de instruo 006 mostrar
tabela
return;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
************
* CONFIGURAES DO PIC *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * *
************/
main()
{
// Reseta portas
porta = 0;
portb = 0;
portc = 0;
portd = 0;
porte = 0;
// configura os tris
set_tris_a(0xFF);
set_tris_b(0xFF);
set_tris_c(0xFF);
set_tris_d(0xFF);
set_tris_e(0xFF);
// Inicializa o LCD
inicializa_lcd();
//Escreve tela
escreve_lcd(O);
escreve_lcd(L);
escreve_lcd(A);
escreve_lcd();
escreve_lcd(M);
escreve_lcd(U);
escreve_lcd(N);
escreve_lcd(D);
escreve_lcd(O);
escreve_lcd(!);
//printf(escreve_lcd,");
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
************
* ROTINA PRINCIPAL *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * *
************/
// Como no h outra execuo, a rotina principal fica vazia
while (true)
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
************
* FIM DO PROGRAMA
***********************************************
* * * * * ***/
}
Normalmente a utilizao do Display LCD apenas uma das funes de uma aplicao prtica, por este motivo, podemos criar uma
biblioteca contendo todas as funes de controle do LCD em um arquivo separado do programa principal. E esta biblioteca ser
chamada por cada um dos muitos projetos futuros que sero realizados e que utilizem Displays LCD sem a necessidade de reescrev-lo
a cada vez.
Para isso criamos um arquivo no bloco de notas ou em qualquer editor de texto e salvamos com o nome de LCD.h. Este arquivo dever
ser salvo na mesma pasta onde se encontra o programa principal do seu projeto, no qual dever ser includa uma linha de comando que
inclua todas as funes desta biblioteca e as tornem disponveis no programa principal.
Exemplo de declarao da biblioteca LCD.h no programa principal:
#include
#fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT,NOLVP,NOCPD,NOWRT
#use delay(clock=4000000)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* CONSTANTES INTERNAS *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Estas so as definies dos pinos que o LCD utiliza.
// Definem quais pinos do PIC controlaro os pinos do LCD
#define lcd_enable pin_d1
#INCLUDE
//Continuao do programa.
Abaixo mostrado todo o contedo do arquivo lcd.h, incluindo novas funes que foram includas a pedido dos leitores do Blog e que
sero explicadas no prprio cdigo.
Conteudo do arquivo lcd.h:
/***************************************************************************/
/* Rotinas para o LCD */
/***************************************************************************/
//Este o bloco com as rotinas necessrias para manipular o LCD
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Envio de Nibble para o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//Esta rotina l o Nibble inferior de uma varivel e envia para o LCD.
void envia_nibble_lcd(int dado)
{
//Carrega as vias de dados (pinos) do LCD de acordo com o nibble lido
output_bit(lcd_db4, bit_test(dado,0));
output_bit(lcd_db5, bit_test(dado,1));
output_bit(lcd_db6, bit_test(dado,2));
output_bit(lcd_db7, bit_test(dado,3));
// ENABLE = 1
// Recomendado para estabilizar o LCD
// ENABLE = 0
// Retorna ao ponto de chamada da funo
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Envio de Byte para o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//Esta rotina ir enviar um dado ou um comando para o LCD conforme abaixo:
// ENDEREO = 0 -> a varivel DADO ser uma instruo
// ENDEREO = 1 -> a varivel DADO ser um caractere
void envia_byte_lcd(boolean endereco, int dado)
{
output_bit(lcd_rs,endereco);
delay_us(100);
output_low(lcd_enable);
envia_nibble_lcd(dado>>4);
delay_us(40);
return;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Envio de caractere para o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Esta rotina serve apenas como uma forma mais fcil de escrever um caractere
// no display. Ela pode ser eliminada e ao invs dela usaremos diretamente a
// funo envia_byte_lcd(1,"); ou
// envia_byte_lcd(1,<cdigo do caractere a ser mostrado no LCD>);
void escreve_lcd(char c)
// envia caractere para o display
{
envia_byte_lcd(1,c);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Funo para limpar o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Como esta operao pode ser muito utilizada, transformando-a em funo
// faz com que o cdigo compilado seja menor.
void limpa_lcd()
{
envia_byte_lcd(0,001);
delay_ms(2);
return;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Inicializa o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void inicializa_lcd()
{
output_low(lcd_db4);
output_low(lcd_db5);
output_low(lcd_db6);
output_low(lcd_db7);
// Garante
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Define inicio da escrita *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//Esta funo foi adicionada e serve para se definir em que posio do LCD deseja-se
}
if(linha == 2)
{
posicao=0xc0;
}
posicao=posicao+coluna;
posicao;
envia_byte_lcd(0,posicao);
return;
}
/***************************************************************************/
/* Final das rotinas para o LCD */
/***************************************************************************/
#INCLUDE
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* DEFINIO E INICIALIZAO DOS PORTS *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#byte porta = 005
#byte portb = 006
set_tris_b(0xFF);
set_tris_c(0xFF);
set_tris_d(0xFF);
set_tris_e(0xFF);
// Inicializa o LCD
inicializa_lcd();
//Limpa a tela do LCD
limpa_lcd();
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* ROTINA PRINCIPAL *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * /
while (true)
{
caracter_inicio(1,6);
printf(escreve_lcd,O BLOG);
caracter_inicio(2,4);
//escreve no LCD
printf(escreve_lcd,DO MARCELO);
//escreve no LCD
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* FIM DO PROGRAMA
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ***/
}
O objetivo desta aula criar uma interface Serial para controlar um display
LCD 16x2, compatvel com HD44780. Os LCDs compatveis com
processadores HD44780 trabalham com um bus de dados paralelo (interfaces
entre dispositivos externos de 4 ou 8 bits). Mas atualmente voc pode comprar
displays LCD que utilizam comunicao Serial. Isso possvel, pois algumas
empresas adaptam uma plaquinha contendo um microcontrolador PIC ou
quaisquer outros, para torn-los seriais. A maioria desses displays seriais usam
um microcontrolador PIC 16F627 ou 16F628 de 18 pinos, mais que suficiente
para interfacear um display LCD configurado para trabalhar com um Bus de
dado de 4 bits. Como estamos usando a verso free do compilador da CCS,
iremos criar nosso driver para tornar um LCD serial, um PIC 16F877 (a maioria
dos pinos no sero usados), portanto, o ideal seria usar um microcontrolador
pequeno, para tornar o circuito compacto e menos dispendioso.
As vantagens de se criar um dirver e tornar um display bus serial, so:
Usa somente um fio para fazer a comunicao com o LCD;
Facilidade em escrever dados no display LCD;
Facilidade em desenvolver circuitos microcontrolados usando LCD;
Produtividade no desenvolvimento de projetos baseados em LCD.
Figura 1 - Display LCD 16x2 com backlight
Pino
Descrio
1 VSS -Terra/GND (Alimentao 0v).
2 VDD - (Alimentao +5v ).
3 VO - Tenso para ajuste do contraste.
RS - (Register Select) Seleciona
4 Dado/Comando.
5 leitura/escrita.
6
7
8
9
10
11
12
13
14
15
16
Barramento de dados.
D5
D6
D7
LED+ Alimentao (Anodo Backlight).
LED- Alimentao (Catodo Backlight).
Controle do
display
0 0 0 0
Move o cursor
0
ou texto
0 0 0 1
INSTRUO
R R/ D D D D
S W 7 6 5 4
Configurao
do LCD
0 0 1
D
L
Posiciona na
memria
1 A A A
Leitura do
Flag Busy
F C C C
Escreve na
memria
D D D D
L dado na
memria
D D D D
Observe no fluxograma acima que aps ligar o mdulo LCD, espera-se por
mais de 30ms antes de se enviar os comandos de controle. Isso necessrio
para que a tenso no mdulo LCD estabilize.
Veja abaixo a seqncia detalhada para inicializar o mdulo LCD:
a) Ligar o LCD;
b) Aguardar 30ms;
c) Habilitar o envio de comandos (RS=0);
d) Colocar o byte comando/dados na via de dados (DB7...DB0);
e) Fazer com que o pino 6 (E) do LCD v a nvel 0 (zero);
f) Aguardar uns 20ms;
g) Fazer com que o pino 6 (E) do LCD v a nvel 1 (um);
h) Aguardar uns 20ms.
Para escrever um byte de COMANDO no display LCD, proceda conforme a
seqncia abaixo:
a) RS=0, R/W=0, E=0
b) Einvia-se o byte de comando na via
(DB7...DB0)
c) RS=0, R/W=0, E=1
d) RS=0, R/W=0, E=0
{
output_high( LCD_PIN_RS ); //RS em 1 - DADO.
delay_us(50);
}
//--------------------------------------------------------------------------//Escreve 8 bits de dados no modo 4 bits no LCD.
//--------------------------------------------------------------------------void LCD_Escreve_Modo_4_bits(int ByteValor)
{
//===> 20Mhz usar delay de 20us.
//===> 4Mhz usar delay de 2us.
//Envia o nibble mais significante (MSB) para o LCD.
output_bit(LCD_DADO_7, bit_test(ByteValor, 7) );
output_bit(LCD_DADO_6, bit_test(ByteValor, 6) );
output_bit(LCD_DADO_5, bit_test(ByteValor, 5) );
output_bit(LCD_DADO_4, bit_test(ByteValor, 4) );
delay_us(2);
output_high( LCD_PIN_ENABLE );
delay_us(2);
output_low( LCD_PIN_ENABLE ); //Clock.
delay_us(2);
//Envia o nibble menos significante (LSB) para o LCD.
output_bit(LCD_DADO_7, bit_test(ByteValor, 3) );
output_bit(LCD_DADO_6, bit_test(ByteValor, 2) );
output_bit(LCD_DADO_5, bit_test(ByteValor, 1) );
output_bit(LCD_DADO_4, bit_test(ByteValor, 0) );
delay_us(2);
output_high( LCD_PIN_ENABLE );
delay_us(2);
output_low( LCD_PIN_ENABLE ); //Clock.
}
//--------------------------------------------------------------------------//Envia um caracter para o LCD.
//--------------------------------------------------------------------------void LCD_EnviaChar(char carac)
{
LCD_Escreve_Modo_4_bits(carac);
}
//--------------------------------------------------------------------------//Envia uma string de caracteres para o LCD.
//--------------------------------------------------------------------------void LCD_EnviaString(char *Str) //Envia um texto para o LCD.
{
LCD_Modo_Dado();
while(*Str) //Loop enquanto no for 'encontrado '\0' (final da string).
LCD_EnviaChar(*Str++); //Envia caracter a caracter para o display LCD.
}
//--------------------------------------------------------------------------//Posisiona o cursor na na coluna X linha do LCD.
//--------------------------------------------------------------------------void LCD_Gotoxy(int colunaX, int LinhaY) //Posiciona na coluna e linha do
display de LCD.
{
LCD_Modo_Comando();
if(LinhaY < 2) //se for a linha 1.
LCD_EnviaChar(LCD_LINHA_1+colunaX); //Endereo de memria da 1a.
linha do LCD (0x80).
else //se no 2a linha.
LCD_EnviaChar(LCD_LINHA_2+colunaX); //Endereo de memria da 2a.
linha do LCD (0xC0).
LCD_Modo_Dado(); //Volta ao modo Dado.
}
//--------------------------------------------------------------------------//Envia uma string no centro da linha do LCD.
//--------------------------------------------------------------------------void LCD_StringCentro(char *Texto, int LinhaY)
{
int Metade;
Metade = strlen(Texto) / 2; //Acha a metade do texto.
LCD_Gotoxy(8-Metade, LinhaY); //Centraliza. O 8 o centro da tela do
display (16 Div. 2).
LCD_EnviaString(Texto);
}
//--------------------------------------------------------------------------//Limpa o LCD.
//--------------------------------------------------------------------------void LCD_LimpaDisplay(void) //Limpa o display e a memria do LCD
posicionando na primeira linha.
{
LCD_Modo_Comando(); //Pe no modo Comando.
LCD_EnviaChar(LCD_LIMPA_DISPLAY); //Limpa o display.
LCD_Modo_Dado(); //Volta ao modo Dado.
}
//------------------------------------------------------------------------------//Pe o curso na posio superior esquerda do display.
//------------------------------------------------------------------------------void LCD_CursorHome(void) //Limpa o display e a memria do LCD
posicionando na primeira linha.
{
LCD_Modo_Comando(); //Pe no modo Comando.
LCD_EnviaChar(LCD_CURSOR_HOME); //Pe o curso na posio superior
esquerda do display.
LCD_Modo_Dado(); //Volta ao modo Dado.
}
//--------------------------------------------------------------------------//Muda o tipo de cursor do LCD.
//--------------------------------------------------------------------------void LCD_TrocaCursor(int Tipo) //Muda o tipo de cursor do display do LCD.
{
LCD_Modo_Comando(); //Pe no modo Comando.
LCD_EnviaChar(Tipo); //Muda o tipo de cursor.
LCD_Modo_Dado(); //Volta ao modo Dado.
}
//-------------------------------------------------------------------------------------------//Pisca uma string na linha/coluna do LCD, definindo um intervalo.
//-------------------------------------------------------------------------------------------void LCD_PiscaString(int ColunaX, int LinhaY, char *String, int Vezes)
{
char Apaga[16]; //para armazenar 16 espaos.
int Conta=0;
int TamaString;
TamaString = strlen(String); //acha o tamanho do texto.
O driver acima foi escrito para simplificar a programao com LCDs, deve
ser usado quando formos criar um novo programa fonte. Use a diretiva #include
<DriverLCD.c> para incluir o driver ao seu novo programa fonte.
pois um recuso a mais para eliminao de erros. Se for remover esta funo,
elimine tambm o LED1 do circuito,, pois este no ter mais utilidade.
Figura 3 - Circuito que torna um display comum, em um display com interface Serial
C++
C++
O programa acima tambm foi criado para ser usado com o circuito
da Figura 3. Seu objetivo criar novos caracteres para ser gravado na
memria CGRAM.
Ao clicar com o mouse na rea de desenho do caractere, os valores
correspondentes a cada linha do caracter so gerados e atribudos
matriz char linha[8]. Esse cdigo pode ser copiado e usado como modelo no
seu programa fonte, para gravar um novo caracter na CGRAM. Veja no
programa, que tambm possvel mudar o nome da matiz, inverter os pixels do
caracter, limpar o LCD, apagar a rea de desenho e o contedo da CGRAM no
LCD.
Um recurso bastante interessante neste programa a opo "Desenha em
tempo real". Se esta opo for marcada os pixels plotados na rea de desenho
sero automaticamente plotados tambm na tela do display LCD.
Esse programa s desenha em um nico endereo da memria CGRAM.
Este endereo o 40(em hexadecimal) referente a posio do caracter de
cdigo ASCII (0).