Os Display LCD Alfanumericos

Centro de Tecnologia Microgenios - Todos os direitos reservados

Clique aqui para Imprimir o doc umento

Os Displays LCD Alfanuméricos

1.0 Introdução

1.1 Hardware e Pinagem

1.2 Endereços de cada caractere no LCD 16x2

1.3 LCD Modo 8 Bits

1.4 LCD Modo 4 bits - Somente um port de controle/dados

1.5 LCD Modo 4 bits - Controlado por dois ports do PIC

Introdução

Agora que já conhecemos os recursos fundamentais da linguagem C, estamos prontos para criar nossos

programas para controle de equipamentos. Estudaremos as principais funções e ferramentas para

manipular displays LCD. Para implementar nossos projetos é interessante a utilização de um display,

capaz de tornar mais simples a visualização de informações e a interação com nosso equipamento,

escolhemos para tratar nesta obra de um display de utilização muito comum em sistemas

microcontrolados, suas características são as seguintes:

Tipo: Display LCD Exibição: Caracteres Alfanuméricos Quantidade de informações: 16 x 2 (dezesseis caracters em 2 linhas) Controlador: padrão HD44780 Hitchi

Um display LCD desse tipo, possui embutido em seu circuito um outro microcontrolador, e para

podermos utilizá-lo temos que entender um pouco de seus comandos e funções. Dessa forma, da mesma

maneira com que trabalhamos com o PIC, para utilizar um display LCD temos que seguir uma sequência

de procedimentos.

Hardware e Pinagem

Existem modelos diferentes, com localização diferente da pinagem, porém a numeração e função dos

pinos geralmente é a mesma, nos kits didáticos e profissionais Microgenios é utilizado o LCD

apresentado em seguida:

Descrição das Pinagens:

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 figura1)

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 -

desabilita

7 B0 LSB

8 B1

9 B2

10 B3

11 B4 barramento de dados

12 B5

12 B6

14 B7 MSB

15 A (display

c/ back) Anodo p/ LED backlight

16 K (display

c/ back) Catodo p/ LED backlight

Além da pinagem é importante entendermos uma outra característica de hardware

desse dispositivo, que são suas áreas de memória; ele possui três áreas de

memória com funções bem diferentes:

CGROM: Memória não volátil onde estão gravados os códigos para escrita dos

caracteres, isso é muito útil, pois apenas enviamos o código ASCII do caracter e esse já é escrito no display.

DDRAM: É uma área de memória volátil, onde escrevemos o que queremos que

apareça no display, cada endereço dessa memória equivale a um endereço de

caracter dos display, podemos fazer a seguinte analogia para facilitar, cada caracter do display é como uma “janela” que exibe o conteúdo que escrevemos na DDRAM.

CGRAM: É uma pequena área de memória onde podemos “desenhar” caracteres

diferentes (apenas 8 caracteres). Ela é muito utilizada quando precisamos criar

caracteres que não são comuns a todas as línguas como por exemplo o caracter “ç”

do português.

Endereço de cada caracter no display 16 x 2

Abaixo está o endereço em hexadecimal de cada caracter no display LCD 16 x 2, assim fica mais fácil a movimentação do cursor e das letras a serem escritas:

Lista de códigos dos Caracteres

A seguir o código que devemos enviar para o LCD a fim de obtermos um determinado caracter:

Endereços e Instruções Agora conhecemos a pinagem desse LCD, vamos conhecer seu modo de

funcionamento e saber um pouco mais das instruções e dados que precisaremos

utilizar.

É interessante atentarmos para a seguinte característica, a via de dados e

instruções é a mesma, dessa forma a sinalização, que indica se o Byte que chega

no display é dado ou instrução é proveninte do sinal encontrado no pino 4 (RS): RS = 0 -> Instrução RS = 1 -> Dado Outra característica importante é que precisamos pulsar (de 1 para 0) o sinal

Enable (pino 6) para que a informação que chega aos terminais do LCD seja

interpretada pelo controlador do display. Em nosso estudo manteremos o pino 5 (R/W) em zero, pois apenas escreveremos

