Docsity
EntrarCadastre-se
Docsity
Prepare-se para as provas
Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity

Ganhe pontos para baixar
Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium

Guias e Dicas
Guias e Dicas
Venda na Docsity
Venda na Docsity
EntrarCadastre-se

Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity

Encontrar documentos

Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity

Pesquisar documentos Store

Os melhores documentos à venda: Trabalhos de alunos formados

Videoaulas

Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade

Quiz

Responda perguntas de provas passadas e avalie sua preparação.

Pesquise entre todos os recursos de estudo
Docsity AINEW

Resuma seus documentos, faça perguntas, converta-os em questionários e mapas conceituais

TCC e ENEM 2025

Estude com provas passadas, TCCs e dicas úteis

Explorar perguntas

Tire suas dúvidas lendo as respostas dadas por outros alunos como você.

Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium

Compartilhe documentos
download point icon20 Pontos

Por cada documento compartilhado

Responda às perguntas
download point icon5 Pontos

por cada resposta enviada (máx. 1 por dia)

Todas as maneiras de obter pontos grátis
Ganhe pontos imediatamente

Escolha um Plano Premium com todos os pontos que precisa

Oportunidades de estudo

Escolha seu próximo programa de estudos

Entre em contato direto com as melhores Universidades do mundo. Pesquise entre milhares de Universidades e parceiros oficiais

Comunidade

Pergunte à comunidade

Peça ajuda à comunidade e tire suas dúvidas relacionadas ao estudo

Ranking universidades

Descubra as melhores universidades em seu país de acordo com os usuários da Docsity

Guias grátis

Os eBooks que salvam estudantes!

Baixe gratuitamente nossos guias de estudo, métodos para diminuir a ansiedade, dicas de TCC preparadas pelos professores da Docsity

Do blog

Vá para o blog

Definição de pinos para LCD em um microcontrolador PIC, Notas de estudo de Física

Centro Universitário do Sul de Minas GeralFísica

A definição de pinos para um display lcd conectado a um microcontrolador pic, incluindo a rotina para enviar um 'nibble' para o lcd. Além disso, são fornecidas informações sobre a inicialização rápida dos pinos de i/o e a definição do pic utilizado.

Tipologia: Notas de estudo

2013

Compartilhado em 23/04/2013

Caruru200
Caruru200 🇧🇷

4.5

(135)

461 documentos

1 / 37

Toggle sidebar

Esta página não é visível na pré-visualização

Não perca as partes importantes!

bg1
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
#define lcd_db5 pin_d5 // pino de dados d5 do LCD
#define lcd_db6 pin_d6 // pino de dados d6 do LCD
#define lcd_db7 pin_d7 // pino de dados d7 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>
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 = 1
delay_us(1); // Recomendado para estabilizar o LCD
output_low(lcd_enable); // ENABLE = 0
return; // Retorna ao ponto de chamada da função
Tutorial LCD em 4 vias 38
}
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e
pf1f
pf20
pf21
pf22
pf23
pf24
pf25

Pré-visualização parcial do texto

Baixe Definição de pinos para LCD em um microcontrolador PIC e outras Notas de estudo em PDF para Física, somente na Docsity!

Parte 2 – Comunicação em 4 vias pela McLAB

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

#define lcd_db5 pin_d5 // pino de dados d5 do LCD

#define lcd_db6 pin_d6 // pino de dados d6 do LCD

