Apostila 01

1
Engenharia Elétrica
6º / 7° Semestre
ELETRÔNICA DIGITAL – APOSTILA 01

Prof Daniel Hasse
Displays de Cristal Líquido

Comunicação a quatro vias entre LCD e Microcontroladores
Conversão Analógica - Digital em Microcontroladores
SÃO JOSÉ DOS CAMPOS, SP

ÍNDICE
ÍNDICE..........................................................................................................................................................................2
INTRODUÇÃO..............................................................................................................................................................5
Capítulo 1 - O LCD ALFA-NUMÉRICO ........................................................................................................................9
Figura 1: Display 08X02 sem back-light.........................................................................................................9
Figura 2: Display 16X01 sem back-light.........................................................................................................9
Figura 3: Display 16X02 com back-light.........................................................................................................9
Figura 4: Display 16X04 com back-light.......................................................................................................10
Figura 5: Display 20X01 sem back-light.......................................................................................................10
Figura 6: Display 20X02 sem back-light.......................................................................................................10
Figura 7: Display 20X04 com back-light.......................................................................................................10
Parte 1 - Os caracteres .......................................................................................................................................11
Figura 8: O padrão de cada célula de um display 5X7 (em mm).................................................................11
Parte 2 - Conexões..............................................................................................................................................12
Tabela 1: Descrição das funções dos pinos do LCD ...................................................................................12
Figura 9: Controle de contraste de um LCD ................................................................................................13
Parte 3 - Comandos do LCD ...............................................................................................................................14
Figura 10: LCD 16X02 energizado, mas não inicializado. ...........................................................................14
Tabela 2: Instruções para inicialização e configuração do LCD ..................................................................14
Tabela 3: Configurações possíveis para o LCD ..........................................................................................15
Parte 4 - Tabelas de Caracteres .........................................................................................................................17
Tabela 4: Os caracteres do ROM Code A00 ...............................................................................................17
Tabela 5: Os caracteres do ROM Code A02 ...............................................................................................18
Parte 5 - Endereçamento ....................................................................................................................................19
Figura 11: Endereçamento direto para um LCD 16X02...............................................................................19
Figura 12: Endereçamento com deslocamento para um LCD 16X02 .........................................................19
Figura 13: Endereçamentos com deslocamento para diversos LCDs.........................................................20
Parte 6 - Rotacionando o LCD ............................................................................................................................20
Parte 7 - A CGRAM – Caracteres definidos pelo usuário ...................................................................................20
Figura 14: O modelo do caractere na CG RAM...........................................................................................21
Figura 15: Criando um robô na CG RAM.....................................................................................................21
Figura 16: O robô, traduzido em bits............................................................................................................21
Parte 8 - Transferência em 8 bits ........................................................................................................................23
Figura 17: Inicializando em 8 vias................................................................................................................23
Parte 9 - Transferência em 4 bits ........................................................................................................................24
Figura 18: Inicializando em 4 vias................................................................................................................25
Parte 10 - Timing .................................................................................................................................................26
Figura 19: Diagrama de temporização para o LCD .....................................................................................26
6: Diagrama de temporização real para o LCD............................................................................................27
Capítulo 2 - O HARDWARE .......................................................................................................................................31
Figura 20: Esquemático para a placa de testes de LCD .............................................................................31
Figura 21: PCI lado dos componentes.........................................................................................................32
Figura 22: PCI lado da solda (trilhas)...........................................................................................................32
Figura 23: Placa de testes conectada ao McPlus via conector ICSP..........................................................32
Capítulo 3 - O SOFTWARE ........................................................................................................................................35
Parte 1 – Comunicação em 8 vias pela McLAB2 ................................................................................................35
Parte 2 – Comunicação em 4 vias pela McLAB2 ................................................................................................38
Definição de constantes ...............................................................................................................................38
Rotina de envio de um “nibble” ....................................................................................................................38
Rotina de envio de um Byte .........................................................................................................................39
Função para Limpar o LCD..........................................................................................................................39
Inicialização do LCD.....................................................................................................................................40
Parte 3 – Comunicação em 4 vias pela placa de testes .....................................................................................42
Definição de constantes ...............................................................................................................................42
Outras alterações .........................................................................................................................................42
Exercício 1 – Inicializando o LCD e “Olá Mundo”.......................................................................................................45
McLAB2 ...............................................................................................................................................................45
Figura 24: Fluxograma para a placa McLAB2 .............................................................................................45
Placa de testes ....................................................................................................................................................50
Figura 25: Fluxograma para a placa de testes ............................................................................................50
Exercício 2 – A função PRINTF() ...............................................................................................................................57
McLAB2 ...............................................................................................................................................................58
Tutorial LCD em 4 vias 2
Figura 26: Fluxograma para a placa McLAB2 .............................................................................................58
Placa de testes ....................................................................................................................................................63
Figura 27: Fluxograma para a placa de testes ............................................................................................63
Exercício 3 – Rotacionando o display ........................................................................................................................71
McLAB2 ...............................................................................................................................................................72
Placa de testes ....................................................................................................................................................76
Exercício 4 – Criando caracteres................................................................................................................................83
Figura 28: Fluxograma para o exemplo 4 ....................................................................................................83
McLAB2 ...............................................................................................................................................................84
Placa de testes ....................................................................................................................................................89
Exercício 5 – Uma pequena animação.......................................................................................................................97
Figura 29: Fluxograma para a animação nas placas McLAB2 e de testes .................................................97
McLAB2 ...............................................................................................................................................................98
Placa de testes ..................................................................................................................................................103
CONSIDERAÇÕES FINAIS......................................................................................................................................111

INTRODUÇÃO
A idéia deste material é realizar a conexão de um LCD paralelo que utiliza o processador
Hitachi HD44780 ou KS0066U a um microcontrolador PIC, utilizando apenas 4 vias de dados.
Devido à sua simplicidade, estes LCDs não são avançados e não possuem recursos como
gerenciamento automático de pixels, não são coloridos (full color), não possuem iluminação
ativa entre outras limitações, mas ainda são largamente utilizados na indústria. Basta ver que
muitas registradoras, equipamentos hand-held, sistemas de informação de computadores
servidores entre outros, ainda utilizam largamente este dispositivo.
Os testes foram executados em uma placa Mosaico McLAB2 e em uma placa
confeccionada para esta finalidade. Os diagramas para esta placa encontram-se no capítulo
referente ao hardware.
Este material foi desenvolvido utilizando o MPLAB 7.21 e o compilador PCWH 3.168
(versão gratuita).
Estes procedimentos também foram testados em Assembly, mas está fora do escopo
deste trabalho. Para programação e gravação do microcontrolador existente nas placas utilizei
o McPLUS (também da Mosaico). Isto garantiu uma perfeita integração ao MPLAB e às
características de gravação “in circuit” (ICSP).
Os PICs testados foram o PIC16F628A, PIC16F877A e o PIC18F452.

Capítulo 1 – O LCD Alfa-numérico

Capítulo 1 - O LCD ALFA-NUMÉRICO
Existem, comercialmente, diversos tipos e tamanhos de LCD alfanuméricos que podem
ser incorporados a um microcontrolador PIC. Os mais comuns são os gerenciados por um
processador Hitachi HD44780. Apesar de ter sido descontinuado, ainda é o mais comumente
encontrado, assim como os equivalentes de outros fabricantes. Maiores detalhes sobre este
processador podem ser encontrados no data sheet do fabricante. Veja no link
http://cn.renesas.com/media/products/lcd/discontinued_products/d_e780u.pdf .
Os displays são fornecidos em diversos formatos e tamanhos e são sempre
especificados em número de caracteres exibidos, no formato de colunas e linhas, sendo os
mais comuns os 08x02 (oito colunas por duas linhas), 16X01 (16 colunas por 1 linha), 16X02
(16 colunas por 2 linhas), 16X04 (16 colunas por 4 linhas), 20X01 (20 colunas por 1 linha),
20X02 (20 colunas por 2 linhas) e 20X04 (20 colunas por 4 linhas).
Estes são alguns exemplos:
Figura 1: Display 08X02 sem back-light
Figura 3: Display 16X02 com back-light

Alguns módulos possuem iluminação em "back-light" e estão disponíveis nas cores

(monocromáticas) azul, âmbar, verde entre outras. Mas, no fundo, todos eles são compatíveis e
podem ser controlados pelo PIC exatamente da mesma maneira. Isto é importante para que,
no futuro, uma rotina desenvolvida para um LCD 16X02 possa ser utilizada para controlar um
LCD 20X04 sem a necessidade de alteração de código.

Parte 1 - Os caracteres
Basicamente, cada "célula" (caractere) do LCD é composto de 8 pixels na horizontal e

de 5 pixels na vertical, ou seja, cada "célula" é representada da seguinte forma (todas as
medidas são em mm):
Figura 8: O padrão de cada célula de um display 5X7 (em mm)
Estes caracteres são conhecidos como 5X7, uma vez que a linha inferior é normalmente
reservada para o cursor. Existem também displays que possuem 11 pixels de altura. Os
caracteres deste LCD são conhecidos como 5X10 e tem a vantagem de que não existe a
distância entre a primeira e a segunda linha. Os caracteres podem parecer contíguos.

Parte 2 - Conexões
Basicamente os LCDs alfa numéricos seguem um padrão de especificação de interface,

onde estão presentes 14 pinos de acesso (para os LCDs sem iluminação em "back-light") ou 16
pinos (para os que possuem iluminação em "back-light"). Na verdade, estes pinos são “pads”
soldáveis para a inserção de conectores IDC e são classificados em 8 pinos para controle de
dados, três linhas de controle e três linhas de alimentação. Iremos detalhar cada um a seguir.
As conexões estão dispostas em 1 linha de 14 (ou 16) pinos lado a lado, onde podemos utilizar
uma barra de pinos SIL ou em duas linhas de 7 (ou 8) pinos, onde nos valeremos de um
conector DIL. Na figura 1 podemos ver um exemplo de conector DIL e na figura 2 o exemplo
mostra um display com conexão SIL.
Na maioria dos displays, a pinagem está impressa e torna mais fácil a identificação de
cada um. Mas, nos casos onde não há identificação impressa, lembre-se que o pino 1 é
sempre o terra e deve possuir uma trilha mais larga ou estar aterrado na carcaça em algum
ponto da trilha.
A função de cada pino é resumida de acordo com a tabela abaixo:
Pino Nome Função
1 Vss Terra
2 Vdd Positivo (normalmente 5V)
3 Vo Contraste do LCD. Às vezes também é chamado de Vee
4 RS Register Select
5 R/W Read/Write
6 E Enable
7 D0 Bit 0 do dado a ser escrito no LCD (ou lido dele).
15 A Anodo do back-light (se existir back-light).
16 K Catodo do back-light (se existir back-light).
Tabela 1: Descrição das funções dos pinos do LCD
Apesar dos LCDs serem projetados para trabalharem com 5V, consumindo apenas
alguns miliampéres, tensões entre 4,5V e 6V funcionam perfeitamente. Alguns módulos
também funcionam com 3V. Por isso, o mais indicado é sempre ler o data sheet do LCD que
você possui para saber melhor seus recursos e limitações. Por estas razões é que o LCD pode
ser utilizado, sem problemas, em equipamentos alimentados por pilhas e baterias. O consumo
deles é bem menor que o de um simples LED!
Como já dito antes, o pino 1 (Vss) é o terra do módulo LCD e pode ser ligado juntamente
com o pino Vss do PIC.
O Pino 2 (Vdd) é o positivo e deve ser ligado juntamente com o Vdd do PIC
O pino 3 (Vo) é onde controlamos o contraste do LCD, ou seja, onde controlamos se o
que irá aparecer no LCD será "escuro" ou "claro". Para isso devemos ligá-lo a um
potenciômetro ou trim-pot de 10KR conectado ao Vss e Vdd (atuando como um divisor de
tensão) de acordo com o esquemático a seguir:

Figura 9: Controle de contraste de um LCD
O pino 4 (RS) é o Seletor de Registros. Resumindo, quando este pino está em nível
lógico baixo (0), os dados enviados para o LCD são tratados como comandos e os dados lidos
do LCD indicam o seu estado atual (status). Quando este pino está em nível lógico alto (1), os
dados são tratados como caracteres, tanto para leitura como para escrita.
Para indicar se os dados serão lidos ou escritos no LCD, existe o pino 5 (R/W) que
controla exatamente se a operação em andamento será de leitura (quando estivem em nível
lógico alto - 1) ou gravação (quando estiver em nível lógico baixo - 0).
O pino 6 (E) é a linha de habilitação para os comandos do LCD. É utilizado para iniciar a
transferência de comandos ou caracteres entre o módulo e as linhas de dados. Quando estiver
escrevendo para o display, os dados serão transmitidos apenas a partir de uma transição de
high para low (H -> L) deste sinal. No entanto, para ler informações do display, as informações
estarão disponíveis imediatamente após uma transição L -> H e permanecerá lá até que o sinal
volte para o nível lógico baixo (0) novamente.
Os pinos 7 a 14 fazem parte do barramentos de dados. 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 memória. A decisão de utilizar 8 vias ou 4 vias
é exclusiva do desenvolvedor do projeto.

Parte 3 - Comandos do LCD
Ao ligar o LCD na alimentação, a primeira linha fica toda preenchida (veja foto abaixo).
Para que ele fique operacional, precisamos inicializá-lo, passando diversas informações de
configuração. Para isso, existem alguns parâmetros que precisam ser definidos. A tabela 2 a
seguir mostra quais são estes comandos.
Figura 10: LCD 16X02 energizado, mas não inicializado.
Ciclos
Instrução RS RW D7 D6 D5 D4 D3 D2 D1 D0 Descrição de
Clock
NOP 0 0 0 0 0 0 0 0 0 0 Sem efeito 0
Limpa o display e seta contador de