no LCD. Podemos ligar este pino do LCD no PIC também. Para utilizarmos esse novo dispositivo em nossos projetos, devemos seguir

alguns passos: 1º Inicializar o LCD: Primeiramente criar uma rotina em nosso programa, que envie

para o display uma sequência de informações que determinará o modo com o qual

trabalharemos, com por exemplo: - Definição da matriz de pontos (nosso caso 5 x 7) - Definição do cursor - Definição da direção de deslocamento (mensagem ou cursor) - Limpeza do display.

O mikroC automaticamente carrega as rotinas de inicilização do LCD na compilação de

um programa. O programador não precisa se preocupar em inicilizar o LCD desde que o

hardware do dispositivo esteja configurado no programa corretamente no modo 4 ou 8

bits; (veremos com detalhes mais adiante).

Tabelas de Instruções

Na seqüência disponibilizamos as tabelas de instruções para esse tipo display, como nosso objetivo não é o estudo do display propriamente dito, aconselhamos aos interessados nesse dispositivo que procurem bibliografias dedicadas a eles para um maior detalhamento das funções.

Tabela com o conjunto completo de instruções:

Tabela com as instruções mais comuns:

Resumo com as instruções mais úteis:

Endereços de cada caractere no LCD 16x2

Abaixo está o endereço em hexadecimal de cada caracter no display LCD 16 x 2,

assim fica mais fácil a movimentação do cursor e das letras a serem

escritas:(ENDEREÇOS EM HEXADECIMAL)

80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F

C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF

Inicialização do LCD

Toda vez que alimentarmos o LCD, devemos executar um procedimento de

inicialização, o qual consiste em enviar comandos que configuram o modo de operação

para execução de um dado programa: fixação das condições de utilização, fixação do

modo de controle ativo/inativo do display e limpeza da tela.

No mikroC não precisamos nos preocupar em programar todos os comandos

de inicialização do LCD, pois, através de simples funções, o compilador se encarrega

de programá-lo para nós. Por esse motivo devemos informar ao sistema o “tipo” de

LCD que estamos utilizando por meio de linhas de comando. A seguir, vamos conhecer

e estudar as instruções de controle de LCD usadas no mikroC.

Definindo o modo de operação do LCD.

Os LCD's podem ser programados para operarem das seguintes formas:

modo 8 bits modo 4 bits

No mikroC é possível trabalhar com os LCD's nos dois modos. no modo 8 bits. no modo 4 bits - somente um port de controle/dados no modo 4 bits - com dois ports para controle e dados do LCD

LCD Modo 8 Bits

No modo 8 bits, todos os pinos do barramento de dados do LCD são utilizados,

conforme figura abaixo:

Repare que todos os 8 pinos do barramento de dados do LCD (D0 a D7) estão ligados

no microcontrolador PIC, neste modo, estamos enviando as instruções e comandos para

o LCD em 8 bits.

O compilador mikroC possui diversas bibliotecas de funções prontas para trabalharmos

com displays LCD. Para exemplificar, vamos apresentar um programa em C que utiliza

os recursos das funções de controle de LCD do compilador mikroC, acompanhe:

/*********************************************************************

*****

Centro de tecnologia Microgenios

Programa exemplo: LCD_modo_8bits.c

Este programa tem por objetivo escrever a mensagem "Microgenios" na

primeira

linha do LCD e na segunda "Kit PICGENIOS".

**********************************************************************

****

*/

void main()

{

trisd = 0; //configura todos os pinos do portd como saída

trise = 0; //configura todos os pinos do porte como saida

ADCON1 = 0x06; //configura todos os pinos de A/D como I/O de uso geral

lcd8_config(&porte, &portd,2,1,0,7,6,5,4,3,2,1,0); //configura e

inicializa o LCD

lcd8_cmd(lcd_clear); //apaga LCD

lcd8_cmd(lcd_cursor_off); // desliga cursor

lcd8_out(1,1,"Microgenios"); // escreve mensagem na primeira linha do

LCD

lcd8_out(2,1,"KIT PICGENIOS"); // escreve mensagem na segunda linha do

LCD

delay_ms(10); //delay de 10 ms

while(1); //loop infinito

}

