Conhecendo como composto o Display LCD passemos para a parte prtica.

. A seguir uma configurao muito bsica de um circuito que integra um microcontrolador PIC 16F628A. Para a utilizao com outro modelo de microcontrolador PIC basta escolher os pinos que queremos para cada funo e indic-los no programa.

 Vamos analisar o cdigo, todo comentado, necessrio para exibir uma mensagem no LCD, utilizando o PORTD de um PIC16F877a /************************************* INICIO ************************************/ #include <16f877A.h> #use delay(clock=4000000) #byte porta = 0x05 #byte portb = 0x06 #byte portc = 0x07 #byte portd = 0x08 #byte porte = 0x09 #bit rs = porte.0 #bit enable = porte.1 // via do LCD que sinaliza recepo de dados ou comando // enable do lcd // microcontrolador utilizado

#fuses xt,nowdt,noprotect,put,brownout,nolvp,nocpd,nowrt // configurao dos fusveis

/************* Rotina que envia um COMANDO para o LCD **************/ void comando_lcd(int caracter) { rs = 0; portd = caracter; enable = 1 ; delay_us(1); enable = 0; delay_us(40); return; // retorna }

// seleciona o envio de um comando // carrega o portd com o caracter // gera pulso no enable // espera 1 microssegundos // desce o pino de enable // espera mnimo 40 microssegundos

/************* Rotina que envia um DADO a ser escrito no LCD *************/ void escreve_lcd(int caracter) { rs = 1; // seleciona o envio de um dado portd = caracter; // carrega o portd com o caracter enable = 1; // gera pulso no enable delay_us(1); // espera 1 microssegundos enable = 0; // desce o pino de enable delay_us(40); // espera mnimo 40 microssegundos return; // retorna } /******************** Funo para limpar o LCD ********************/ void limpa_lcd() { comando_lcd(0x01); delay_ms (2); return;

// limpa LCD

} /******************* Inicializao do Display de LCD ********************/ void inicializa_lcd() { comando_lcd(0x30); delay_ms(4); comando_lcd(0x38); limpa_lcd(); comando_lcd(0x0c); comando_lcd(0x06); return; }

// envia comando para inicializar display // espera 4 milissegundos // configura LCD, 8 bits, matriz de 7x5, 2 linhas // limpa LCD // display sem cursor // desloca cursor para a direita // retorna

/******************** Configuraes do PIC ********************/ void main() { // configura microcontrolador setup_adc_ports (no_analogs); // configura os tris set_tris_a(0b11011111); set_tris_b(0b00000011); set_tris_c(0b11111101); set_tris_d(0b00000000); set_tris_e(0b00000100); // configurao da direo dos pinos de I/O

// inicializa os ports porta=0x00; // limpa porta portb=0x00; // limpa portb portc=0x00; // limpa portc portd=0x00; // limpa portd porte=0x00; // limpa porte inicializa_lcd(); // inicializa o LCD /************************* Rotina principal **************************/ while(TRUE) // rotina principal { //Local onde o programa ser escrito } }

 Para simplificar o projeto, podemos manter o pino R/W do LCD aterrado, habilitando assim, apenas o modo de gravao que nos importa; No poderemos ler o STATUS BIT para saber quando p LCD est pronto para o prximo dado; Basta apenas esperar o tempo mnimo para cada funo e executar a prxima; Isso no uma deficincia do projeto e sim uma caracterstica da maioria dos projetos comerciais; Antes de comearmos a programao, precisamos informar quais os pinos de I/O sero utilizados pelo LCD; Isso facilitar a portabilidade do projeto para outros PICs ou LCDs #define lcd_enable pin_e1 #define lcd_rs pin_e0 #define lcd_db4 pin_d4 #define lcd_db5 pin_d5 #define lcd_db6 pin_d6 #define lcd_db7 pin_d7 // pino enable do LCD // pino rs do LCD // pino de dados d4 do LCD // pino de dados d5 do LCD // pino de dados d6 do LCD // pino de dados d7 do LCD

/*****************************************************************/ /* Envio de "Nibble" para o LCD */ /*****************************************************************/ //Esta rotina l o "Nibble" inferior de uma varivel e envia para o LCD. void envia_nibble_lcd(int dado) { //Carrega as vias de dados (pinos) do LCD de acordo com o nibble lido output_bit(lcd_db4, bit_test(dado,0)); //Carrega DB4 do LCD com o bit DADO<0> output_bit(lcd_db5, bit_test(dado,1)); //Carrega DB5 do LCD com o bit DADO<1> output_bit(lcd_db6, bit_test(dado,2)); //Carrega DB6 do LCD com o bit DADO<2> output_bit(lcd_db7, bit_test(dado,3)); //Carrega DB7 do LCD com o bit DADO<3> //Gera um pulso de enable output_high(lcd_enable); delay_us(1); output_low(lcd_enable); return; } // ENABLE = 1 // Recomendado para estabilizar o LCD // ENABLE = 0 // Retorna ao ponto de chamada

/*****************************************************************/ /* Envio de Byte para o LCD */ /*****************************************************************/ //Esta rotina ir enviar um dado ou um comando para o LCD conforme abaixo: // ENDEREO = 0 -> a varivel DADO ser uma instruo // ENDEREO = 1 -> a varivel DADO ser um caractere void envia_byte_lcd(boolean endereco, int dado) { output_bit(lcd_rs,endereco); // Seta o bit RS para instruo ou caractere delay_us(100); // Aguarda 100 us para estabilizar o pino do LCD output_low(lcd_enable); // Desativa a linha ENABLE envia_nibble_lcd(dado>>4); // Envia a parte ALTA do dado/comando envia_nibble_lcd(dado & 0x0f); // Limpa a parte ALTA e envia a parte BAIXA do // dado/comando delay_us(40); // Aguarda 40us para estabilizar o LCD return; // Retorna ao ponto de chamada da funo } /*****************************************************************/ /* Funo para limpar o LCD */ /*****************************************************************/ void limpa_lcd() { envia_byte_lcd(0,0x01); delay_ms(2); return; }

// Envia instruo para limpar o LCD // Aguarda 2ms para estabilizar o LCD // Retorna ao ponto de chamada da funo

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/ * Inicializa o LCD * / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void inicializa_lcd() { output_low(lcd_db4); output_low(lcd_db5); output_low(lcd_db6); output_low(lcd_db7); output_low(lcd_rs); output_low(lcd_enable); delay_ms(15); envia_nibble_lcd(0x03); delay_ms(5); envia_nibble_lcd(0x02); delay_ms(1); envia_byte_lcd(0,0x28); envia_byte_lcd(0,0x0c); limpa_lcd();

// Garante que o pino DB4 esto em 0 (low) // Garante que o pino DB5 esto em 0 (low) // Garante que o pino DB6 esto em 0 (low) // Garante que o pino DB7 esto em 0 (low) // Garante que o pino RS esto em 0 (low) // Garante que o pino ENABLE esto em 0 (low) // Aguarda 15ms para estabilizar o LCD // Envia comando para inicializar o display // Aguarda 5ms para estabilizar o LCD // CURSOR HOME - Envia comando para zerar o //contador de caracteres e retornar posio inicial // Aguarda 1ms para estabilizar o LCD // FUNCTION SET - Configura o LCD para 4 bits, // 2 linhas, fonte 5X7. // DISPLAY CONTROL - Display ligado, sem cursor // Limpa o LCD

envia_byte_lcd(0,0x06); direita return; }

// ENTRY MODE SET - Desloca o cursor para a // Retorna ao ponto de chamada da funo

Vamos fazer um exerccio prtico. O Hardware utilizado o que segue:

Abaixo, o programa correspondente: #include <16f877a.h> #fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT,NOLVP,NOCPD,NOWRT #use delay(clock=4000000) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

* CONSTANTES INTERNAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Estas so as definies dos pinos que o LCD utiliza. // Definem quais pinos do PIC controlaro os pinos do LCD #define lcd_enable pin_d1 #define lcd_rs pin_d0 #define lcd_db4 pin_d4 #define lcd_db5 pin_d5 #define lcd_db6 pin_d6 #define lcd_db7 pin_d7 // pino enable do LCD // pino rs (register select)do LCD // (0) para comandos (1) para dados // pino de dados d4 do LCD // pino de dados d5 do LCD // pino de dados d6 do LCD // pino de dados d7 do LCD

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * DEFINIO E INICIALIZAO DOS PORTS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #byte porta = 0x05 #byte portb = 0x06 #byte portc = 0x07 #byte portd = 0x08 #byte porte = 0x09 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ENVIO DE NIBBLE PARA O LCD * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //Esta rotina l o "Nibble" inferior de uma varivel e envia para o LCD. //1byte = 8 bits = 2 Nibbles //Sero enviados para os pinos db4, db5, db6, db7 do LCD void envia_nibble_lcd(int dado) { //Carrega as vias de dados (pinos) do LCD de acordo com o nibble lido output_bit(lcd_db4, bit_test(dado,0)); //Carrega DB4 do LCD com o bit DADO<0> output_bit(lcd_db5, bit_test(dado,1)); //Carrega DB5 do LCD com o bit DADO<1> output_bit(lcd_db6, bit_test(dado,2)); //Carrega DB6 do LCD com o bit DADO<2> output_bit(lcd_db7, bit_test(dado,3)); //Carrega DB7 do LCD com o bit DADO<3> //Gera um pulso de enable output_high(lcd_enable); // ENABLE = 1delay_us(1); // Recomendado para estabilizar o LCD output_low(lcd_enable); // ENABLE = 0 return; // Retorna ao ponto de chamada } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ENVIO DE BYTE PARA O LCD * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Esta rotina ir enviar um dado ou um comando para o LCD conforme abaixo: // ENDEREO = 0 -> a varivel DADO ser uma instruo // ENDEREO = 1 -> a varivel DADO ser um caractere

void envia_byte_lcd(boolean endereco, int dado) { output_bit(lcd_rs,endereco); // Seta o bit RS para instruo ou caractere delay_us(100); // Aguarda 100 us para estabilizar o pino do LCD output_low(lcd_enable); // Desativa a linha ENABLE envia_nibble_lcd(dado>>4); // Envia a parte ALTA do dado/comando envia_nibble_lcd(dado & 0x0f); // Limpa a parte ALTA e envia a parte BAIXA do //dado/comando delay_us(40); // Aguarda 40us para estabilizar o LCD return; // Retorna ao ponto de chamada da funo } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * ** * * * ENVIO DE CARACTER PARA O LCD * **********************************************************/ // Esta rotina serve apenas como uma forma mais fcil de escrever um caractere no display. void escreve_lcd(char c) { envia_byte_lcd(1,c); } // envia caractere para o display

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * ** * * * FUNO PARA LIMPAR O LCD * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * ** * * / // Como esta operao pode ser muito utilizada, transformando-a em funo // faz com que o cdigo compilado seja menor. void limpa_lcd() { envia_byte_lcd(0,0x01); delay_ms(2); return; }

// Envia instruo para limpar o LCD // 0 - envio de instruo // 0X01 - mostrar tabela // Aguarda 2ms para estabilizar o LCD // Retorna ao ponto de chamada da funo

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * INICIALIZA O LCD * **********************************************************/ void inicializa_lcd() { output_low(lcd_db4); output_low(lcd_db5); output_low(lcd_db6); output_low(lcd_db7); output_low(lcd_rs); output_low(lcd_enable); delay_ms(15);

// Garante que o pino DB4 esto em 0 (low) // Garante que o pino DB5 esto em 0 (low) // Garante que o pino DB6 esto em 0 (low) // Garante que o pino DB7 esto em 0 (low) // Garante que o pino RS esto em 0 (low) // Garante que o pino ENABLE esto em 0 (low) // Aguarda 15ms para estabilizar o LCD

envia_nibble_lcd(0x02); (0x80) delay_ms(1); envia_byte_lcd(0,0x20); envia_byte_lcd(0,0x0C); cursor limpa_lcd(); envia_byte_lcd(0,0x06); posio return; }

// CURSOR HOME - Envia comando para zerar o //contador de caracteres e retornar posio inicial // Aguarda 1ms para estabilizar o LCD // FUNCTION SET - Configura o LCD para //4 bits, 1 linha, fonte 5X7. // 0 - envio de instruo 0x20 - mostrar tabela // DISPLAY CONTROL - Display ligado, sem // 0 - envio de instruo 0x0C - mostrar tabela // Limpa o LCD // ENTRY MODE SET - A cada caracter, incrementa uma // 0 - envio de instruo 0x06 - mostrar tabela // Retorna ao ponto de chamada da funo

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * CONFIGURAES DO PIC * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * / main() { // Reseta portas porta = 0; portb = 0; portc = 0; portd = 0; porte = 0; // configura os tris set_tris_a(0xFF); set_tris_b(0xFF); set_tris_c(0xFF); set_tris_d(0xFF); set_tris_e(0xFF); // Inicializa o LCD inicializa_lcd(); //Escreve tela escreve_lcd(O"); escreve_lcd(L"); escreve_lcd(A"); escreve_lcd(""); escreve_lcd(M"); escreve_lcd(U"); escreve_lcd(N"); escreve_lcd(D"); escreve_lcd(O"); escreve_lcd(!"); //printf(escreve_lcd,""); // configurao da direo dos pinos de I/O

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ROTINA PRINCIPAL * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * / // Como no h outra execuo, a rotina principal fica vazia while (true) { } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * FIM DO PROGRAMA * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ***/ }

Normalmente a utilizao do Display LCD apenas uma das funes de uma aplicao prtica, por este motivo, podemos criar uma biblioteca contendo todas as funes de controle do LCD em um arquivo separado do programa principal. E esta biblioteca ser chamada por cada um dos muitos projetos futuros que sero realizados e que utilizem Displays LCD sem a necessidade de reescrev-lo a cada vez.

Para isso criamos um arquivo no bloco de notas ou em qualquer editor de texto e salvamos com o nome de "LCD.h". Este arquivo dever ser salvo na mesma pasta onde se encontra o programa principal do seu projeto, no qual dever ser includa uma linha de comando que inclua todas as funes desta biblioteca e as tornem disponveis no programa Exemplo de declarao da biblioteca LCD.h no programa principal. principal:

#include <16f877a.h> #fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT,NOLVP,NOCPD,NOWRT #use delay(clock=4000000) /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * CONSTANTES INTERNAS *

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Estas so as definies dos pinos que o LCD utiliza. // Definem quais pinos do PIC controlaro os pinos do LCD #define lcd_enable pin_d1 #define lcd_rs pin_d0 #define lcd_db4 pin_d4 #define lcd_db5 pin_d5 #define lcd_db6 pin_d6 #define lcd_db7 pin_d7 #INCLUDE <LCD.H> //Continuao do programa.... // pino enable do LCD // pino rs (register select)do LCD // (0) para comandos (1) para dados // pino de dados d4 do LCD // pino de dados d5 do LCD // pino de dados d6 do LCD // pino de dados d7 do LCD // Declarao da biblioteca do LCD

Abaixo mostrado todo o contedo do arquivo "lcd.h", incluindo novas funes que foram includas a pedido dos leitores do Blog e que sero explicadas no prprio cdigo. Conteudo do arquivo "lcd.h":

/***************************************************************************/ /* Rotinas para o LCD */ /***************************************************************************/ //Este o bloco com as rotinas necessrias para manipular o LCD

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Envio de "Nibble" para o LCD * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

//Esta void {

rotina

"Nibble"

inferior

de

uma

varivel

envia

para

LCD. dado)

envia_nibble_lcd(int

//Carrega as vias de dados (pinos) do LCD de acordo com o nibble lido output_bit(lcd_db4, bit_test(dado,0)); output_bit(lcd_db5, bit_test(dado,1)); output_bit(lcd_db6, bit_test(dado,2)); output_bit(lcd_db7, bit_test(dado,3)); //Gera delay_us(1); output_low(lcd_enable); return; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Envio de Byte para o LCD * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //Esta rotina ir enviar um dado ou um comando para o LCD conforme abaixo: // // void { output_bit(lcd_rs,endereco); delay_us(100); output_low(lcd_enable); envia_nibble_lcd(dado>>4); envia_nibble_lcd(dado & 0x0f); delay_us(40); return; } // Seta o bit RS para instruo ou caractere // Aguarda 100 us para estabilizar o pino do LCD // Desativa a linha ENABLE // Envia a parte ALTA do dado/comando // Limpa a parte ALTA e envia a parte BAIXA do // dado/comando // Aguarda 40us para estabilizar o LCD // Retorna ao ponto de chamada da funo ENDEREO ENDEREO = = 0 1 -> -> a a varivel varivel DADO DADO ser ser int uma um instruo caractere dado) um //Carrega DB4 do LCD com o bit DADO<0> //Carrega DB5 do LCD com o bit DADO<1> //Carrega DB6 do LCD com o bit DADO<2> //Carrega DB7 do LCD com o bit DADO<3> pulso de // // ENABLE ENABLE enable = = 1 0

output_high(lcd_enable);

// Recomendado para estabilizar o LCD // Retorna ao ponto de chamada da funo

envia_byte_lcd(boolean

endereco,

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Envio de caractere para o LCD *

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Esta rotina serve apenas como uma forma mais fcil de escrever um caractere // no display. Ela pode ser eliminada e ao invs dela usaremos diretamente a // // void // { envia_byte_lcd(1,c); } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Funo para limpar o LCD * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // Como esta operao pode ser muito utilizada, transformando-a em funo // void { envia_byte_lcd(0,0x01); delay_ms(2); return; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Inicializa o LCD * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void { output_low(lcd_db4); output_low(lcd_db5); output_low(lcd_db6); output_low(lcd_db7); (low)output_low(lcd_rs); (low)output_low(lcd_enable); (low)delay_ms(15); LCDenvia_nibble_lcd(0x03); delay_ms(5); // Garante que o pino DB4 esto em 0 (low) // Garante que o pino DB5 esto em 0 (low) // Garante que o pino DB6 esto em 0 (low) // Garante que o pino DB7 esto em 0 // Garante que o pino RS esto em 0 // Garante que o pino ENABLE esto em 0 // Aguarda 15ms para estabilizar o // Envia comando para inicializar o display // Aguarda 5ms para estabilizar o LCD inicializa_lcd() // Envia instruo para limpar o LCD // Aguarda 2ms para estabilizar o LCD // Retorna ao ponto de chamada da funo faz com que o cdigo compilado seja menor. limpa_lcd() envia funo envia_byte_lcd(1,"<caractere do a ser a mostrado ser no LCD>"); no ou envia_byte_lcd(1,<cdigo caractere mostrado LCD>); c) o display

escreve_lcd(char caractere para

envia_nibble_lcd(0x03); delay_ms(5); envia_nibble_lcd(0x03); delay_ms(5); envia_nibble_lcd(0x02);

// Envia comando para inicializar o display // Aguarda 5ms para estabilizar o LCD // Envia comando para inicializar o display // Aguarda 5ms para estabilizar o LCD // CURSOR HOME - Envia comando para zerar o //contador de caracteres e retornar posio // inicial (0x80).delay_ms(1); // Aguarda 1ms para estabilizar o LCD

envia_byte_lcd(0,0x28); envia_byte_lcd(0,0x0c); cursor limpa_lcd(); envia_byte_lcd(0,0x06); direita return; }

// FUNCTION SET - Configura o LCD para 4 bits, // 2 linhas, fonte 5X7. // DISPLAY CONTROL - Display ligado, sem // Limpa o LCD // ENTRY MODE SET - Desloca o cursor para a // Retorna ao ponto de chamada da funo

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Define inicio da escrita * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ //Esta funo foi adicionada e serve para se definir em que posio do LCD deseja-se //iniciar a escrita. Para isto basta chamar a Funo "caracter_Inicio()" indicando a //linha e a coluna onde o cursor ser posicionado antes de se mandar escrever

void { int16

caracter_inicio(int

linha,

int

coluna)//define

posico

de

inicio

da

frase

posicao=0; if(linha posicao=0x80; if(linha posicao=0xc0; == 1) { //Se setado linha 1, end incial 0x80 } == 2) { //Se setado linha 2, end incial 0xc0 }

posicao=posicao+coluna;

//soma ao end inicial, o numero da coluna

posicao--; envia_byte_lcd(0,posicao); return; }

//subtrai 1 para corrigir posio

/***************************************************************************/ /* Final das rotinas para o LCD */ /***************************************************************************/

Agora veremos um exemplo de aplicao prtica da utilizao desta biblioteca:

#include #fuses #use

<16f877a.h> XT,NOWDT,NOPROTECT,PUT,BROWNOUT,NOLVP,NOCPD,NOWRT delay(clock=4000000)

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * CONSTANTES INTERNAS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ // // Estas Definem so quais as definies pinos pin_d1 do dos PIC pinos controlaro // que os pino o LCD do do utiliza. LCD LCD

pinos enable

#define

lcd_enable

#define lcd_rs pin_d0 #define lcd_db4 pin_d4 #define lcd_db5 pin_d5 #define lcd_db6 pin_d6 #define lcd_db7 pin_d7 #INCLUDE <LCD.H>

// pino rs (register select)do LCD // (0) para comandos (1) para dados // pino de dados d4 do LCD // pino de dados d5 do LCD // pino de dados d6 do LCD // pino de dados d7 do LCD // Declarao da biblioteca do LCD

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * DEFINIO E INICIALIZAO DOS PORTS * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #byte porta = 0x05 #byte portb = 0x06 #byte portc = 0x07 #byte portd = 0x08 #byte porte = 0x09

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * CONFIGURAES DO PIC * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * / main() { // Reseta portas porta = 0; portb = 0; portc = 0; portd = 0; porte = 0; // configura os tris set_tris_a(0xFF); set_tris_b(0xFF); set_tris_c(0xFF); set_tris_d(0xFF); set_tris_e(0xFF); // Inicializa o LCD inicializa_lcd(); //Limpa a tela do LCD limpa_lcd(); // configurao da direo dos pinos de I/O

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

* ROTINA PRINCIPAL * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * / while (true) { caracter_inicio(1,6); printf(escreve_lcd,"O BLOG"); //define o ponto de inicio da frase //Linha 1 e coluna 6 //escreve no LCD

caracter_inicio(2,4); printf(escreve_lcd,"DO MARCELO");

//define o ponto de inicio da frase //Linha 2 e coluna 4 //escreve no LCD

} /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * FIM DO PROGRAMA * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ***/ }