Clear Display 0 0 0 0 0 0 0 0 0 1 endereço para zero.
165
Seta contador de endereço para
zero, retorna o cursor para a
Cursor Home 0 0 0 0 0 0 0 0 1 x posição original. 3
O conteúdo da DD RAM permanece
inalterado.
Seta a direção do movimento do
Entry Mode
0 0 0 0 0 0 0 1 I/D S cursor (I/D) e especifica 3
Set deslocamento automático (S).
Display Liga e desliga o Display (D), cursor
0 0 0 0 0 0 1 D C B (C) e ativa cursor piscante, (B).
3
Control
Cursor / Desloca o display ou move o cursor
0 0 0 0 0 1 S/C R/L x x (S/C) e especifica a direção (R/L).
3
Display shift
Seta número de bits para
Function Set 0 0 0 0 1 DL N F x x comunicação (DL), número de linhas 3
(N) e tamanho da fonte (F).
Set CGRAM Seta o endereço da CGRAM. O
0 0 0 1 Endereço CGRAM dado (endereço) é enviado junto.
3
Address
Set DDRAM Seta o endereço da DDRAM. O
0 0 1 Endereço DDRAM dado (endereço) é enviado junto. 3
Address
Busy Flag & Flag do Read busy (BF) e contador
0 1 BF Address Counter (Contador de Endereço) de endereços.
0
Address
Escreve dados na DDRAM ou na
Write Data 1 0 Dado CGRAM
3
Read Data 1 1 Dado Lê dados da DDRAM ou da CGRAM 3
x : Sem 1 Incrementa 1 Deslocamento para a direita

I/D R/L
importância 0 Decrementa 0 Deslocamento para a esquerda
1 Deslocamento automático do display 1 Interface de 8 bits
S DL
0 0 Interface de 4 bits
1 Display ON (ligado) 1 2 linhas
D N
0 Display OFF (desligado) 0 1 linha
1 Cursor ON (ligado) 1 Caracteres 5x10
C F
0 Cursor OFF (desligado) 0 Caracteres 5x7
1 Cursor piscando
B
0 DDRAM : Display Data RAM
1 Deslocamento do display CGRAM : Character Generator RAM
S/C
0 Movimento do Cursor
Tabela 2: Instruções para inicialização e configuração do LCD

Baseados na tabela anterior verificamos que existem diversas configurações que podem
ser atribuídas ao LCD. A tabela a seguir mostra as opções disponíveis.
Tabela 3: Configurações possíveis para o LCD

Lembre-se que, antes de qualquer operação com o LCD ele precisa ser inicializado
utilizando estas informações da Tabela 3. É importante salientar que não existe uma ordem
específica para os itens de configuração especificados acima. Eles podem ser enviados em
qualquer ordem, uma vez que o bit mais significativo de cada categoria indica o seu grupo de
configuração. No entanto para o processo de inicialização, é importante que antes de
entrarmos nos grupos acima, existe uma ordem que deve ser respeitada. Isso será visto em um
capítulo específico que irá abordar a rotina de inicialização do display.

Parte 4 - Tabelas de Caracteres
Como parte integrante do controlador que o LCD utiliza, há uma tabela de caracteres
pré-programados que estão 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 são produzidos na Ásia, ele vem com um conjunto de caracteres específicos. A figura a
seguir mostra a tabela existente na maioria dos LCDs. Ela é conhecida como ROM Code A00.
Tabela 4: Os caracteres do ROM Code A00

Existe outra tabela que também é encontrada nos LCDs, mas são mais raras.
Geralmente os LCDs mais caros possuem esta opção. Novamente, é sempre muito importante
ler o data sheet do seu módulo de LCD antes de prosseguir com o desenvolvimento do projeto.
A tabela a seguir ilustra os caracteres pertencentes ao ROM Code A02:
Tabela 5: Os caracteres do ROM Code A02

Como você pode reparar, os caracteres acentuados que temos em português somente
estarão disponíveis nesta versão de ROM. Os LCDs são fornecidos com apenas um tabela de
caracteres.
Para evitar que os módulos sejam “rígidos” no que diz respeito a caracteres exibidos,
todos eles possuem uma área específica para caracteres criados pelo usuário. Esta área

chama-se CG RAM e é volátil, ou seja, se desligarmos o LCD ou o reiniciarmos, todas estas
informações serão perdidas. Termos um capítulo específico sobre a CGRAM.
Parte 5 - Endereçamento
Após ligarmos o LCD e o iniciarmos, o cursor irá para a primeira posição que é a 0x00
(primeira linha x primeira coluna). De acordo com que vamos inputando dados nele, o cursor irá
deslocar para as posições seguintes. Este auto-incremento é uma facilidade muito
interessante, pois dispensa especificar cada posição para cada caractere em separado,
economizando (e muito) em linhas de códigos necessárias.
fMas, e se quisermos escrever em um ponto específico do LCD?
Neste caso, podemos especificar exatamente qual é o endereço 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 2, para entrarmos com um comando para setar um endereço na DDRAM do LCD
precisaremos ter o pino RS e RW em nível lógico baixo e o bit mais significativo precisa estar
obrigatoriamente em nível lógico alto. Com isso podemos endereçar até 128 posições e, ao
passar o endereço, deveremos somar este bit, ou seja, precisaremos somar o valor 0x80 ao
endereço desejado.
Para ilustrar, o endereçamento de um display LCD 16X02 é o seguinte:
Figura 11: Endereçamento direto para um LCD 16X02
Como devemos, obrigatoriamente fazer com que o bit mais significativo do endereço
seja 1, o valor que devemos passar para o LCD obedece à figura abaixo:
Figura 12: Endereçamento com deslocamento para um LCD 16X02

Para facilitar as contas, segue abaixo o endereçamento para a maioria dos LCDs
comerciais:
Figura 13: Endereçamentos com deslocamento para diversos LCDs
Parte 6 - Rotacionando o LCD
Independente do tamanho do LCD existem sempre 80 posições por linha que podem ser
usadas. Como não existem posições 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 não haja confusões durante o endereçamento.
Este modo também será estudado durante os exercícios.
Parte 7 - A CGRAM – Caracteres definidos pelo usuário
Os endereços 00000000 a 00000111 (0x00 a 0x07) são reservados para os caracteres

criados pelo usuário. Temos, portanto, oito caracteres programáveis. Esta programação é
realizada apontando para o endereço da CG RAM (character Generator RAM) onde desejamos
armazenar o caractere. Os próximos 8 bytes enviados para a RAM representam cada linha do
caractere, iniciando pelo top.
Ficou confuso? Então vamos explicar melhor. Como já vimos anteriormente, cada
caractere é formado por uma matriz de 8 linhas por 5 colunas, de acordo com a figura abaixo.

Figura 14: O modelo do caractere na CG RAM
Se desejarmos criar um “robozinho”, devemos preencher esta matriz da seguinte forma:
Figura 15: Criando um robô na CG RAM

Durante a programação, cada linha é tratada como um byte em separado. Portanto,
imaginemos que cada linha seja tratada como um arranjo de bits, onde cada ponto preenchido
é representado por 1 e cada ponto “apagado” seja representado por 0. Teremos então a
seguinte configuração: Teremos então a seguinte configuração:
Figura 16: O robô, traduzido em bits

Lembrando que, pelo fato do byte ter 8 bits e o caractere ter apenas 5 bits, os 3 bits
mais significativos serão sempre 0. Agora fica fácil para entendermos que o robô pode ser
traduzido nos seguintes bytes (sempre de cima para baixo): 00001110, 00010001, 00001110,
00000100, 00011111, 00000100, 00001010 e 00010001. Passando para hexadecimal, teremos
que o robozinho é decomposto nos bytes 0x0E, 0X11, 0X0E, 0X04, 0X1F, 0X04, 0X0A e 0X11.
Agora que já vimos como decompor um caractere, vamos aprender a programá-lo na
CGRAM. De acordo com a Tabela 2, precisamos enviar o comando SET CGRAM ADRESS
juntamente com o endereço do caractere inicial que desejamos gravar. Então, para iniciar a
programação pelo primeiro caractere disponível, precisamos enviar o comando 00010000 para
o LCD dizendo para posicionar o ponteiro no primeiro endereço da CGRAM. A seguir
precisaremos enviar os 8 bytes que compões o caractere. Voilá! O nosso robozinho começa a
aparecer na tela e pode ser acessado normalmente pelo endereço 0x00!
Agora, se continuarmos inserindo informações de bytes, automaticamente o ponteiro
passará para o segundo caractere na CG RAM e assim sucessivamente. Então para
programarmos os oitos caracteres, bastaria posicionar na posição inicial (0x00) e passarmos 64
bytes diretamente para o LCD.
Maiores detalhes serão vistos durante os exercícios onde criaremos diversos caracteres
para uso.

Parte 8 - Transferência em 8 bits
O LCD baseado no controlador Hitachi HD44780 ou no controlador KS0066U possuem 8

vias de dados e são conhecidos como LCDs paralelos, pois os dados são enviados
paralelamente ao LCD. Em nosso estudo não detalharemos este processo, visto que o nosso
foco é a comunicação em 4 vias de acesso. Todavia, o código necessário para se comunicar
com o LCD usando todas as vias de dados também é apresentado na seção SOFTWARE.
Para iniciarmos o LCD neste modo, devemos adotar a seguinte seqüência de
comandos:
Figura 17: Inicializando em 8 vias

Parte 9 - Transferência em 4 bits
O controlador HD44780 ou o KS0066U, encontrados na maioria dos módulos de LCDs

alfa-numéricos existentes atualmente foram desenvolvidos para serem 100% compatíveis com
microprocessadores antigos de 4 bits. No entanto esta característica é muito útil quando
precisamos interfacear um microcontrolador.
Muitas vezes, durante o desenvolvimento de um projeto, precisamos ter muito cuidado
com o número de pinos de I/O utilizados, pois normalmente, este é o componente mais caro do
projeto. Por isso precisamos racionar o uso destes pinos. Já pensou você desenvolvendo um
equipamento com um PIC16F628A e ter que migrar para o, por exemplo, PIC16F873A apenas
por que faltaram alguns pinos para ligar um LCD?
Outro ponto diz respeito à miniaturização, pois atualmente um grande diferencial de
cada projeto está neste ponto. Cada vez mais precisamos ter equipamentos que exerçam mais
funções e ocupem cada vez menos espaço. É aqui que reside a grande vantagem de se
comunicar em quatro vias de dados.
Mas como eu vou mandar 1 byte (8 bits) se eu só tenho 4 vias de dados? Uma vez que
o display é posto no modo de 4 vias, basta mandarmos 2 pacotes de 4 bits cada que o display
se encarrega de fazer o resto. Cada pacote de 4 bits é conhecido como “nibble”.
Neste modo, apenas as vias de dados D4 a D7 são utilizadas, e as vias D0 a D3 devem
ser deixadas flutuando (sem conexão alguma) ou conectadas ao positivo da alimentação, via
resistor limitador que tem seu valor entre 4K7 e 47K. Não é aconselhável aterrá-los, a não ser
que o pino R/W também esteja aterrado, prevenindo que os pinos sejam configurados como
saída. Se o pino for configurado erroneamente como saída e os pinos estiverem diretamente
aterrados, os pinos que estiverem com valor lógico 1 poderão se queimar.
Ao energizar o LCD, ele é automaticamente posto no mode de comunicação em 8 vias.
Por isso, precisamos inicializá-lo para que possa operar corretamente. Neste ponto há uma
pegadinha… Como eu faço para inicializar o LCD se ele só possui as vias D4 a D7 e ele está
no modo 8 vias?
Foi pensando neste problema que os projetistas dos controladores determinaram que o
bit que irá configurar o modo 4 vias seria o D4, por isso não precisamos nos preocupar. Basta
enviar um comando com o valor 0b001000000 (0x20) que o LCD entra no modo de 4 vias.
A partir deste momento, todas as informações que serão passadas para o LCD deverão
ser divididas em 2 “nibbles”, sendo que o “nibble” mais significativo deve ser enviado
primeiramente, e o “nibble” menos significativo deverá ser enviado logo em seguida.
Para inicializarmos em 4 bits, devemos adotar a seguinte seqüência de comandos:

Figura 18: Inicializando em 4 vias

Parte 10 - Timing
Antes de passarmos definitivamente para a parte prática deste tutorial, precisamos

conhecer uma limitação dos LCDs: o tempo de sincronização, também conhecido como
TIMING. Independentemente da velocidade em que seu projeto/protótipo opera, existe um
tempo mínimo que o LCD precisa para processar as informações. Se este tempo não for
respeitado, o LCD não funcionará.
A figura abaixo ilustra o gráfico de tempo que o LCD opera
Parâmetro Descrição Tempo

tAS Tempo de set-up do endereço (Address set-up time). Mínimo 140ns
tAH Tempo de retenção do endereço (Address hold time). Mínimo 10ns
tDS Tempo de ajuste do dado (Data set-up time). Mínimo 200ns
tDH Tempo de retenção do dado (Data hold time). Mínimo 20ns
tDA Tempo de acesso ao dado (Data access time). Mínimo 320ns
tEH Tempo para habilitar nível 1(Enable high time time). Mínimo 450ns
tEL Tempo para habilitar nível 0(Enable low time). Mínimo 500ns
tRF Tempo de transição (Rise/Fall time). Mínimo 25ns
Figura 19: Diagrama de temporização para o LCD
Mas cuidado… Este diagrama não conta toda a história. Apesar de o LCD precisar
apenas destes tempos para a execução, diversos flags internos precisam ser setados que,
aliados a outros fatores, tornam o processo de temporização muito maior. A maioria dos
comandos ocupam o LCD por até 40us e outros podem demandar até 3ms para serem
liberados. É exatamente por isso que existe um flag chamado “BUSY” que indica se o display
está pronto para executar outra instrução ou não. A função para esta operação é a READ
STATUS.
Em caso onde não utilizamos o modo de leitura do LCD, podemos nos basear em um
tempo mínimo que cada operação precisa para ser completada. A tabela a seguir ilustra os
tempos necessários.