Descrição detalhada do programa:

O programa acima tem a função de escrever no LCD 16X2 duas mensagens

"Microgenios" na primeira linha do LCD, e "KIT PICGENIOS" na segunda linha do

LCD.

A função main(), já conhecemos.

Os comando abaixo definem os sentidos das portas de i/o do PIC.




Os comandos seguintes controlam o display LCD no modo 8 bits. Vamos estudar cada

um dos comandos:

O comando lcd8_config ( ):

O comando lcd8_config determina quais são os pinos do barramento de dados e de

controle do LCD que estão ligados ao PIC, assim como também inicializa o LCD.

Sintaxe:

lcd8_config(&port_controle, &port_dados, RS, EN, RW, D7, D6, D5, D4,

D3, D2, D1, D0 );

Onde:

port_controle e port_dados pode ser: PORTA, PORTB, PORTC, PORTD ou PORTE.

RS : pino do port_controle que determina o bit de instruções ou dado do LCD.

EN : pino do port_controle que determina o bit de "enable" do LCD.

RW : pino do port_controle que determina o bit de leitura /escrita do LCD.

(nolmalmente coloca-se este pino do LCD no GND).

D7 à D0: Pinos do port_dados

Vejamos nosso exemplo de programa:


inicializa o LCD

A função lcd8_config acima, determina os PORTs e os pinos que participam do

controle do LCD:

Port que controla o LCD:

PORTE

Funções dos pinos de controle do port de controle:

RS: 1 //pino RE2

EN: 1 //pino RE1

RW: 0 //pino RE0

Port de dados do LCD;

PORTD

Funções dos pinos do port de dados no LCD;

D7: 7 //pino RD7 do PORTD








Configuramos então nosso lcd conforme figura abaixo:

Apartir desta primeira linha de programa, concluimos que nosso LCD esta ligado da

seguinte maneira:

Repare que o pino R/W do LCD foi aterrado. No comando Lcd8_config informamos

que o pino RW era RE0 do PIC.

O comando lcd8_cmd(comandos_LCD):

No mikroC podemos configurar o LCD de diversas formas diferentes. Através da

função lcd8_cmd(), podemos determinar diversas "tarefas" que o LCD deverá executar.

Acompanhe:

Sintaxe:

Lcd8_cmd(comandos_LCD);

onde:

Comando_LCD pode ser:

Comandos Descrição LCD_FIRST_ROW Move cursor para primeira linha do LCD LCD_SECOND_ROW Move cursor para segunda linha do LCD LCD_THIRD_ROW Move cursor para a terceira linha do LCD LCD_FOURTH_ROW Move cursor para a quarta linha do LCD LCD_CLEAR Apaga display LCD_RETURN_HOME Retorna cursor para a primeira coluna da primeira linha do LCD LCD_CURSOR_OFF Desliga cursor LCD_UNDERLINE_ON Salta cursor para a linha inferior LCD_BLINK_CURSOR_ON Ativa o modo piscante do cursor LCD_MOVE_CURSOR_LEFT Move cursor para a esquerda sem movimentar os textos LCD_MOVE_CURSOR_RIGHT Move cursor para a direita sem movimentar os textos LCD_TURN_ON Liga cursor LCD_TURN_OFF Apaga todo o visor do LCD, sem perder os dados no visor LCD_SHIFT_LEFT Movimenta textos do LCD para a esquerda LCD_SHIFT_RIGHT Movimenta textos do LCD para a direita

No exemplo utilizamos o seguinte comando para apagar o display LCD:


Este e os demais comandos que estudaremos somente podem ser utilizados após a

execução do comando lcd8_config().

Utilizamos o comando para desligar o cursor do LCD


E agora escrevemos a mensagem "Microgenios" na coordenada informada pela

função lcd8_out no LCD.