#define lcd_db7 pin_d7 // pino de dados d7 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> 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 = 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 return; // Retorna ao ponto de chamada da função }

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

  • Inicializa o LCD *
                    • * * * * * * * * * * * * * * * * * * * * * * * * * * * */ void inicializa_lcd() { output_low(lcd_db4); // Garante que o pino DB4 estão em 0 (low) output_low(lcd_db5); // Garante que o pino DB5 estão em 0 (low) output_low(lcd_db6); // Garante que o pino DB6 estão em 0 (low) output_low(lcd_db7); // Garante que o pino DB7 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) delay_ms(15); // Aguarda 15ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x02);// CURSOR HOME - Envia comando para zerar o contador de // caracteres e retornar à posição inicial (0x80). delay_ms(1); // Aguarda 1ms para estabilizar o LCD 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 return; // Retorna ao ponto de chamada da função }

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 #define lcd_db5 pin_b1 // pino de dados d5 do LCD #define lcd_db6 pin_b2 // pino de dados d6 do LCD #define lcd_db7 pin_b3 // pino de dados d7 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”

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.

McLAB

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

Início Define Microcontrolador Define configurações para gravação Define configurações para 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 McLAB

//Este é o bloco com as rotinas necessárias para manipular o LCD /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  • 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> 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 = 1 delay_us(1); // Recomendado para estabilizar o LCD output_low(lcd_enable); // ENABLE = 0 return; // Retorna ao ponto de chamada da função } / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 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/coamndo 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 função } / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 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,""); 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() { envia_byte_lcd(0,0x01); // Envia instrução para limpar o LCD delay_ms(2); // Aguarda 2ms para estabilizar o LCD return; // Retorna ao ponto de chamada da função }
  • Inicializa o LCD *
                    • * * * * * * * * * * * * * * * * * * * * * * * * * * * / void inicializa_lcd() { output_low(lcd_db4); // Garante que o pino DB4 estão em 0 (low) output_low(lcd_db5); // Garante que o pino DB5 estão em 0 (low) output_low(lcd_db6); // Garante que o pino DB6 estão em 0 (low) output_low(lcd_db7); // Garante que o pino DB7 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) delay_ms(15); // Aguarda 15ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x02); // CURSOR HOME - Envia comando para zerar o contador de // caracteres e retornar à posição inicial (0x80). delay_ms(1); // Aguarda 1ms para estabilizar o LCD 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 return; // Retorna ao ponto de chamada da função } /***************************************************************************/ / 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; // configura os tris set_tris_a(0b00111111); // configuração da direção dos pinos de I/O 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(" ");

Placa de testes

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

Início Define Microcontrolador Define configurações para gravação Define configurações para 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 25: Fluxograma para a placa de testes

Este é o código a ser programado em nossa placa de testes:

  • 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=15% RAM=3% - 6% *
  • VERSÃO : 1.0 *
  • DATA : 31/08/2005 *
                    • * * * * * * * * * * * * * * * * * * * * * * * * * * * / / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Descrição geral * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / // Primeiro teste de LCD em 4 vias - Olá Mundo // // // / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Definição do PIC utilizado * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / #include <16f628a.h> / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações para gravação * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / #fuses INTRC,NOWDT,PUT,MCLR,NOBROWNOUT,NOLVP #ROM 0x07ff = {0} //Calibragem do oscilador interno / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 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 #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 #define lcd_db5 pin_b1 // pino de dados d5 do LCD #define lcd_db6 pin_b2 // pino de dados d6 do LCD #define lcd_db7 pin_b3 // pino de dados d7 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) #byte porta = 0x #byte portb = 0x /***************************************************************************/ / Rotinas para o LCD */ /***************************************************************************/
  • Inicializa o LCD *
                    • * * * * * * * * * * * * * * * * * * * * * * * * * * * / void inicializa_lcd() { output_low(lcd_db4); // Garante que o pino DB4 estão em 0 (low) output_low(lcd_db5); // Garante que o pino DB5 estão em 0 (low) output_low(lcd_db6); // Garante que o pino DB6 estão em 0 (low) output_low(lcd_db7); // Garante que o pino DB7 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) delay_ms(15); // Aguarda 15ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x03); // Envia comando para inicializar o display delay_ms(5); // Aguarda 5ms para estabilizar o LCD envia_nibble_lcd(0x02); // CURSOR HOME - Envia comando para zerar o contador de // caracteres e retornar à posição inicial (0x80). delay_ms(1); // Aguarda 1ms para estabilizar o LCD 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 return; // Retorna ao ponto de chamada da função } /***************************************************************************/ / Final das rotinas para o LCD / /***************************************************************************/ / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Configurações do PIC * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / main() { // Reseta portas porta = 0; portb = 0; // configura os tris set_tris_a(0b00111111); // configuração da direção dos pinos de I/O 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("!"); / * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Rotina principal *

// Como não há outra execução, a rotina principal fica vazia 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()

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.