Instrução Tempo
Limpar ao Display (Clear Display) 82us a 4,1ms
Ir para a posição inicial (display & Cursor Home) 40us a 4,1ms
Entrada de caracteres (Character Entry Mode) 40us
Controles de Display e Cursor (Display On/Off & 40us
Cursor)
Deslocamento do display e do cursor (Display/Cursor 40us
Shift)
Ajustes de funções (Function Set) 40us
Setar endereço da CGRAM (Set CGRAM Address) 40us
Setar endereço do display (Set Display Address) 40us
Escrever dados (Write Data) 40us
Ler dados (Read Data) 40us
Led o estado (Read Status) 1us
6: Diagrama de temporização real para o LCD
Novamente, apesar da tabela acima funcionar em qualquer LCD alfa-numérico, consulte
o data sheet de seu LCD para determinar exatamente quais são os tempos mínimos
necessários.

Capítulo 2 – O Hardware

Capítulo 2 - O HARDWARE
Apesar de este tutorial ter sido desenvolvido para utilização na placa Mosaico McLAB2,
quem não possuir esta placa poderá fazer uma placa para testes. O esquemático para tal placa
de testes é mostrado na figura abaixo. Para testes realizados na placa McLAB2 nenhuma
alteração é necessária.
Figura 20: Esquemático para a placa de testes de LCD

A placa de circuito impresso sugerida é mostrada nas figuras abaixo e tem 2.225” X
1.600” (aproximadamente 56,5mm X 40.6mm).
Figura 21: PCI lado dos componentes Figura 22: PCI lado da solda (trilhas)
O conector ICSP foi dimensionado para utilizar diretamente com os programadores
McFlash e McPlus, evitando assim que o PIC tenha que ser retirado do circuito para ser
programado.
Outro detalhe diz respeito ao regulador de tensão LM7805 que pode ser substituído pelo
78L05, devido ao baixo consumo do circuito.
Todos os componentes estão detalhados tanto no esquemático quanto no desenho da
PCI – Lado dos componentes, são facilmente encontrados no mercado e são de baixo custo.
A foto abaixo mostra a placa conectada diretamente no McPlus.
Como este protótipo não utiliza oscilador ou ressonador externo, apenas o interno
calibrado à 4MHz, utilizou-se o pino CLOCKOUT para realizar aferições para calibragem.
O PIC aqui utilizado foi o 16F628A.
Figura 23: Placa de testes conectada ao McPlus via conector ICSP

Capítulo 3 – O Software

Capítulo 3 - O SOFTWARE
Esta seção será dividida em três partes. A primeira e a segunda serão inteiramente
focadas na McLAB2, onde apresentaremos, na parte 1, o código para comunicação em 8 vias e
em seguida o código necessário para estabelecer a comunicação em 4 bits na parte 2. Todo o
detalhamento é explicitado no próprio código.
Na terceira parte iremos demonstrar a comunicação em 4 bits na placa de testes
apresentada no capítulo anterior. Como não há ligação física das 8 vias de dados nela,
obviamente não iremos demonstrar esta comunicação. Mas será facilmente verificado que o
código detalhado para a McLAB2 será perfeitamente aproveitado com pequenas mudanças.
Parte 1 – Comunicação em 8 vias pela McLAB2
Este é o código necessário para exibir uma mensagem no LCD, utilizando o PORTD do
PIC16F877A da placa McLAB2
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 23/09/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Descrição geral *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Este exemplo foi elaborado para explicar o funcionamento do módulo de LCD.
// Foi utilizado um barramento de 8 vias de comunicação pelo PORTD
#include <16f877A.h> // microcontrolador utilizado

#fuses xt,wdt,noprotect,put,brownout,nolvp,nocpd,nowrt // configuração dos
fusíveis
#use delay(clock=4000000, RESTART_WDT)
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
#byte porta = 0x05
#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08
#byte porte = 0x09
#bit rs = porte.0 // via do LCD que sinaliza recepção de dados ou comando
#bit enable = porte.1 // enable do lcd
/****************** Rotina que envia um COMANDO para o LCD ******************/

void comando_lcd(int caracter)
{
rs = 0; // seleciona o envio de um comando
portd = caracter; // carrega o portd com o caracter
enable = 1 ; // gera pulso no enable
delay_us(1); // espera 3 microssegundos
enable = 0; // desce o pino de enable
delay_us(40); // espera mínimo 40 microssegundos
return; // retorna
}

/************** Rotina que envia um DADO a ser escrito no LCD **************/
void escreve_lcd(int caracter)
{
rs = 1; // seleciona o envio de um comando
portd = caracter; // carrega o portd com o caracter
enable = 1; // gera pulso no enable
enable = 0; // desce o pino de enable
delay_us(40); // espera mínimo 40 microssegundos
return; // retorna
}
/******************** Função para limpar o LCD ********************/

void limpa_lcd()
{
comando_lcd(0x01); // limpa LCD
delay_ms (2);
return;
}
/******************** Inicialização do Display de LCD ********************/

void inicializa_lcd()
{
comando_lcd(0x30); // envia comando para inicializar display
delay_ms(4); // espera 4 milissegundos
comando_lcd(0x38); // configura LCD, 8 bits, matriz de 7x5, 2 linhas
limpa_lcd(); // limpa LCD
comando_lcd(0x0c); // display sem cursor
comando_lcd(0x06); // desloca cursor para a direita
return; // retorna
}
/******************** Tela Principal ********************/

void tela_principal()
{
// posiciona o cursor na linha 0, coluna 0
comando_lcd(0x80);
// imprime mensagem no LCD
printf (escreve_lcd, "Ola, mundo!");
// posiciona o cursor na linha 1, coluna 2
comando_lcd(0xC0);
// imprime mensagem no LCD
printf (escreve_lcd, "Oi, mundo");
// retorna da função
return;
}
/******************** Configurações do PIC ********************/

void main()
{
// configura microcontrolador
setup_adc_ports (no_analogs);
setup_counters (rtcc_internal, WDT_2304MS);
// configura os tris
set_tris_a(0b11011111); // configuração da direção dos pinos de I/O
set_tris_b(0b00000011);
set_tris_c(0b11111101);
set_tris_d(0b00000000);
set_tris_e(0b00000100);
// inicializa os ports
porta=0x00; // limpa porta
portb=0x00; // limpa portb
portc=0x00; // limpa portc
portd=0x00; // limpa portd
porte=0x00; // limpa porte
tela_principal(); // imprime a tela principal no LCD
/******************** Rotina principal ********************/

loop:
while(TRUE) // rotina principal
{
RESTART_WDT(); // incia o watch-dog timer
}
}

Parte 2 – Comunicação em 4 vias pela McLAB2
Como parte didática, a codificação foi dividida em várias partes que serão detalhadas a
seguir. Observe que todas estas rotinas partem do princípio que o pino R/W do LCD está
aterrado, garantindo sempre nível lógico “0”, ou seja, poderemos apenas enviar informações
(apenas escrita). As características de leitura do LCD ficam bloqueadas. Por isso, não
poderemos verificar o STATUS BIT para saber quando ele estará pronto para processar outra
informação. Devido a estes fatores, devemos nos basear no tempo mínimo par cada operação,
estabelecida na Tabela 6.
O fato de termos aterrado o pino R/W não é uma deficiência no protótipo e sim uma
característica da maioria dos projetos comerciais.
Definição de constantes
Antes de começarmos a programação propriamente dita, precisamos informar quais são
os pinos de I/O que serão utilizados pelo nosso LCD. Este procedimento faz com que a
portabilidade entre os códigos e entre LCDs seja maximizada. Estas são as linhas que
devemos incluir em nosso programa principal, juntamente com outras constantes internas:
#define lcd_enable pin_e1 // pino enable do LCD

#define lcd_rs pin_e0 // pino rs do LCD
#define lcd_db4 pin_d4 // pino de dados d4 do LCD
Rotina de envio de um “nibble”

Esta é a principal rotina para comunicação em 4 vias (depois da inicialização do LCD em
si). É justamente através dela que passaremos um “nibble” para o LCD. Esta rotina
basicamente assume que um comando ou caractere especificado pela variável DADO será
enviado para o LCD. Ela então pega o “nibble” mais baixo da variável e envia para o LCD.
Outro ponto diz respeito ao tempo necessário para a duração do pulso de enable. Como boa
prática, utilize sempre 1us para evitar instabilidades.
/*******************************************************************************/
/* Envio de "Nibble" para o LCD */
/*******************************************************************************/
//Esta rotina lê o "Nibble" inferior de uma variável 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<0>
//Gera um pulso de enable

output_high(lcd_enable); // ENABLE = 1
delay_us(1); // Recomendado para estabilizar o LCD
output_low(lcd_enable); // ENABLE = 0
return; // Retorna ao ponto de chamada da função

}
Rotina de envio de um Byte
Como o LCD precisa receber um byte inteiro antes de exibi-lo, precisamos montar esta
rotina para que os 8 bits sejam enviados para ele. Outro destaque é que esta rotina ainda
diferencia se a variável irá passar um comando ou um caractere a ser exibido. O grande truque
desta rotina consiste em pegar a variável DADO, deslocar os 4 bits mais significativos
(DADOS<7:4>) e deslocá-los para a direita para que ocupem as posições menos significativas
(DADOS<3:0>), ou seja, passaremos o “nibble” superior (mais significativo) para a posição do
“nibble” inferior (menos significativo). E por que isso é feito? Lembre-se que a nossa rotina para
enviar “nibbles” para o LCD só pega o nível inferior da variável. Então a rotina
envia_nibble_lcd() é chamada, transferindo o conteúdo do “nibble” superior para o LCD.
Lembre-se, também, que sempre devemos transferir primeiramente o “nibble” superior. Atente
para o fato que na instrução envia_nibble_lcd(dado>>4); o valor da variável passada é deslocada,
mas o conteúdo dela não é alterado. É como se utilizássemos uma variável auxiliar para este
procedimento.
Como a variável DADO permanece inalterada, podemos transferir agora o “nibble”
inferior. Teoricamente, bastaríamos chamar novamente a rotina envia_nibble_lcd(dado>>4); mas,
como uma norma de “boa prática”, nós primeiramente limpamos a parte alta do byte através da
instrução “dado & 0x0f”. Isso faz com que os 4 bits mais significativos sejam forçados para “0”.
Observe que aqui também a manipulação e alteração do valor passado como parâmetro não
altera o valor original da variável DADO.
Observe que aqui precisamos de, pelo menos 40us para que o LCD processe o byte (na
verdade são dois “nibbles”) transmitido e exiba-o na tela. Para resumir, dizemos que este é o
tempo mínimo para estabilizar o LCD. Repare, também, que este é o tempo mínimo
estabelecido pela Tabela 6.
/********************************************************************************/
/* Envio de Byte para o LCD */
/********************************************************************************/
//Esta rotina irá enviar um dado ou um comando para o LCD conforme abaixo:
// ENDEREÇO = 0 -> a variável DADO será uma instrução
// ENDEREÇO = 1 -> a variável DADO será um caractere
void envia_byte_lcd(boolean endereco, int dado)
{
output_bit(lcd_rs,endereco); // Seta o bit RS para instrução 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
}
Função para Limpar o LCD.

Como este é um procedimento muito comum e pode ocorrer diversa vezes dentro de um
programa, foi criada uma rotina simples especificamente para este fim. Este procedimento faz
com que durante a compilação, seja gerada um rotina específica e faz com que o código fique
mais otimizado após a compilação.
Atente também para o fato de precisarmos aguardar cerca de 2ms antes de retornarmos
ao programa. Esta valor também está presente na Tabela 6. Caso esta rotina apresente

instabilidade para o seu LCD em particular, experimente alterar o valor deste delay, lembrando
que, como boa prática e de acordo com a Tabela 6, este valor pode variar entre 82us e 4,1ms.
/********************************************************************************/
/* Função para limpar o LCD */
/********************************************************************************/
//
void limpa_lcd()
{
envia_byte_lcd(0,0x01); // Envia instrução para limpar o LCD
delay_ms(2); // Aguarda 2ms para estabilizar o LCD
}
Inicialização do LCD
A seguir, temos o código para inicializar um LCD em 4 vias. A primeira ação da rotina é
forçar todas as linhas para o nível lógico “0”. O passo seguinte é aguardar 15ms para
estabilizar o LCD, após ser energizado. Até este ponto, é o mesmo procedimento para os
modos de 8 e 4 vias. Após este ponto, precisamos mandar as informações para inicialização
básica do LCD que consiste em enviar três vezes o “nibble” 0x03, ou enviar o byte 0x30. Para
efeito de economia de código e utilizando a característica de que a rotina envia_nibble_lcd()
trabalha com o “nibble” inferior, será melhor enviarmos o comando 0x03. Repare que devemos
aguardar um tempo para estabilizar o LCD. Como este é um procedimento executado apenas 1
vez em todo o ciclo do PIC e verificando que o tempo determinado na maioria dos data sheets
são inferiores ou muito próximos a 5ms, adotou-se este valor como intervalo mínimo entre as
fases iniciais de configuração, onde devemos enviar 3 comando 0x03. Após isso, vamos enviar
o “nibble” para posicionar o cursor para a posição inicial e, ainda seguindo a Tabela 6,
devemos aguardar de 40us a 4,1ms . Por padrão foi adotado 1ms. Aqui também cabe a
observação de que, se o display apresentar instabilidades, este tempo deve ser alterado. Em
seguida é enviado o “nibble” 0x20 que indica que o LCD será configurado para 4 vias de dados,
e 1 linha com matriz de 7X5 com cursor. Este valor pode ser alterado a fim de realizar testes,
conforme descrito nas Tabelas 2 e 3. Repare que para este último comando, é necessário
enviar um byte completo e não apenas um “nibble”.
Estes são os procedimentos iniciais e obrigatoriamente deve seguir esta seqüência. A
partir deste ponto podemos entrar com as configurações constantes nas Tabelas 2 e 3 em
qualquer ordem. É importante salientar também que as instruções constantes a partir deste
ponto, assim como a de posicionamento do cursor (CURSOR HOME) podem ser utilizadas em
qualquer ponto do programa e não apenas na inicialização do LCD. Com isso fica fácil
implementar, por exemplo, uma rotina do tipo “backspace”.
Os comando seguintes enviam um byte completo (e não apenas um “nibble”) para as
configurações de controle do display (Display control) e para os deslocamentos desejados
(Entry Mode Set).
Sempre use as Tabelas 2 e 3 como referência.
E para finalizar, existe o comando RETURN para retornar ao ponto onde a rotina foi
chamada. Novamente esta é uma boa prática, mas este comando pode ser retirado, uma vez a
função sempre retorna ao ponto onde foi chamada.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Inicializa o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
output_low(lcd_db4); // Garante que o pino DB4 estão em 0 (low)
output_low(lcd_rs); // Garante que o pino RS estão em 0 (low)
output_low(lcd_enable); // Garante que o pino ENABLE estão em 0 (low)
envia_nibble_lcd(0x03); // Envia comando para inicializar o display