lcd8_out(1,1,"Microgenios"); // escreve mensagem na primeira linha do

LCD

Os números 1, 1 da função acima, informa que a mensagem "Microgenios" será escrita

na primeira linha da primeira coluna do LCD. o Primeiro numero informa a linha do

LCD e o segundo número informa a coluna do LCD.

Os displays LCD são constituidos de linhas e colunas conforme podemos ver na figura

abaixo:

O LCD apresentado possui 4 linhas por 20 colunas.

Podemos escrever um dado em qualquer posição do LCD. basta informar a linha e a

coluna para inicio do texto.

No caso de desejarmos escrever uma mensagem "ligado" na quarta linha, décima

coluna do LCD 20 x 4, basta escrever o seguinte comando:

lcd8_out(4,10,"ligado"); // escreve mensagem na quarta linha, décima

coluna do lcd 20 x 4

Vamos escrever agora outro programa que escreve uma mensagem no display lcd 16 x

4:

/*********************************************************************

*****


Programa exemplo: LCD_modo_8bits_01.c

Este programa tem por objetivo escrever a mensagem "Maquina: ligado"

na primeira

linha do LCD e na segunda linha "Prog: ligado".

**********************************************************************

****

*/

char *texto = "ligado"

void main()

{





inicializa o LCD



lcd8_out(1,1,"Maquina: "); // escreve mensagem na primeira linha do

LCD lcd8_out_cp(texto); // escreve mensagem na segunda linha do LCD

lcd8_out(2,1,"Prog: "); // escreve mensagem na segunda linha do LCD lcd8_out_cp(texto); // escreve mensagem na segunda linha do LCD

delay_ms(10); //delay de 10 ms


}

Neste exemplo repare que utilizamos a mesma configuração de hardware do LCD

anterior. Repare que agora temos um comando novo em nosso programa, o comando

lcd8_out_cp, cuja função é escrever no lcd uma string ou variável na corrente posição

do cursor.

Repare que o comando lcd8_out(1,1,"Maquina: "); deixa o cursor posicionada na

sétima coluna da primeira linha do lcd. O próximo comando que vem em seguida no

programa é lcd8_out_cp(texto), que escreve na posição do cursor do lcd o valor da

variável "texto", que neste caso é a string "ligado".

Teremos como resultado:

M a q u i n a : L i g a d o

P r o g : L i g a d o

LCD Modo 4 bits - Somente um port de controle/dados

No modo de 4 bits, devemos ligar apenas o nibble mais significativo (DB4 a DB7)

do barramento de dados do LCD ao microcontrolador, conforme o esquema elétrico seguinte:

Para exemplificar este modo 4 bits iremos apresentar um programa:

/*********************************************************************

*****



Este programa tem por objetivo escrever a mensagem "teste LCD" na

primeira

linha do LCD. Programa no modo 4 bits

**********************************************************************

****

*/

void main() {

TRISD = 0; // programa portD como saida

Lcd_Config(&PORTD,1,3,2,7,6,5,4); //configura e inicializa LCD

Lcd_Cmd(Lcd_CLEAR); // apaga display

Lcd_Cmd(Lcd_CURSOR_OFF); // desliga cursor

Lcd_Out(1, 1, "teste LCD"); // escreve texto "teste LCD" na

primeira linha, primeira coluna do LCD

while(1);

}


O programa acima tem a função de escrever na primeira linha do display lcd o texto

"teste LCD". Repare na imagem acima que utilizamos somente um port do PIC para

controle e envio de dados para o LCD.


um dos comandos:

O comando lcd_config ( ):

O comando lcd_config( ) determina quais são os pinos do barramento de dados e de

controle do LCD que estão ligados ao PIC, assim como também inicializa o LCD.

Sintaxe:

lcd_config(&port_controle/dados, RS, EN, RW, D7, D6, D5, D4 );

Onde:






D7 à D4: pinos do port_dados


Lcd_Config(&PORTD,1,3,2,7,6,5,4); //configura e inicializa LCD

A função lcd_config acima, determina o PORT e os pinos que participam do controle