envia_nibble_lcd(0x02);// CURSOR HOME - Envia comando para zerar o contador de
// caracteres e retornar à posição inicial (0x80).
envia_byte_lcd(0,0x28); // FUNCTION SET - Configura o LCD para 4 bits,
// 2 linhas, fonte 5X7.
envia_byte_lcd(0,0x0c); // DISPLAY CONTROL - Display ligado, sem cursor
limpa_lcd(); // Limpa o LCD
envia_byte_lcd(0,0x06); // ENTRY MODE SET - Desloca o cursor para a direita

}

Parte 3 – Comunicação em 4 vias pela placa de testes
Para configurar a placa de testes sugerida neste documento, basta alterar as definições
das constantes declaradas no início do programa. Com isto fica muito fácil visualizar quão
poderosa é esta rotina. Ela pode ser implementada em qualquer projeto que você estiver
desenvolvendo.
Definição de constantes
Antes de começarmos a programação propriamente dita, precisamos informar quais são
os pinos de I/O que serão utilizados pelo nosso LCD. Este procedimento faz com que a
portabilidade entre os códigos e entre LCDs seja maximizada. Estas são as linhas que
devemos incluir em nosso programa principal, juntamente com outras constantes internas:
#define lcd_enable pin_b5 // pino enable do LCD
#define lcd_rs pin_b4 // pino rs do LCD
#define lcd_db4 pin_b0 // pino de dados d4 do LCD
Outras alterações
É obvio que, além destas configurações, o tipo de processador, fuses, declaração e
inicialização de PORTs e TRIS, assim como as configurações básicas do microcontrolador
deverão ser adequados, uma vez que utilizamos o PIC16F628A ao invés do PIC16F877A
existente na McLAB2.
Isso ficará bem claro ao comparar os dois códigos referentes a um mesmo exercício.

Exercício 1 – Inicializando o LCD e “Olá Mundo!”

Exercício 1 – Inicializando o LCD e “Olá Mundo”
Como primeiro exercício vamos apenas inicializar o LCD e escrever a frase “Olá Mundo”
no display da McLAB2 e da placa de testes. A seguir temos detalhado os testes para cada
placa.
McLAB2
O fluxograma necessário para realizar este primeiro exercício é exibido na figura abaixo:
Início
Define Microcontrolador
Define configurações para

gravação

rotinas de delay
Define constantes internas
Define e inicializa os PORTs
Define bibliotecas para o LCD:

envia_nibble_lcd();
envia_byte_lcd();
escreve_lcd();
limpa_lcd();
inicializa_lcd();
Configura o PIC:
Reseta PORTs
Configura TRIS
Inicializa o LCD
Escreve na tela
Define rotina principal
Final
Figura 24: Fluxograma para a placa McLAB2

O código que deverá ser gravada na McLAB2 é o seguinte:
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Tutorial LCD em 4 vias *
* Para uso na placa de testes *
* *
* Exercício 1 - Olá Mundo! *
* *
* Criado por Eduardo de Souza Ramos *
* *
* Memory usage: ROM=4% RAM=3% - 6% *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Primeiro teste de LCD em 4 vias - Olá Mundo
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Definição do PIC utilizado *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <16f877a.h>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Configurações para gravação *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT,NOLVP,NOCPD,NOWRT
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Definição para uso de Rotinas de Delay *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use delay(clock=4000000)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Constantes internas *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Estas são as definições dos pinos que o LCD utiliza.
// Definem quais pinos do PIC controlarão os pinos do LCD
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Definição e inicialização dos port's *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(a) // Inicialização rápida dos Pinos de I/O
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
#byte porta = 0x05

#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08
#byte porte = 0x09
/***************************************************************************/
/* Rotinas para o LCD */
/***************************************************************************/
//Este é o bloco com as rotinas necessárias para manipular o LCD
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Envio de "Nibble" para o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Envio de Byte para o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
output_bit(lcd_rs,endereco);// Seta o bit RS para instrução ou caractere
envia_nibble_lcd(dado>>4); // Envia a parte ALTA do dado/coamndo
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Envio de caractere para o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Esta rotina serve apenas como uma forma mais fácil de escrever um caractere
// no display. Ela pode ser eliminada e ao invés dela usaremos diretamente a
// função envia_byte_lcd(1,"<caractere a ser mostrado no lcd>"); ou
// envia_byte_lcd(1,<código do caractere a ser mostrado no lcd>);
void escreve_lcd(char c)
// envia caractere para o display
{
envia_byte_lcd(1,c);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Função para limpar o LCD *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Como esta operação pode ser muito utilizada, transformando-a em função
// faz cvom que o código compilado seja menor.
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
output_low(lcd_enable);// Garante que o pino ENABLE estão em 0 (low)

envia_nibble_lcd(0x02); // CURSOR HOME - Envia comando para zerar o contador de

}
/***************************************************************************/
/* Final das rotinas para o LCD */
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Configurações do Pic *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Configura o PIC
setup_adc_ports(no_analogs);
// Reseta portas
porta = 0;
portb = 0;
portc = 0;
portd = 0;
porte = 0;
set_tris_b(0b11111111);
set_tris_c(0b11111111);
set_tris_d(0b00001111);
set_tris_e(0b11111100);
// 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("!");
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Rotina principal *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Como não há outra execução, a rotina principal fica vazia
while (true)
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}

Placa de testes
O fluxograma necessário para realizar este primeiro exercício é exibido na figura abaixo:
Início

gravação

rotinas de delay

envia_nibble_lcd();
envia_byte_lcd();
escreve_lcd();
limpa_lcd();
inicializa_lcd();
Configura o PIC:
Reseta PORTs
Configura TRIS
Inicializa o LCD
Escreve na tela
Final
Figura 25: Fluxograma para a placa de testes

Este é o código a ser programado em nossa placa de testes:
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 1 – Olá Mundo! *
* *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Primeiro teste de LCD em 4 vias - Olá Mundo
//
//
//
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#fuses INTRC,NOWDT,PUT,MCLR,NOBROWNOUT,NOLVP
#ROM 0x07ff = {0} //Calibragem do oscilador interno
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(b)
#byte porta = 0x05

#byte portb = 0x06
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// função envia_byte_lcd(1,"<caractere a ser mostrado no LCD>"); ou
// envia_byte_lcd(1,<código do caractere a ser mostrado no LCD>);
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// faz com que o código compilado seja menor.
void limpa_lcd()
{
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Configurações do PIC *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Reseta portas
porta = 0;
portb = 0;
set_tris_b(0b11000000);
// 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("!");
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
while (true)
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}
Repare que neste programa exemplo, o uso de memória foi ROM=15% e RAM=3% -
6%. Esta observação é importante para que possamos comparar com os outros exercícios.

Exercício 2 – A função PRINTF();

Exercício 2 – A função PRINTF()
Depois de termos realizado o Exercício 1, é muito comum termos a seguinte dúvida: “Ok,
mas não tem uma forma melhor de escrever no LCD sem ter que declarar caractere por
caractere? Isso é muito chato!”.
Sim, existe uma forma onde, além de deixarmos o programa mais enxuto, ainda
economizamos espaço de memória! E qual é a mágica? É simples... vamos usar uma função
disponível no compilador (neste caso o CCS) chamada PRINTF().
Para que tenhamos uma visão mais clara das vantagens que esta função oferece,
vamos manter o mesmo corpo do exercício anterior, mudando apenas a forma de exibir as
informações no LCD.
Como no Exercício anterior, vamos abordar o uso desta rotina tanto na McLAB2 quanto
na placa de testes.

McLAB2
O fluxograma necessário para realizar este exercício é exibido na figura abaixo:
Início

gravação

rotinas de delay

envia_nibble_lcd();
envia_byte_lcd();
escreve_lcd();
limpa_lcd();
inicializa_lcd();
Configura o PIC:
Reseta PORTs
Configura TRIS
Inicializa o LCD
Escreve na tela
Final
Figura 26: Fluxograma para a placa McLAB2

Este é o código:
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 2 - A função PRINTF() *
* *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Segundo teste de LCD em 4 vias - Olá Mundo utilizando a função PRINTF()
//
//
//
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
#byte porta = 0x05

#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08
#byte porte = 0x09
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
envia_nibble_lcd(0x03);// Envia comando para inicializar o display

envia_byte_lcd(0,0x28);// FUNCTION SET - Configura o LCD para 4 bits,
envia_byte_lcd(0,0x0c);// DISPLAY CONTROL - Display ligado, sem cursor
envia_byte_lcd(0,0x06);// ENTRY MODE SET - Desloca o cursor para a direita

}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Configura o PIC
// Reseta portas
porta = 0;
portb = 0;
portc = 0;
portd = 0;
porte = 0;
set_tris_b(0b11111111);
set_tris_c(0b11111111);
set_tris_d(0b00001111);
set_tris_e(0b11111100);
// Inicializa o LCD
inicializa_lcd();

//Escreve tela
printf(escreve_lcd,"Ola Mundo!");
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
while (true)
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}

Placa de testes
O fluxograma necessário para realizar este exercício é exibido na figura abaixo:
Início

gravação

rotinas de delay

envia_nibble_lcd();
envia_byte_lcd();
escreve_lcd();
limpa_lcd();
inicializa_lcd();
Configura o PIC:
Reseta PORTs
Configura TRIS
Inicializa o LCD
Escreve na tela
Final
Figura 27: Fluxograma para a placa de testes

Este é o código para a nossa placa de testes:
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 2 - A função PRINTF() *
* *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Segundo teste de LCD em 4 vias - Olá Mundo utilizando a função PRINTF()
//
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(b)
#byte porta = 0x05

#byte portb = 0x06
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Reseta portas
porta = 0;
portb = 0;
set_tris_b(0b11000000);
// Inicializa o LCD
inicializa_lcd();
//Escreve tela
printf(escreve_lcd,"Ola Mundo!");
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
while (true)
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}

Repare que neste programa exemplo, o uso de memória foi ROM=9% e RAM=3% - 6%.
Se compararmos com o exercício anterior, veremos que houve um ganho substancial de
memória (6 pontos percentuais) que em alguns casos pode representar o sucesso de seu
projeto! Portanto, use esta função e seja feliz!!!
Maiores detalhes sobre esta função e como imprimir o conteúdo de variáveis pode ser
encontrada no help do compilador CCS

Exercício 3 – Rotacionando o display

Exercício 3 – Rotacionando o display
Conforme dito antes, independentemente do tamanho do display, há sempre 80
posições em cada linha do display para armazenar caracteres. Mas preste atenção que, nos
displays de 4 linhas, a terceira linha é continuação da primeira e a quarta e a continuação da
segunda. Verifique isto na Figura 13.
Mas, como não há espaço disponível para visualizar todos estes espaços, há um modo
de deslocar a telado LCD de forma que temos acesso a todo o conteúdo armazenado em cada
linha. Este é um procedimento muito simples, mas há uma pegadinha... ele altera a relação dos
endereços com as posições na tela. Portanto, se você realizar diversas rotações, é uma boa
prática utilizar o comando envia_byte_lcd(0,0x02) para que o comando CURSOR HOME seja
executado, direcionando o cursor para a posição 0x00 (ou 0x80 se levarmos em conta que o bit
7 deve ser sempre “1”, ao nos referenciarmos a um endereço) e deslocando o display para o
estado original. Não se esqueça que este comando não altera a memória RAM do LCD. Não
use o comando CLEAR DISPLAY (0x01), pois neste caso, todo o conteúdo da memória RAM
poderá será perdido.
Se entrarmos com mais de 16 caracteres por linha (no nosso caso, uma vez que usamos
um LCD de 16 posições), os caracteres excedentes ficarão fora da linha de visão, no lado
“direito” da tela.
Então, poderemos usar a função envia_byte_lcd(0,0x18) para que todos os endereços
da tela sejam deslocadas para a esquerda. Isto dá a sensação de que a tela deslocou para a
direita. É como se tivéssemos uma lupa em cima do texto.
Da mesma forma, poderemos utilizar a função envia_byte_lcd(0,0x1c) para realizar a
operação inversa.
Neste exemplo mostramos como podemos criar um mostrador onde o texto apresenta o
clássico movimento de “vai-e-vem”.
Como vocês já devem ter reparado nos dois exemplos anteriores, o fluxograma é o
mesmo, portanto, para este exemplo, não vamos fugir à regra. Devido a isto, não iremos repetir
o mesmo desenho, passando diretamente para a codificação para a placa McLAB2 e para a
nossa placa de testes.

McLAB2
Este é o código para a McLAB2

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 3 - Deslocando e rotacionando o display *
* *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Neste exercício, o display será deslocado para a esquerda e, ao final
// da mensagem ele será deslocado para a direita, criando um efeito de
// vai-e-vem. Serão utilizadas as duas linhas do LCD para ter uma melhor
// visualização.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
#byte porta = 0x05

#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08
#byte porte = 0x09

/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
envia_byte_lcd(0,0x28);// FUNCTION SET - Configura o LCD para 4 bits,
envia_byte_lcd(0,0x0c);// DISPLAY CONTROL - Display ligado, sem cursor
envia_byte_lcd(0,0x06);// ENTRY MODE SET - Desloca o cursor para a direita
}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Configura o PIC
// Reseta portas
porta = 0;
portb = 0;
portc = 0;
portd = 0;
porte = 0;
set_tris_b(0b11111111);
set_tris_c(0b11111111);
set_tris_d(0b00001111);
set_tris_e(0b11111100);
// Inicializa o LCD
inicializa_lcd();
//Escreve tela
printf(escreve_lcd,"Teste 1-linha com mais de 16 caracteres");
envia_byte_lcd(0,0xc0); //Desloca o cursor para a segunda linha do LCD
printf(escreve_lcd,"Teste 2-linha comum, + de 16 caracteres");
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Esta rotina é a responsável pelo movimento de vai-e-vem do display.
// Ela fica em loop infinito.;
while (true)
{
int i;
//Desloca os caracteres do LCD para a esquerda
for(i=0;i<=22;i++)
{
envia_byte_lcd(0,0x18); //0x18 = 0b00011000
delay_ms(250);
}
//Desloca os caracteres do LCD para a direita
for(i=0;i<=22;i++)
{
envia_byte_lcd(0,0x1c); //0x1c = 0b00011100
delay_ms(250);
}
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}

Placa de testes
O seguinte código é o que deverá ser executado em nossa placa de testes:

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 3 - Deslocando e rotacionando o display *
* *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Neste exercício, o display será deslocado para a esquerda e, ao final
// da mensagem ele será deslocado para a direita, criando um efeito de
// vai-e-vem. Serão utilizadas as duas linhas do LCD para ter uma melhor
// visualização.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(b)
#byte porta = 0x05

#byte portb = 0x06
/***************************************************************************/

/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{

}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Reseta portas
porta = 0;
portb = 0;
set_tris_b(0b11000000);
// Inicializa o LCD
inicializa_lcd();
//Escreve tela
printf(escreve_lcd,"Teste 1-linha com mais de 16 caracteres");
envia_byte_lcd(0,0xc0); //Desloca o cursor para a segunda linha do LCD
printf(escreve_lcd,"Teste 2-linha comum, + de 16 caracteres");
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
while (true)
{
int i;
//Desloca os caracteres do LCD para a esquerda
for(i=0;i<=22;i++)
{
envia_byte_lcd(0,0x18); //0x18 = 0b00011000
delay_ms(250);
}
//Desloca os caracteres do LCD para a direita
for(i=0;i<=22;i++)
{
envia_byte_lcd(0,0x1c); //0x1c = 0b00011100
delay_ms(250);
}
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}
Faça um teste... Comentes as linhas que direcionam os caracteres do LCD para a direita
e veja o que acontece...

Exercício 4 – Criando caracteres

Exercício 4 – Criando caracteres
Os endereços da CGRAM de 0x40 até 0x7F são usados para que armazenemos os
caracteres desenhados por nós.
Para isso, precisaremos, logo no início do programa, definir quais são os valores dos
caracteres, conforme explicado no Capítulo 1 – Parte 7.
Este exemplo, para as placas McLAB2 e a nossa placa de testes, utiliza o mesmo
fluxograma, que é exibido a seguir.
Início cria_cgram();
Vai para a primeira posição

Define microcontrolador
da CGRAM (0x40)
Define configurações para Entra com os 8 dados do

gravação primeiro caractere

rotinas de delay segundo caractere
Entra com os 8 dados do

terceiro caractere

quarto caractere
Define bibliotecas para o LCD: Entra com os 8 dados do

envia_nibble_lcd(); quinto caractere
envia_byte_lcd();
escreve_lcd();
limpa_lcd();
inicializa_lcd();
sexto caractere
cria_cgram();
anima_cgram();

Configura o PIC: sétimo caractere
Reseta PORTs
Configura TRIS
Inicializa o LCD Entra com os 8 dados do
Escreve na tela oitavo caractere
Define rotina principal Limpa o LCD
Fim Retorna
Figura 28: Fluxograma para o exemplo 4

McLAB2
Este é o código que deverá ser implementado em nossa placa de testes:
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 4 - Criando caracteres na CGRAM *
* *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Neste exercício, criaremos 8 caracteres especiais (desenhos) na CGRAM
// para utilizarmos em qualquer ponto do LCD
// A priori eles serão exibidos nas 8 primeiras posições da primeira
// linha do LCD. Maseles poderão ser utilizados em qualquer ponto.
// Como estes caracteres ficam na CGRAM, são voláteis, ou seja, ao
// desligarmos o módulo e o ligarmos novamente, precisarmos reintroduzir
// o código para a criação de caracteres.
// Reparem que, apesar de termos 16 posições disponíveis na CGRAM,
// somente poderemos criar 8 caracteres. As 8 posições adjacentes (posições
// 0x08 a 0x0f) são espelho da primeira (0x00 a 0x07)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
#byte porta = 0x05

#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08
#byte porte = 0x09
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Cria caracteres na CG RAM *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void cria_cgram()
{
envia_byte_lcd(0,0b01000000); // Vai para primeira posição da CGRAM
envia_byte_lcd(1,0b00001110); // Cria a primeira linha de nosso robozinho

envia_byte_lcd(1,0b00010001); // Cria a segunda linha de nosso robozinho
envia_byte_lcd(1,0b00001110); // Cria a terceira linha de nosso robozinho
envia_byte_lcd(1,0b00000100); // Cria a quarta linha de nosso robozinho
envia_byte_lcd(1,0b00011111); // Cria a quinta linha de nosso robozinho
envia_byte_lcd(1,0b00000100); // Cria a sexta linha de nosso robozinho
envia_byte_lcd(1,0b00001010); // Cria a sétima linha de nosso robozinho
envia_byte_lcd(1,0b00010001); // Cria a oitava linha de nosso robozinho
envia_byte_lcd(1,0b00001110); // Cria a primeira linha de nosso robozinho 2

envia_byte_lcd(1,0b00010001); // Cria a segunda linha de nosso robozinho 2
envia_byte_lcd(1,0b00001110); // Cria a terceira linha de nosso robozinho 2
envia_byte_lcd(1,0b00010100); // Cria a quarta linha de nosso robozinho 2
envia_byte_lcd(1,0b00001110); // Cria a quinta linha de nosso robozinho 2
envia_byte_lcd(1,0b00000101); // Cria a sexta linha de nosso robozinho 2
envia_byte_lcd(1,0b00001010); // Cria a sétima linha de nosso robozinho 2
envia_byte_lcd(1,0b00010001); // Cria a oitava linha de nosso robozinho 2


envia_byte_lcd(1,0b00011111); // Cria a primeira linha de nosso janelinha

envia_byte_lcd(1,0b00010101); // Cria a segunda linha de nosso janelinha
envia_byte_lcd(1,0b00011111); // Cria a terceira linha de nosso janelinha
envia_byte_lcd(1,0b00010101); // Cria a quarta linha de nosso janelinha
envia_byte_lcd(1,0b00010101); // Cria a quinta linha de nosso janelinha
envia_byte_lcd(1,0b00011111); // Cria a sexta linha de nosso janelinha
envia_byte_lcd(1,0b00010101); // Cria a sétima linha de nosso janelinha
envia_byte_lcd(1,0b00011111); // Cria a oitava linha de nosso janelinha
envia_byte_lcd(1,0b00011111); // Cria a primeira linha de nossa ampulheta 1

envia_byte_lcd(1,0b00011111); // Cria a segunda linha de nossa ampulheta 1
envia_byte_lcd(1,0b00001110); // Cria a terceira linha de nossa ampulheta 1
envia_byte_lcd(1,0b00000100); // Cria a quarta linha de nossa ampulheta 1
envia_byte_lcd(1,0b00001010); // Cria a quinta linha de nossa ampulheta 1
envia_byte_lcd(1,0b00010001); // Cria a sexta linha de nossa ampulheta 1
envia_byte_lcd(1,0b00010001); // Cria a sétima linha de nossa ampulheta 1
envia_byte_lcd(1,0b00011111); // Cria a oitava linha de nossa ampulheta 1


limpa_lcd();

}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Configura o PIC
// Reseta portas
porta = 0;
portb = 0;
portc = 0;
portd = 0;
porte = 0;
set_tris_b(0b11111111);
set_tris_c(0b11111111);
set_tris_d(0b00001111);
set_tris_e(0b11111100);
// Inicializa o LCD
inicializa_lcd();
//Escreve tela
limpa_lcd();
cria_cgram();
//Escreve os caracteres da CGRAM nas duas linhas do LCD

escreve_lcd(0b00000000);
envia_byte_lcd(0,0xc0);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//
while (true)
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}
Placa de testes
Este é o código que deverá ser implementado em nossa placa de testes:

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 4 - Criando caracteres na CGRAM *
* *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Neste exercício, criaremos 8 caracteres especiais (desenhos) na CGRAM
// para utilizarmos em qualquer ponto do LCD
// A priori eles serão exibidos nas 8 primeiras posições da primeira
// linha do LCD. Mas eles poderão ser utilizados em qualquer ponto.
// Como estes caracteres ficam na CGRAM, são voláteis, ou seja, ao
// desligarmos o módulo e o ligarmos novamente, precisarmos reintroduzir
// o código para a criação de caracteres.
// Reparem que, apesar de termos 16 posições disponíveis na CGRAM,
// somente poderemos criar 8 caracteres. As 8 posições adjacentes (posições
// 0x08 a 0x0f) são espelho da primeira (0x00 a 0x07)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#use fast_io(b)
#byte porta = 0x05

#byte portb = 0x06
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void cria_cgram()
{
envia_byte_lcd(1,0b00001110); // Cria a primeira linha de nosso robozinho

envia_byte_lcd(1,0b00010001); // Cria a segunda linha de nosso robozinho
envia_byte_lcd(1,0b00001110); // Cria a terceira linha de nosso robozinho
envia_byte_lcd(1,0b00000100); // Cria a quarta linha de nosso robozinho
envia_byte_lcd(1,0b00011111); // Cria a quinta linha de nosso robozinho
envia_byte_lcd(1,0b00000100); // Cria a sexta linha de nosso robozinho
envia_byte_lcd(1,0b00001010); // Cria a sétima linha de nosso robozinho
envia_byte_lcd(1,0b00010001); // Cria a oitava linha de nosso robozinho



envia_byte_lcd(1,0b00011111); // Cria a primeira linha de nosso janelinha

envia_byte_lcd(1,0b00010101); // Cria a segunda linha de nosso janelinha
envia_byte_lcd(1,0b00011111); // Cria a terceira linha de nosso janelinha
envia_byte_lcd(1,0b00010101); // Cria a quarta linha de nosso janelinha
envia_byte_lcd(1,0b00010101); // Cria a quinta linha de nosso janelinha
envia_byte_lcd(1,0b00011111); // Cria a sexta linha de nosso janelinha
envia_byte_lcd(1,0b00010101); // Cria a sétima linha de nosso janelinha
envia_byte_lcd(1,0b00011111); // Cria a oitava linha de nosso janelinha



limpa_lcd();

}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Reseta portas
porta = 0;
portb = 0;
set_tris_b(0b11000000);
// Inicializa o LCD
inicializa_lcd();
//Escreve tela
limpa_lcd();
cria_cgram();
//envia_byte_lcd(0,0x80);
envia_byte_lcd(0,0xc0);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
//
while (true)
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}

Exercício 5 – Uma pequena animação

Exercício 5 – Uma pequena animação
E agora, como exercício final, vamos fazer uma pequena animação com os caracteres
criados no exercício anterior e vamos introduzir o conceito de “backspace” automaticamente
pelo LCD.
O organograma é o mesmo para a McLAB2 e para a nossa placa de testes:
Início cria_cgram(); anima_cgram();
Vai para a primeira posição

Define microcontrolador Define número de interações
da CGRAM (0x40)

Envia o primeiro caractere
gravação primeiro caractere

Executa um backspace
rotinas de delay segundo caractere

Define constantes internas Envia o segundo caractere
terceiro caractere

Define e inicializa os PORTs Executa um backspace
quarto caractere
Define bibliotecas para o LCD: Entra com os 8 dados do

Envia o terceiro caractere
envia_nibble_lcd(); quinto caractere
envia_byte_lcd();
escreve_lcd();
limpa_lcd();
inicializa_lcd(); Executa um backspace
sexto caractere
cria_cgram();
anima_cgram();

Apaga o caractere anterior
Configura o PIC: sétimo caractere
Reseta PORTs
Configura TRIS
Inicializa o LCD Entra com os 8 dados do
Escreve na tela oitavo caractere
Interação
Não
acabou?
Define rotina principal Limpa o LCD

Sim
Fim Retorna Retorna
Figura 29: Fluxograma para a animação nas placas McLAB2 e de testes

McLAB2
O código a seguir deve ser programado na McLAB2:

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 5 - Uma pequena animação *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Pequena animação para exemplificar o uso dos caracteres gerados na CGRAM
// e testar a função de backspace.
// O tempo de animação é controlado pela constante tempo
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define tempo 150
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
#byte porta = 0x05

#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08