do LCD:


PORTD


RS: 1 //pino RD2

EN: 3 //pino RD3

RW: 2 //qualquer valor de outro pino, pois o RW do LCD esta aterrado


PORTD






PODEMOS ATERRAR O PINO R/W DO LCD, POIS AS FUNÇÕES DE CONTROLE DE LCD

DO MIKROC NÃO UTILIZA ESTE PINO SIMPLESMENTE DEIXAM ESTE PINO EM NIVEL

LÓGICO 0. CASO VENHAMOS A ATERRAR O PINO RW, ECONOMIZAREMOS 1 PINO DE

I/O DO PIC.

Os demais comandos do programa estudamos anteriormente, em caso de dúvida leia

novamente o conteúdo do tópico lcd modo 8 bits.

LCD Modo 4 bits - Controlado por dois ports do PIC

Este é mais um dos modos 4 bits de trabalharmos com LCD. Neste novo modo podemos

ter um port de controle e outro port do PIC para dados. Veja o esquema abaixo:

Repare que para controlar o display LCD utilizamos dois ports do PIC, o PORTA para

controle, e o PORTD como dados.

Vamos estudar um programa para entendermos os comandos de controle:

/*********************************************************************

*****



Este programa tem por objetivo escrever a mensagem "Programa LCD" na

primeira

linha do LCD. Programa no modo 4 bits

**********************************************************************

****

*/

void main() {

ADCON1 = 6; // programa pinos de A/D como I/O de uso

geral

TRISA = 0; // programa portA como saida

TRISD = 0; // programa portD como saida

Lcd_custom_Config(&PORTD,0,2,4,5,&PORTA,1,2,3); //configura e

inicializa LCD no modo 4 bits

Lcd_Cmd(Lcd_CLEAR); // apaga display

Lcd_Cmd(Lcd_CURSOR_OFF); // desliga cursor

Lcd_Out(1, 4, "Programa LCD"); // escreve texto "Programa LCD" na

primeira linha, quarta coluna do LCD

while(1);

}


O programa acima tem a função de escrever na primeira linha, quarta coluna do display

lcd o texto "Programa LCD". Repare no esquema eletrônico acima que temos dois ports

do PIC ligado ao LCD.


um dos comandos:

O comando lcd_custom_config ( ):

O comando lcd_custom_config( ) determina quais são os pinos do barramento de dados

e de controle do LCD que estão ligados ao PIC, assim como também inicializa o LCD.

Sintaxe:

lcd_config(&port_dados, D7, D6, D5, D4, &port_controle, RS, RW, EN );

Onde:






D7 à D4: pinos do port_dados


Lcd_custom_Config(&PORTD,0,2,4,5,&PORTA,1,2,3); //configura e

inicializa LCD no modo 4 bits

A função lcd_custom_Config acima, determina os PORTs e os pinos que participam

do controle e envio de dados para o LCD:


PORTA


RS: 1 //pino RA1

EN: 3 //pino RA3

RW: 2 //qualquer valor de outro pino, pois o RW do LCD esta aterrado, neste caso conectados a RA2


PORTD






Aprendendo Programando:

Apartir de agora, iremos desenvolver alguns exemplos de programas utilizando display

LCD alfanuméricos.

1º Programa:

Vamos elaborar um programa utilizando os recursos das funções de display LCD do

MikroC para que funcione da seguinte maneira:

Nosso hardware esta operando o LCD no formato 8 bits

Inicialmente será escrito uma string na primeira linha do display LCD e outra na

segunda linha.

As mensagem deverão se deslocar 16 casas para a direita e posteriormente deverá

retornar ao seu local de origem:

Cada deslocamente levará aproximadamente 200 milisegundos.

Microcontrolador: PIC18F4x2

Cristal: 8MHz

Acompanhe o harware:

figura 01 - Esquema elétrico

/*********************** Animação de Display LCD ************************

Centro de Tecnologia Microgenios

Programa: Animação LCD

Compilador: MikroC

Cristal: 8Mhz

Microcontrolador: PIC18F452

Objetivo: Deslocar as mensagem dos display LCD para a direita e para a

esquerda

utilizando laço For.

*************************************************************************/