#byte porte = 0x09
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void cria_cgram()
{
//escreve_lcd(0b00000000);




limpa_lcd();
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Cria uma animação na CG RAM *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void anima_cgram()
{
int i;
for (i=0;i<=15;i++)
{
delay_ms(tempo);
envia_byte_lcd(0,0b00010000); //backspace
delay_ms(tempo);
delay_ms(tempo);
delay_ms(tempo);
escreve_lcd(" ");
}
return;
}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Configura o PIC
// Reseta portas
porta = 0;
portb = 0;
portc = 0;
portd = 0;
porte = 0;
set_tris_b(0b11111111);
set_tris_c(0b11111111);
set_tris_d(0b00001111);
set_tris_e(0b11111100);
// Inicializa o LCD
inicializa_lcd();
//Escreve tela
limpa_lcd();
cria_cgram();
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
while (true)
{
//Faz uma animação do robozinho
envia_byte_lcd(0,0x80);
anima_cgram();
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}

Placa de testes
O código a seguir deve ser programado na nossa placa de testes:

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Exercício 5 - Uma pequena animação *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* VERSÃO : 1.0 *
* DATA : 31/08/2005 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// Pequena animação para exemplificar o uso dos caracteres gerados na CGRAM
// e testar a função de backspace.
// O tempo de animação é controlado pela constante tempo
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#define tempo 150
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#use fast_io(b)
#byte porta = 0x05

#byte portb = 0x06
/***************************************************************************/

/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
// dado/comando
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void limpa_lcd()
{
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
{


}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void cria_cgram()
{




limpa_lcd();

}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Cria uma animação na CG RAM *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void anima_cgram()
{
int i;
for (i=0;i<=15;i++)
{
delay_ms(tempo);
delay_ms(tempo);
delay_ms(tempo);
delay_ms(tempo);
escreve_lcd(" ");
}
return;
}
/***************************************************************************/
/***************************************************************************/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
main()
{
// Reseta portas
porta = 0;
portb = 0;
set_tris_b(0b11000000);
// Inicializa o LCD
inicializa_lcd();
//Escreve tela
limpa_lcd();
cria_cgram();
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
while (true)
{
//Faz uma animação do robozinho
envia_byte_lcd(0,0x80);
anima_cgram();
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Fim do Programa *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}

Display LCD
01. INTRODUÇÃO
Os módulos LCD são interfaces de saída muito útil em sistemas microprocessados. Estes módulos podem ser gráficos e a caracter.
Os módulos LCD gráficos são encontrados com resuluções de 122x32, 128x64, 240x64 e 240x128 dots pixel, e geralmente estão
disponíveis com 20 pinos para conexão. Os LCD comuns (tipo caracter) são especificados em número de linhas por colunas e são
encontrados nas configurações previstas na Tabela 1.
Número de Número de Quantidade de

Colunas Linhas pinos
8 2 14
12 2 14/15
16 1 14/16
16 2 14/16
16 4 14/16
20 1 14/16
20 2 14/16
20 4 14/16
24 2 14/16
24 4 14/16
40 2 16
40 4 16
Tabela 1 - Módulos LCD disponíveis
Os módulos podem ser encontrados com LED backlight (com uma iluminação de fundo) para facilitar as leituras durante a noite.
Neste caso, a alimentação deste led faz-se normalmente pelos pinos 15 e 16 para os módulos comuns e 19 e 20 para os módulos
gráficos, sendo os pinos 15 e 19 para ligação ao anodo e os pinos 16 e 20 para o catodo. A corrente de alimentação deste led varia
de 100 a 200mA, dependendo do modelo.
Estes módulos utilizam um controlador próprio, permitindo sua interligação com com outras placas através de seus pinos, onde
deve ser alimentado o módulo e interligado o barramento de dados e controle do módulo com a placa do usuário. Naturalmente
que além de alimentar e conectar os pinos do módulo com a placa do usuário deverá haver um protocolo de comunicação entre as
partes, que envolve o envio de bytes de instruções e bytes de dados pelo sistema do usuário.
Assim como em um rádio relógio todo módulo LCD permite um ajuste na intensidade da luz emitida ou ajuste
de contraste, isto é possível variando-se a tensão no pino 3. A Figura 1 mostra um circuito típico e
recomendado pela maioria dos fabricantes para efetuar este ajuste. Alguns fabricantes recomenda o uso de um
resistor de 4K7 em série com o potenciômetro de 10K.
A Tabela 2 descreve cada pino do módulo ou do display para conexão deste a outras placas:
1
Display LCD
Pino Função Descrição

1 Alimentação Terra ou GND
2 Alimentação VCC ou +5V
3 V0 Tensão para ajuste de contraste (ver Figura 1)
4 RS Seleção: 1 - Dado, 0 - Instrução
5 R/W Seleção: 1 - Leitura, 0 - Escrita
6 E Chip select 1 ou (1 → 0) - Habilita, 0 - Desabilitado
7 B0 LSB
8 B1
9 B2 Barramento
10 B3 de
11 B4 Dados
12 B5
13 B6
14 B7 MSB
15 A (qdo existir) Anodo p/ LED backlight
16 K (qdo existir) Catodo p/ LED backlight
Tabela 2 - Pinagem dos Módulos LCD
Figura 1 - Detalhe do controle de contraste do módulo LCD
2
Display LCD
02. INTERFACE COM CPU
Os módulos LCD são projetados para conectar-se com a maioria das CPU’s disponíveis no mercado, bastando para isso que esta
CPU atenda as temporizações de leitura e escrita de instruções e dados, fornecido pelo fabricante do módulo. A Figura 2 mostra
um exemplo de diagrama de tempos típico requeridos para operação de escrita no módulo LCD, estes tempos variam em função
do clock da CPU do usuário.
Figura 2 - (a) Escrita no LCD (b) Ciclo de Escrita da CPU 8051
A Tabela 3 a seguir mostra a relação entre a freqüência da CPU e a temporização de leitura/escrita da maioria dos módulos LCD.
Em geral, podemos conectar o barramento de dados da CPU ao barramento do módulo, mapeando-o convenientemente na placa
de usuário, e efetuarmos uma operação normal de leitura/escrita sem mais problemas.
Clock da CPU
t AS
(MHz) PW EH
(nS) t H
(nS )
08 MHz 325 650 75
10 MHz 250 500 50
12 MHz 200 400 33,3
16 MHz 138 275 12,5
Tabela 3 - Relação clock da CPU x Temporização do Módulo LCD
A Figura 3 mostra um exemplo de conexão de uma placa baseada nos microcontroladores da linha Intel de 8 bits (8051), ao
módulo LCD. Neste caso como os sinais A0 e A1 estão conectados aos pinos 4 e 5, teremos então 04 (quatro) endereços distintos
para comunicação entre a CPU e o módulo LCD. A Tabela 4 mostra estes endereços.
3
Display LCD
Figura 3 - Sistema baseado na CPU 8051 com módulo LCD
4
Display LCD
ENDEREÇO R/W RS DESCRIÇÃO

4000 0 0 Instrução - Escrita no modulo
4001 0 1 Dados - Escrita no modulo
4002 1 0 Instrução - Leitura no modulo
4003 1 1 Dados - Leitura no modulo
Tabela 4 - Endereçamento do módulo LCD para Figura 3
O exemplo apresentado na Figura 3 refere-se a conexão do módulo LCD com comunicação/transmissão de 8 bits, mas podemos
conectar o módulo com transmissão a cada 4 bits, conforme é mostrado na Figura 4. Neste caso não utilizamos os pinos 7, 8, 9 e
10. Isto é muito útil quando a CPU do usuário possui poucos pinos de I/O, caso típico da linha de microprocessadores PIC, como
por exemplo o Basic Stamp. Agora surge a dúvida, um mesmo módulo pode conectar-se com 8 ou 4 bits? como isto é possível?
Ocorre que o módulo LCD quando alimentado necessita de algumas instruções de inicialização que identificará qual a forma de
transmissão de dados que será estabelecida entre a CPU e o módulo.
Figura 4 - Modulo LCD comunicando-se com 4 bits
5
Display LCD
03. PROGRAMAÇÃO / INSTRUÇÕES
A Tabela 5 traz um resumo das instruções mais usadas na comunicação com os módulos LCD.
DESCRIÇÃO MODO RS R/W Código h

Display Liga (sem cursor) 0 0 0C
Desliga 0 0 0A / 08
Limpa Display com 0 0 01
Home cursor
Controle do Cursor Liga 0 0 0E
Desliga 0 0 0C
Desloca para Esquerda 0 0 10
Desloca para Direita 0 0 14
Cursor Home 0 0 02
Cursor Piscante 0 0 0D
Cursor com Alternância 0 0 0F
Sentido de deslocamento do Para a esquerda 0 0 04
cursor ao entrar com caracter Para a direita 0 0 06
Deslocamento da mensagem Para a esquerda 0 0 07
ao entrar com caracter Para a direita 0 0 05
Deslocamento da mensagem Para a esquerda 0 0 18
sem entrada de caracter Para a direita 0 0 1C
End. da primeira posição primeira linha 0 0 80
segunda linha 0 0 C0
Tabela 5 - Instruções mais comuns
A Tabela 6 apresenta o conjunto de instruções, levando-se em consideração que a comunicação com o módulo seja com
barramento de 8 bits (fixado durante a inicialização). Para o caso desta comunicação ocorrer com apenas 4 bits (nible), os dados
ou instruções serão enviados por nible. sendo enviado o nible mais significativo primeiro. Por exemplo para limpar o display,
escreve-se o nible 0000 e depois 0001.
6
Display LCD
INSTRUÇÃO R R/ B7 B6 B5 B4 B3 B2 B1 B0 DESCRIÇÃO e tempo de execução (uS) t

S W
Limpa Display 0 0 0 0 0 0 0 0 0 1 -Limpa todo o display e retorna o cursor 1.6 mS
para a primeira posição da primeira linha
Home p/ 0 0 0 0 0 0 0 0 1 * -Retorna o cursor para a 1. coluna da 1. 1.6 mS
Cursor Linha
-Retorna a mensagem previamente
deslocada a sua posição original
Fixa o modo de 0 0 0 0 0 0 0 1 X S -Estabelece o sentido de deslocamento do
funcionamento cursor (X=0 p/ esquerda, X=1 p/ direita)
-Estabelece se a mensagem deve ou não
ser deslocada com a entrada de um novo 40 uS
caracter (S=1 SIM, X=1 p/ direita)
-Esta instrução tem efeito somente durante
a leitura e escrita de dados.
Controle do 0 0 0 0 0 0 1 D C B -Liga (D=1) ou desliga display (D=0)
Display -Liga(C=1) ou desliga cursor (C=0) 40 uS
-Cursor Piscante(B=1) se C=1
Desloca cursor 0 0 0 0 0 1 C R * * -Desloca o cursor (C=0) ou a mensagem
ou mensagem (C=1) para a Direita se (R=1) ou esquerda
se (R=0) 40 uS
- Desloca sem alterar o conteúdo da
DDRAM
Fixa o modo de 0 0 0 0 1 Y N F * * -Comunicação do módulo com 8 bits(Y=1)
utilização do ou 4 bits(Y=0)
módulo LCD -Número de linhas: 1 (N=0) e 2 ou mais
(N=1) 40 uS
-Matriz do caracter: 5x7(F=0) ou
5x10(F=1)
- Esta instrução deve ser ativada durante a
inicialização
Posiciona no 0 0 0 1 -Fixa o enderço na CGRAM para
endereço da Endereço da CGRAM posteriormente enviar ou ler o dado (byte) 40 uS
CGRAM
Posiciona no 0 0 1 -Fixa o enderço na DDRAM para
endereço da Endereço da DDRAM posteriormente enviar ou ler o dado (byte) 40 uS
DDRAM
Leitura do 0 1 B -Lê o conteúdo do contador de endereços

Flag Busy F (AC) e o BF. O BF (bit 7) indica se a 0
AC
última operação foi concluída (BF=0
concluída) ou está em execução (BF=1).
Escreve dado 0 1 - Grava o byte presente nos pinos de dados
na CGRAM / Dado a ser gravado no LCD no local apontado pelo contador de 40 uS
DDRAM endereços (posição do cursor)
Lê Dado na 1 1 - Lê o byte no local apontado pelo
CGRAM / Dado lido do módulo contador de endereços (posição do cursor) 40 uS
DDRAM
Tabela 5 - Conjunto de instruções do módulo LCD
7
Display LCD
3.1 - DESCRIÇÃO DETALHADA DAS INSTRUÇÕES
3.1.1- Limpa Display

RS R/W B7 B6 B5 B4 B3 B2 B1 B0
CÓDIGO 0 0 0 0 0 0 0 0 0 1
MSB LSB
Esta instrução escreve o caracter ASCII 32 que corresponde ao branco ou barra de espaço em todos os endereços da DDRAM
apagando a mensagem que estiver escrita. O cursor retorna ao endereço “zero”, ou seja, à posição mais a esquerda da primeira
linha.
3.1.2 - Cursor Home
CÓDIGO 0 0 0 0 0 0 0 0 1 *
MSB LSB
Faz retornar o cursor para a posição mais a esquerda da primeira linha e faz voltar à posição original mensagens previamente
deslocadas. O conteúdo da DDRAM permanece inalterado.
3.1.3 - Fixa o modo de operação
CÓDIGO 0 0 0 0 0 0 0 1 X S
MSB LSB
Esta instrução tem efeito somente durante a leitura ou escrita de dados, portanto, deve ser ativada na inicialização.
§ Estabelece o sentido de deslocamento do cursor (X=0 p/ esquerda, X=1 p/ direita)
§ Estabelece se a mensagem deve ou não ser deslocada com a entrada de um novo caracter
S=1 SIM, S=0 NÃO. Exemplo: X=1 e S=1 => mensagem desloca p/ direita.
3.1.4 - Controle do Display
CÓDIGO 0 0 0 0 0 0 0 D C B
MSB LSB
A mensagem fica aparente quando D=1 e desaparece quando D=0, porém o conteúdo da DDRAM fica inalterado. O cursor fica
aparente quando C=1 e desaparece quando C=0, porém as propriedades de escritas vigentes permanecem inalteradas. O
cursor quando aparente liga a última linha que compõem o caracter, exceto quando B=1, que apresenta em alternância com uma
matriz com todos os pontos negros em intervalos de 0,4 segundos. Quando B=1 e C=0, obteremos a ativação intermitente de uma
matriz completa (todos os pontos da matriz).
3.1.5 - Deslocamento do Cursor ou da Mensagem
CÓDIGO 0 0 0 0 0 1 C R * *
MSB LSB
8
Display LCD
Desloca o cursor ou a mensagem sem que para isso tenha que escrever ou ler dados do display. Utilizado para posicionamento dos
dados no display.
C R FUNÇÃO
0 0 Desloca o cursor para a esquerda e decrementa o contador de endereço.
0 1 Desloca o cursor para a direita e incrementa o contador de endereço.
1 0 Desloca a mensagem e o cursor para a esquerda.
1 1 Desloca a mensagem e o cursor para a direita
3.1.6 - Estabelece o modo de utilização do Módulo LCD
CÓDIGO 0 0 0 0 1 Y N F * *
MSB LSB
Y estabelece o modo de comunicação. Se Y=1 estabelece 8 bits e quando Y=0 será 4 bits, enviados em duas operações, com os 4
bits (Nible) mais significativos sendo enviados primeiro. N fixa o número de linhas: N=0 para uma linha e N=1 para duas ou
mais linhas. F fixa o tipo da matriz: F=0 para matriz 7x5 ou 8x5 e F=1 para matriz 10x5 (somente possível quando apresentando
em uma linha).
3.1.7 - Endereçamento da CGRAM
CGRAM é uma região da memória RAM destinada para criação de caracteres especiais, como por exemplo: ç, é, Ê, etc.
CÓDIGO 0 0 0 1 A A A A A A
MSB LSB
Estabelece o endereço da CGRAM no contador de endereços (AC) como um número binário AAAAAA e após isto os dados serão
escritos ou lidos pela CPU neste endereço. Cada caracter especial ocupa 8 endereços na CGRAM.
3.1.8 - Endereçamento da DDRAM
CÓDIGO 0 0 1 A A A A A A A
MSB LSB
Estabelece o endereço da DDRAM no contador de endereços (AC) como um número binário AAAAAAA e após isto os dados
serão escritos ou lidos pela CPU neste endereço. Para os display de uma linha AAAAAAA varia de 80H a CFH. Já para todos os
display de duas linhas varia de 80H a A7H para a primeira linha e de C0H a E7H para a segunda linha.
3.1.9 - Busy Flag (BF)
CÓDIGO 0 1 BF A A A A A A A
MSB LSB
Busy Flag ou o bit 7 indica ao sistema onde está conectado o módulo LCD, se o controlador do módulo está ocupado com alguma
operação interna (BF=1), e neste caso, não aceita nenhuma instrução até que BF volte para 0.
Além disso, permite a leitura do conteúdo do contador de endereços (AC) expressa por AAAAAAA. O contador de endereços
pode conter tanto endereço da CGRAM como da DDRAM, depende neste caso, da instrução anterior.
9
Display LCD
3.1.10 - Escrita de dados na DDRAM ou CGRAM
CÓDIGO 1 0 A A A A A A A A
MSB LSB
Escreve o byte AAAAAAAA tanto na CGRAM como na DDRAM, dependendo da instrução anterior (que define o endereço).
Após a escrita, o endereço é automaticamente incrementado ou decrementado de uma unidade dependendo do modo escolhido
(ver item 3.1.3).
3.1.11 - Leitura de dados na DDRAM ou CGRAM
CÓDIGO 1 1 A A A A A A A A
MSB LSB
Faz uma leitura na CGRAM ou na DDRAM, dependendo da instrução anterior (que define o endereço). É importante que
precedendo a esta leitura seja executado a instrução de estabelecimento do endereço da CGRAM ou DDRAM, pois caso contrário
o dado lido é inválido.
3.2 - TABELAS DE ENDEREÇOS DOS CARCTERES NA DDRAM

A seguir resumiremos os endereços da DDRAM (em hexadecimal) dos caracteres da maioria dos módulos LCD disponíveis no
mercado.
Caracter
Módulo 8x1 1 2 3 4 5 6 7 8
Endereço(hexa) 80 81 82 83 84 85 86 87
LCD 16x1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
80 81 82 83 84 85 86 87 88 89 8 8B 8C 8 8E 8F
A D
LCD 16x1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
80 81 82 83 84 85 86 87 C0 C1 C2 C3 C4 C5 C6 C7
LCD 16x2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
linha 1 80 81 82 83 84 85 86 87 88 89 8 8B 8C 8 8E 8F
A D
linha 2 C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 C C C C C C
A B C D E F
10
Display LCD
LCD 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
20x2
linha 1 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93
linha 2 C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF D0 D1 D2 D3
LCD 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
20x4
linha 1 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93
linha 3 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93
LCD 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
24x1
LCD
24x2
linha 1 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97
linha 2 C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7
LCD 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
40x1
a LCD
40X4
linha 1 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93
linha 3 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93
Cont. 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
linha 1 94 95 96 97 98 99 9A 9B 9C 9E 9D 9F A0 A1 A2 A3 A4 A5 A6 A7
linha 2 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7
linha 3 94 95 96 97 98 99 9A 9B 9C 9E 9D 9F A0 A1 A2 A3 A4 A5 A6 A7
linha 4 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7
OBS:
§ Para os módulos de 04 linhas estamos considerando que existe um outro pino de habilitação (como o pino 6) para as duas
últimas linhas, portando outros endereços de hardware.
§ Antes de enviar uma instrução para escrita de dados no display, enviar antes uma de endereçamento na DDRAM, com o
endereço onde deve ser escrito o caracter, tipo um gotoxy().
11
Display LCD
3.3 - TABELAS DE ENDEREÇOS DOS CARCTERES NA CGRAM
Os caracteres especiais previamente programado, durante a inicialização, podem ser utilizados a qualquer tempo como se fossem
caracteres normais, lembrando que os endereços bases em hexadecimal para gravação dos caracteres especiais, na maioria dos
módulos LCD, são respectivamente: 40, 48, 50, 58, 60, 68, 70 e 78. Cada caracter especial ocupa 8 (oito) endereços.
RS R/W Dado em Binário HEXA

Endereço 50 0 0 0 1 0 1 0 0 0 0 50
50 1 0 x x x 0E
51 1 0 x x 11
52 1 0 x 10
53 1 0 x 10
54 1 0 x x x 15
55 1 0 x x x 0E
56 1 0 x 10
57 1 0 00*
Tabela 7 - Caracter especial {ç} na CGRAM
Isto significa que para utilizarmos o caracter gravado no endereço base 50, durante a inicialização ou reset do sistema, teremos
que escrevermos 8 bytes entre os endereços 50 e 57, para construirmos o caracter. Para ilustrar este procedimento, supor que
queiramos construir o caracter {ç} no endereço base 50. Neste caso, devemos construir o mapa deste caracter especial como
mostrado na Tabela 7 (supondo estar trabalhando com matriz 7x5 e com auto incremento de endereço a cada escrita). Observe
que o último endereço sempre será 00, pois esta posição é sempre ocupada pelo cursor.
3.4 - INICIALIZAÇÃO DOS MÓDULOS LCD

Toda vez que alimentamos o módulo LCD deve ser executado o procedimento de inicialização, que consiste no envio de uma
seqüência de instruções para configurar o modo de operação para execução de um dado programa de interfaceamento. Em muitos
display este procedimento ocorre automaticamente, dentro de condições específicas que envolve temporizações mínimas referente
a transição do nível lógico 0 para 1, ao ligarmos a fonte. Em caso de dúvidas, recomendamos o envio destas instruções após o
reset do sistema.
3.4.1 - Inicialização para sistemas 8 bits de dados (5 instruções)

Entre as duas primeiras instruções recomendamos um delay de 15 mS. As demais instruções podem ser escritas após checar o
Busy Flag.
Instruções em Hexadecimal (8 bits)

MÓDULO LCD 1 2 3 4 5
1 linha - Matriz 7x5 e 8x5 30 15m 30 15m 06 BF 0E BF 01
S S
1 linha - Matriz 10x5 34 15m 34 15m 06 BF 0E BF 01
S S
2 linha - Matriz 7x5 e 8x5 38 15m 38 15m 06 BF 0E BF 01
S S
12
Display LCD
3.4.2 - Inicialização para sistemas 4 bits de dados (5 instruções)
Entre as quatro primeiras instruções recomendamos um delay de 15 mS. As demais instruções podem ser escritas após checar o
Busy Flag. Estes bits (nible) devem estar conectados aos pinos 11, 12.13 e 14.
Instruções em Hexadecimal (4 bits)

MÓDULO LCD 1 2 3 4 5 6 7 8 9 10 11 12
1 linha - Matriz 7x5 e 8x5 3 3 3 2 2 0 0 8 0 1 0 1
1 linha - Matriz 10x5 3 3 3 2 2 4 0 8 0 1 0 1
2 linha - Matriz 7x5 e 8x5 3 3 3 2 2 8 0 8 0 1 0 1
13
Display LCD
04. ROTEIRO PARA PROGRAMAÇÃO
A seguir passaremos a descrever um resumo dos procedimentos para utilização de um módulo ou display LCD:
1. Ao energizar o módulo ajuste o potenciômetro de controle do brilho ou contraste até obter a visualização da matriciação na
primeira linha para módulo de duas linhas ou até a matriciação de meia linha para módulos de uma linha.
2. Alguns módulos de uma linha só funcionam com a instrução 38 ao invés de 30, conforme instruções de inicialização.
3. O sinal de Enable (pino 6) deverá ser gerado conforme a temporização mostrada na Figura 2. Os códigos de dados ou de
instruções só serão processados pelo processador do módulo após a descida do sinal do Enable.
4. Para ajustar a velocidade de comunicação entre a CPU do usuário e o módulo LCD existem duas possibilidades:
§ Intercalar uma rotina de atraso de aproximadamente 15 mS entre as instruções.
§ Fazer a leitura do Busy Flag antes do envio de cada instrução e só enviar quando o mesmo for 0. Neste caso, a única
exceção será durante a inicialização.
5. Durante a inicialização enviar a seqüência correta das instruções de inicialização conforme item 3.4
6. Para programar caracteres na CGRAM, faça inicialmente o endereçamento da mesma.
7. Após a escrita de dados na CGRAM envie a instrução 01, para posicionar o cursor.
8. Para escrever os caracteres especiais previamente gravados na CGRAM, utilize os códigos de 00 até 07 correspondente aos
endereços bases de 40, 48 até 78 em hexa.
9. Comandos úteis:
FIXAÇÃO DAS CONDIÇÕES DE UTILIZAÇÃO Instrução

1 linha 5x7 (8 bits) 30H
CONTROLE DISPLAY Instrução

Display aceso c/ cursor fixo 0EH
Display aceso c/ cursor intermitente 0FH
Display aceso sem cursor 0CH
Display apagado 08H
MODO DE OPERAÇÃO Instrução

Escreve deslocando a mensagem para esquerda (cursor fixo) 07H
Escreve deslocando a mensagem para a direita (cursor fixo) 05H
Escreve deslocando o cursor para a direita 06H
Escreve deslocando o cursor para a esquerda 04H
14
Display LCD
OUTROS COMANDOS ÚTEIS Instrução

Limpa display e retorna o cursor para o inicio 01H
Retorna o cursor para o inicio (sem alterar a DDRAM) 02H
Desloca somente o cursor para a direita 14H
Desloca somente o cursor para a esquerda 10H
Desloca o cursor + mensagem para a direita 1CH
Desloca o cursor + mensagem para a esquerda 18H
Desloca o cursor para posição inicial da segunda linha C0H
Desloca o cursor para posição inicial da primeira linha 80H
CGRAM (caracteres especiais) Instrução

Endereço inicial para construir caracteres especiais 40H
Para escrever o primeiro caracter (previamente construídos) 00H
Para escrever o último caracter (previamente construídos) 07H
Obs: Após o endereçamento da CGRAM, o cursor se desloca para a primeira posição da segunda linha (ou metade), portanto é
recomendado enviar a instrução 01 ou “limpa display e cursor home”.
15
Display LCD
05. CUIDADOS ESPECIAIS COM MÓDULOS LCD
5.1 - MANUSEIO
§ Somente retire o módulo de sua embalagem protetora imediatamente antes de sua instalação
§ Não guarde os módulos em recintos de alta temperatura e alta umidade. A temperatura de armazenamento deverá estar
compreendida entre 5 e 30 oC.
§ O LCD é coberto por uma lâmina plástica polarizada a qual não pode ser riscada. Cuidado em seu manuseio. Para a limpeza
da lâmina utilize cotonetes embebido em benzina. Não utilize outros tipos de solventes.
§ Observe cuidadosamente os procedimentos de controle anti-estático quando manusear os módulos. Eles incorporam circuitos
integrados CMOS LSI os quais são sensíveis à descarga eletrostática. Não toque nos terminais do conector, trilhas do circuito
impresso e/ou terminais do CI.
5.2 - INSTALAÇÃO
§ Nunca desmonte o módulo
§ Use uma estação de solda aterrada para soldagem de conectores ou terminais.
§ montador deverá também ser convenientemente aterrado.
§ Sempre que o projeto o permita, instale o módulo atrás de uma janela protetora de plástico ou vidro.
§ Somente retire a fita adesiva que protege a lâmina plástica frontal imediatamente antes de seu uso.
5.3 - OPERAÇÃO
§ Nunca instale ou desconecte o módulo com sua alimentação ligada.

§ Sempre opere os módulos respeitando sua gama de temperatura de operação.
§ Observe cuidadosamente os valores das tensões de alimentação e os níveis dos sinais de controle.
§ Ajuste a tensão no pino 3 (V0) para obter o contraste mais conveniente para uma dada aplicação.
16
Display LCD
06. EXEMPLO DE PROGRAMAÇÃO
Baseado no hardware da Figura 3, eaborar um programa em assembler para o 8031 que escreva no módulo LCD a seguinte
mensagem: “Vila Nova”.
;=======================================================================
; Programa: Exemplo para manuseio de display ou modulo LCD
; Autor: Ilton L. Barbacena
; Data: Out/96
; Compilador: ASM51.EXE / versao shareware para 8051 / $mod51
; versao: 1.0
; Descricao: Este programa grava a mensagem "Vila Nova"
; no display LCD 2x20 (duas linha de 20 caracteres).
; Os pinos de dados do mudulo LCD estao conectados
; diretamente no barramento de dados da CPU, conforme
; Figura 3 da apostila sobre LCD.
;=======================================================================
$mod51
lcd_wr_inst equ 4000H
lcd_wr_dado equ 4001H
lcd_rd_inst equ 4002H
lcd_rd_dado equ 4003H
;========================================================================
; Programa principal
;========================================================================
ORG 0H
MOV SP,#50H
MOV TMOD,#11H ; TIMER1 / TIMER0 no modo 1
CLR EA ; desabilita todas as interrupcoes
CALL inicia_lcd
MOV R7,#0FFH
loop: INC R7
MOV A,R7
MOV DPTR,#mensagem
MOVC A,@A+DPTR ; le caracter da mensagem
CJNE A,#0FFH,cont ; testa se fim da mensagem
JMP fim
cont: CALL wr_dado ; escreve o conteudo de acumulador no LCD

CALL espera ; aguarda busy flag
JMP loop
fim: JMP fim ; fim do programa
17
Display LCD
;=======================================================================
; Rotinas chamadas pelo Programa Principal
;=======================================================================
ORG 100H
inicia_lcd: ; rotina de inicializacao

MOV A,#38H ; 2 linhas / matriz 7x5
CALL wr_inst
CALL tempo ; delay de 15mS
MOV A,#38H ; 2 linhas / matriz 7x5
CALL wr_inst
CALL tempo ; delay de 15mS
MOV A,#06H ; cursor com autoincremento para direita
CALL wr_inst
CALL espera ; busy flag
MOV A,#0EH ; liga display / cursor
CALL wr_inst
MOV A,#01H ; limpa display / cursor home
CALL wr_inst
RET
espera: ; rotina para aguardar busy flag

CALL rd_inst ; ler busy flag e retorna em A
RLC A ; bit7=BF vai para o carry
JC espera ; se BF=1 => verifica novamente
RET
wr_inst: ; escreve a instrucao em A no LCD

MOV DPTR,#lcd_wr_inst
MOVX @DPTR,A
RET
wr_dado: ; escreve o dado em A no LCD

MOV DPTR,#lcd_wr_dado
MOVX @DPTR,A
RET
rd_inst: ; le o Busy Flag e o contador de endereco

MOV DPTR,#lcd_rd_inst
MOVX A,@DPTR ; retorna em A
RET
rd_dado: ; le dado / de qual endereco?

MOV DPTR,#lcd_rd_dado ; depende da ultima operacao no LCD
MOVX A,@DPTR ; retorna em A
RET
18
Display LCD
;=========================================================
; Rotina de tempo: 15 mS / clock 12 MHz => 50.000 ciclos
;=========================================================
tempo:
MOV DPTR,#15536 ; (65536-50000)
MOV TH1,DPH
MOV TL1,DPL
SETB TR1 ; dispara timer1
JNB TF1,$ ; aguarda estouro => 50.0000
CLR TR1
CLR TF1 ; prepara para proxima chamada
RET
mensagem: ; mensagem a ser escrita no LCD

DB 'Vila Nova', 0FFH
END ; obrigatorio
Exercício para praticar:
Repetir o exercício anterior, porém com a mensagem “Escola Técnica”. Construir o {é} na CGRAM. Lembre-se que apenas os
códigos ascii são caracteres válidos para o LCD (verificar a tabela no manual do fabricante).
19
PIC: Conversor A/D e LCD
OBJETIVOS
• Compreender a operação do conversor A/D do PIC;
• Aprender a utilizar as funções do drive de LCD ;
• Desenvolver uma IHM usando o LCD e o teclado da placa de experimentos;
CONVERSOR A/D
O módulo do conversor A/D possui 8 entradas analógicas, que possuem um capacitor de sample-
and-hold. A saída do sample-and-hold é conectada a entrada do conversor A/D a partir de um
multiplex 8 x 1. O conversor A/D gera uma palavra binária de 10 bits para representar o valor de
tensão na entrada analógica selecionada.
O módulo A/D tem duas entradas de tensão de referência (alta e baixa), que são selecionadas por
software, entre algumas opções de combinação pré-estabelecidas. Uma característica apenas
presente no módulo conversor A/D é que o mesmo pode operar mesmo o PIC estando no modo
SLEEP. Para operar neste modo o sinal de clock do conversor A/D (CAD) deve ser derivado do
oscilador RC interno do PIC.
O conversor A/D possui quatro registradores:
• Registrador do byte mais significado do resultado da conversão (ADRESH);
• Registrador do byte menos significado do resultado da conversão (ADRESL);
• Registrador de controle 0 (ADCON0) e
• Registrador de controle 1.
Os registradores ADRESH:ADRESL contém os 10 bits do resultado da conversão. Quando a

mesma é concluída, o resultado é carregado nesses registradores, o bit GO/DONE (bit 2 do Reg.
ADCON0) é resetado e o flag de interrupção, bit ADIF, é setado.
Após a configuração do módulo como desejado, o canal cujo sinal analógico deve ser convertido,
deve ser selecionado antes da conversão ser iniciada. Os canais de entrada analógicos devem ter
seus correspondentes bits TRIS ajustado para que os pinos das portas A e E se comportem como
entradas. Após o período de aquisição do sinal ter finalizado (aproximadamente 20µs) a
conversão A/D pode ser iniciada conforme os seguintes passos:
1. Configure o módulo A/D

• Configure os pinos de entrada analógica, as tensões de referência e os pinos de I/O
digital (ADCON1);
• Selecione o canal de entrada analógica (ADCON0);
• Selecione a freqüência do sinal de clock do conversor A/D (ADCON0);
• Ative o módulo A/D;
2. Configure a interrupção do módulo A/D (se desejado);
• Resete o bit ADIF;
• Sete o bit ADIE;
• Sete o bit GIE;
3. Aguarde o tempo de aquisição requerido;
4. Inicie a conversão
1
• Sete o bit GO/DONE (ADCON0)
5. Aguarde o tempo de conversão ter transcorrido;
• Realize um POLLING no bit GO/DONE, verificando se o seu valor é zero
(indicativo de fim de conversão A/D);
• ou aguarde pela interrupção gerada pelo módulo A/D ao fim da conversão;
6. Leia o par de registradores (ADRESH:ADRESL), resete o bit ADIF se a interrupção do
conversor A/D está sendo utilizada;
7. Para realizar uma nova conversão retorne ao passo 1 ou 2 (antes de uma nova conversão
ser iniciada, deve ser aguardado um tempo de 2TAD, que é o tempo de conversão por bit,
cujo valor é definido na tabela 1).
O conversor A/D necessita de no mínimo 12 TAD para realizar uma conversão de 10 bits. A fonte
do clock do conversor A/D é selecionada por software entre as possibilidades abaixo:
• 2Tosc
• 8Tosc
• 32Tosc
• Oscilador RC interno
Para uma conversão correta, o clock do conversor A/D deve ser selecionado para garantir um TAD
mínimo de 1.6µs. A tabela 1 mostra os valores de TAD em função da seleção da fonte do clock.
Tabela1 – TAD x Máxima freqüência de conversão
Se o bit GO/DONE for resetado durante uma conversão, esta será abortada. Os registradores de
resultado do módulo A/D não serão atualizados com a parcialmente concluída conversão. Assim,
os registradores ADRESH:ADRESL continuaram armazenando o valor da última conversão
concluída (ou o último valor escrito para os registradores ADRESH:ADRESL). Após uma
conversão ser abortada, um tempo de 2TAD é necessário antes de uma nova conversão ser
iniciada. Após este tempo, a aquisição do canal selecionado é automaticamente iniciada.
O par de registradores ADRESH:ADRESL comporta 16 bits, assim, o valor convertido de 10 bits
pode ser justificado a direita ou à esquerda, de acordo com o bit seleção de formato do conversor
A/D (ADFM), que controla a justificação. Os bits extras não utilizados são carregados com “0”
(zeros). Quando o módulo A/D não estiver sendo utilizado, os registradores ADRESH:ADRESL
podem ser usados como dois registradores de propósito geral de 8 bits.
2
Justificação do resultado da conversão A/D
Diagrama de blocos do conversor A/D
3
Registrador ADCON0 - Controla a operação do módulo A/D.
4
Registrador ADCON1 – Configura a função dos pinos das portas (A e E)
Os registradores ADCON1 e TRIS controlam a operação dos pinos das portas A/D. Os pinos das
portas que serão entradas analógicas devem ter seus correspondentes bits TRIS setados. Se o bit
está resetado, o nível de tensão da saída digital será convertido. A operação do conversor A/D
independe do estado dos bits CHS2:CHS0 e dos bits TRIS
Observações:
1 – Quando o registrador da porta é lido, qualquer pino configurado como um canal de entrada
analógica será lido como zero (nível baixo). Pinos configurados como entradas digitais irão se
converter em entradas analógicas. Níveis analógicos em uma entrada configurada como digital,
não afetarão a precisão da conversão.
2 – Níveis analógicos em qualquer pino que é definido como uma entrada digital (incluindo os
pinos AN7:AN0) podem fazer com que o buffer de entrada consuma corrente que está fora das
especificações do dispositivo.
5
Registradores associados com o módulo do conversor A/D
As rotinas abaixo implementam as funções utilizadas para escrever

caracteres e/ou mensagens em um LCD (Display de Cristal Líquido) de 16
colunas por 2 linhas.
/*=====================================================================
=======================================================================
ARQUIVO - DRIVER: LCD_16x2_LIB.C
DATA DE CRIAÇÃO: 03/11/2003
REVISÃO: 1.0
DATA DA ULTIMA REV: 03/12/2004
ULTIMA REV: 1.1
MICROCONTROLADOR: FAMILIA PIC
FUNÇÃO:
DESCRIÇÃO: BIBLIOTECA DE MANIPULAÇÃO DO DISPLAY DE CRISTAL

LÍQUIDO (LCD 16X2).
AUTOR: TÉC. LÚCIO HÉLIO
=======================================================================
=====================================================================*/
#ifndef CS_LCD
#define CS_LCD PIN_E0 // Pino de Controle "CS - CHIP

//SELECT" do LCD --------- (pino 6).
#define RS_LCD PIN_E1 // Pino de Controle "RS - REGISTER
//SELECT" do LCD ----- (pino 4).
#define D4_LCD PIN_D4 // Pino do Barramento de Dados "D4 - Dado
//4" do LCD --- (pino 11).
//5" do LCD --- (pino 12).
//6" do LCD --- (pino 13).
//7" do LCD --- (pino 14).

Apostila 01

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila 01

Enviado por

Direitos autorais:

Formatos disponíveis

1

ELETRÔNICA DIGITAL – APOSTILA 01

Displays de Cristal Líquido

SÃO JOSÉ DOS CAMPOS, SP

Tutorial LCD em 4 vias 3

Tutorial LCD em 4 vias 5

Tutorial LCD em 4 vias 7

Figura 1: Display 08X02 sem back-light

Figura 2: Display 16X01 sem back-light

Figura 3: Display 16X02 com back-light

Tutorial LCD em 4 vias 9

Figura 5: Display 20X01 sem back-light

Figura 6: Display 20X02 sem back-light

Figura 7: Display 20X04 com back-light

Alguns módulos possuem iluminação em "back-light" e estão disponíveis nas cores

Tutorial LCD em 4 vias 10

Basicamente, cada "célula" (caractere) do LCD é composto de 8 pixels na horizontal e

Figura 8: O padrão de cada célula de um display 5X7 (em mm)

Tutorial LCD em 4 vias 11

Basicamente os LCDs alfa numéricos seguem um padrão de especificação de interface,

Tutorial LCD em 4 vias 12

Tutorial LCD em 4 vias 13

Figura 10: LCD 16X02 energizado, mas não inicializado.

Limpa o display e seta contador de

Read Data 1 1 Dado Lê dados da DDRAM ou da CGRAM 3

x : Sem 1 Incrementa 1 Deslocamento para a direita

Tabela 2: Instruções para inicialização e configuração do LCD

Tutorial LCD em 4 vias 14

Tabela 3: Configurações possíveis para o LCD

Tutorial LCD em 4 vias 15

Tutorial LCD em 4 vias 16

Tabela 4: Os caracteres do ROM Code A00

Tabela 5: Os caracteres do ROM Code A02

Tutorial LCD em 4 vias 18

Figura 11: Endereçamento direto para um LCD 16X02

Figura 12: Endereçamento com deslocamento para um LCD 16X02

Tutorial LCD em 4 vias 19

Figura 13: Endereçamentos com deslocamento para diversos LCDs

Parte 6 - Rotacionando o LCD

Parte 7 - A CGRAM – Caracteres definidos pelo usuário

Os endereços 00000000 a 00000111 (0x00 a 0x07) são reservados para os caracteres

Tutorial LCD em 4 vias 20

Se desejarmos criar um “robozinho”, devemos preencher esta matriz da seguinte forma:

Figura 15: Criando um robô na CG RAM

Figura 16: O robô, traduzido em bits

Tutorial LCD em 4 vias 21

Tutorial LCD em 4 vias 22

O LCD baseado no controlador Hitachi HD44780 ou no controlador KS0066U possuem 8

Figura 17: Inicializando em 8 vias

Tutorial LCD em 4 vias 23

O controlador HD44780 ou o KS0066U, encontrados na maioria dos módulos de LCDs

Tutorial LCD em 4 vias 24

Tutorial LCD em 4 vias 25

Antes de passarmos definitivamente para a parte prática deste tutorial, precisamos

Parâmetro Descrição Tempo

Tutorial LCD em 4 vias 26

Tutorial LCD em 4 vias 27

Tutorial LCD em 4 vias 29

Figura 20: Esquemático para a placa de testes de LCD

Figura 23: Placa de testes conectada ao McPlus via conector ICSP

Tutorial LCD em 4 vias 32

Tutorial LCD em 4 vias 33

Parte 1 – Comunicação em 8 vias pela McLAB2

/ Rotina que envia um COMANDO para o LCD /

/ Função para limpar o LCD /

/ Inicialização do Display de LCD /

/ Tela Principal /

/ Configurações do PIC /

/ Rotina principal /