void main() {

unsigned char inc = 0; //declara variavel chamada "inc" como char



ADCON1 = 0x06; //configura todos os pinos de A/D como I/O de uso

geral

lcd8_config(&porte, &portd,2,1,4,7,6,5,4,3,2,1,0); //

lcd8_cmd(lcd_clear); //apaga display LCD

lcd8_cmd(lcd_cursor_off); //desliga cursor

lcd8_out(1,1,"Microgenios"); //escreve no display LCD

lcd8_out(2,1,"KIT PICGENIOS"); //escreve no display LCD

//*********** desloca mensagens do lcd para a direita

*********************

for (inc = 0 ; inc < 16 ; inc++){

lcd8_cmd(LCD_SHIFT_RIGHT); //desloca mensagem para a direita

Delay_ms(200); //aguarda 200 milisegundos

}

//*********** desloca mensagens do lcd para a esquerda

*********************

for (inc = 0 ; inc < 16 ; inc++){

lcd8_cmd(LCD_SHIFT_left); //desloca mensagem para a esquerda

Delay_ms(200); //aguarda 200 milisegundos

}


}

Obs: repare neste programa que o pino R/W do display LCD foi aterrado, e na função

lcd8_config foi declarado como sendo pino RE4. O pino R/W normalmente não é

utilizado nas maioria das aplicações, neste caso, como a

função lcd8_config necessita de algum parâmetro, informamos um valor qualquer,

neste caso foi um pino inexistente no chip. (lembre-se que todos os ports do PIC são

composto por 8 bits, neste caso a posição de memória RE4 existe, porém não tem

aplicação para este chip).

Regras do C: Se na declaração de uma função declararmos "n"

parametros, necessáriamente deveremos enviar todos os "n" parâmetros na

chamada desta função.

2º Programa:

Nosso segundo programa, tem como objetivo escrever no display LCD o valor

numérico 100 armazenado em uma variável do tipo char, chamada "contador".

Utilizaremos o mesmo esquema eletrônico apresentado do exemplo 01.

Acompanhe:




Compilador: MikroC

Cristal: 8Mhz


Objetivo: enviar para o display LCD o valor da variável contador

*************************************************************************/

void main() {

unsigned char contador = 100; //declara variável char contador e

atribui o valor 100

unsigned char texto[10]; //cria vetor (array) do tipo char com 11

elementos (os indice começam do 0)



ADCON1 = 0x06; //configura todos os pinos de A/D como I/O de uso

geral




bytetostr(contador, texto); //converte o valor numérico de

contador e atribui ao vetor Texto

lcd8_out(1,1,texto); //escreve no display LCD o valor do vetor

texto


}

O programa deste exercício possui muitas informações importantes, dentre elas, a

utilização de Arrays, ou como neste caso é chamado, vetor.

Para que possamos enviar o valor numérico presente em uma variável qualquer, a

principio precisamos converter cada um de seus algorismo em caracterer, pois a função

de display LCD do MikroC somente opera com caracteres e string.

Um erro comum (acredito que você já tentou), é utilizar as funções dessa forma:

lcd8_out(1,1,contador); //escreve no display LCD o valor da

variável contador

Se você pensou que iria aparecer no display LCD o valor da variável contador no

display LCD você se enganou.

Vamos analizar com mais calma:

Seu display LCD somente pode operar com caracterer, ou seja, char. Lembre-se que o

barramento do LCD é de 8 bits, no qual permite o envio de valores de 0 a 255 no

máximo.

Cada caracterer no padrão ASCII é do comprimento de um char, neste caso você já

começa a pensar...

"Tenho que enviar um caracter por vez no display LCD".

É exatamente isso, temos que enviar caracter por caracter, caso nossa intensão seja

escrever uma mensagem no visor do LCD.

Nosso compilador possui algumas bibliotecas que irão nos ajudar e muito na elaboração

do nosso programa. Utilizamos uma função chamada bytetostr no programa, que tem

por objetivo converter o valor numérico de uma variável para String e armazenar em

uma Tabela (vetor). " Professor, estou com uma dúvida !! . Afinal qual é a diferença entre um caractere e uma string??? Na linguagem C diferenciamos um caractere de uma string através das aspas simples ' e aspas duplas ".

Exemplo: 'A' ---> caractere A padrão ASCII "A" ---> string A mas qual é a diferença? Caractere: todo caractere ASCII possui um valor numérica (consulte o menu Tools > ASC Chart do MikroC) String:

Não exite uma representação numérica para uma string, pois está é composta por caractere + 1

caractere de terminação, chamado "Null", cujo valor é Zero. então teremos: "A" ---> é igual a: --- > 'A' (caractere) + "\0" (caractere de terminação de string null) Pense e responda: Qual é o número que representa seu nome? resp: Não existe um número que represente seu nome, e isso acontece em qualquer string.

Veja como ficará o resultado no modo de debugação no MikroC:

Figura 02 - Debugação do programa anterior

Perceba o preenchimento do vetor Texto após a execução do comando: bytetostr(contador, texto);

3º Programa:

Este Terceiro programa tem por objetivo mostrar utilizar os recursos da memória

CGRAM do display LCD. Neste exemplo, aparecerá um pequeno "cavalinho" andando

no display LCD alfanumérico.

Teste este programa no seu kit PICgenios e veja o resultado:




Compilador: MikroC

Cristal: 8Mhz


Objetivo: enviar para o display LCD o valor da variável contador

http://br.youtube.com/watch?v=NS6-T3bGNd4

*************************************************************************/

//1º caracterer************

const char character1[] = { 32 , 32 , 32 , 32 , 3 , 7 , 14 , 14};








const char character1a[] = { 32 , 32 , 32 , 32 , 32 , 7 , 15 , 30};








const char character1b[] = { 32 , 32 , 32 , 7 , 15 , 14 , 28 , 24};








void escreve(char pos_row, char pos_char, char pos_row1, char

pos_char1,char num) {

char i;

if (num == 1){

LCD8_Cmd(64);

for (i = 0; i<=7; i++) LCD8_Chr_Cp(character1[i]);








LCD8_Cmd(LCD_RETURN_HOME);

lcd8_chr(pos_row, pos_char, 0);

LCD8_Chr_cp(1);

LCD8_Chr_cp(2);

LCD8_Chr_cp(3);

lcd8_chr(pos_row1, pos_char1, 4);

LCD8_Chr_cp(5);

LCD8_Chr_cp(6);

LCD8_Chr_cp(7);

}

if (num == 2){

LCD8_Cmd(64);

for (i = 0; i<=7; i++) LCD8_Chr_Cp(character1a[i]);










LCD8_Chr_cp(1);

LCD8_Chr_cp(2);

LCD8_Chr_cp(3);


LCD8_Chr_cp(5);

LCD8_Chr_cp(6);

LCD8_Chr_cp(7);

}

if (num == 3){

LCD8_Cmd(64);

for (i = 0; i<=7; i++) LCD8_Chr_Cp(character1b[i]);










LCD8_Chr_cp(1);

LCD8_Chr_cp(2);

LCD8_Chr_cp(3);


LCD8_Chr_cp(5);

LCD8_Chr_cp(6);

LCD8_Chr_cp(7);

}

}

void main() {

unsigned char texto[10];







while(1){

escreve (1,1,2,1,3);

delay_ms(100);

escreve (1,1,2,1,2);

delay_ms(100);

escreve (1,1,2,1,1);

delay_ms(100);

}

}

voltar para o topo da pagina

Centro de Tecnologia Microgenios - Curso de Microcontroladores PIC - Programação

em C

Microgenios © 1998 - 2008. Todos os direitos reservados. É proibido cópia parcial ou

integral desse material sem prévio aviso. Maiores informações:

[email protected]

Documents

Os Display LCD Alfanumericos