Prtica 1

Acione os LEDs que esto conectados a porta B do PIC 16F877A de modo que eles
liguem alternados (um por vez) iniciando da direita. Com o passar do tempo a velocidade
em que eles so alternados deve aumentar e depois diminuir.
Fluxograma

Figura 1: Fluxograma da prtica 1
Uma ideia simples para realizar tal funcionalidade controlar o tempo que cada LED ira
piscar baseado em uma operao de multiplicao, onde multiplicar um valor constante
por um valor varivel para mais e para menos.
Desenvolvimento
Um programa simples que envolve apenas a utilizao dos pinos B do MCU 18F877A
configurados como sadas, com um cabealho de configurao bsica. Como a ideia
fazer com que os LEDs pisquem e com passar do tempo a velocidade aumente e depois
diminua, foi definido uma constante simblica tmp com valor de 100 (#DEFINE temp
100) e uma varivel global inteira de 2 BYTES a (int16 a;), juntos sero responsvel
pela acelerao e desacelerao.
Uma funo void chamada pisca_led foi criada para deixar o cdigo mais dinmico, que
tem a capacidade de aplicar nvel lgico alto a um nico pino da porta B (output_b
(0b00000001);) alternando de modo sequencial aps um determinado tempo (delay_ms
(a*tmp);).
A funo principal (void main()) construda de forma simples, inicializando todos os
pinos B como pinos de sada (set_tris_b (0b11111111)) e logo depois entra na estrutura
de repetio infinita (while(true)), nela so includa duas estrutura de repetio for, uma
que decresce e outra que cresce na contagem. A primeira estrutura (for(a=4; a>=1; a--
)) , inicializa a varivel a em 4, com a condio maior ou igual a 1, com decrescimento
de 1 em 1 e em seu bloco de instrues feito a chamada da funo void pisca_led
criada anteriormente, assim o tempo que cada LED respectivo aos pinos B levar para
piscar ser determinado pelo valor da varivel a assumir no loop, tendo comeo de 400,
depois 300, 200 e 100 milissegundos. E na segunda estrutura (for(a=1; a<=4; a++)), a
varivel a inicializada em 1, com a condio menor ou igual a 4, com crescimento de
1 em 1 e seu bloco de instrues feita novamente a chamada da funo void
pisca_led, portanto o tempo que levar para cada LED piscar comear com 100,
depois 200, 300 e 400 milissegundos.
Cdigo
#include <16F877A.h> //inclusao do PIC
#FUSES NOWDT //WATCH DOG desabilitado
#FUSES BROWNOUT//reset por queda de tensao habilitado
#FUSES NOLVP //programacao em baixa tensao desabilitada
#FUSES XT //oscilador XT
#use delay(clock=4000000) //determinao do cristal oscilador

#DEFINE tmp 100 //constante para o tempo
int16 a; //variavel que suporta valor de 0 a 65535

void pisca_led (){ //funcao void pisca_led
output_b (0b00000001); //Pino B0 em alto e restante em baixo
delay_ms(a*tmp); //multiplicacao para determinar o tempo
output_b (0b00000010); //Pino B1 em alto e restante em baixo
delay_ms(a*tmp);
output_b (0b00000100); //Pino B2 em alto e restante em baixo
delay_ms(a*tmp);
output_b (0b00001000); //Pino B3 em alto e restante em baixo
delay_ms(a*tmp);
output_b (0b00010000); //Pino B4 em alto e restante em baixo
delay_ms(a*tmp);
output_b (0b00100000); //Pino B5 em alto e restante em baixo
delay_ms(a*tmp);
output_b (0b01000000); //Pino B6 em alto e restante em baixo
delay_ms(a*tmp);
output_b (0b10000000); //Pino B7 em alto e restante em baixo
delay_ms(a*tmp);
}

void main(){ //funcao principal
set_tris_b(0b11111111); //declarando todos os pinos como saida
while(TRUE){ //loop infinito
for(a=4; a>=1; a--){ //contagem de aceleracao
pisca_led(); //chamada da funcao pisca_led
} //fim da contagem
for(a=1; a<=4; a++){ //contagem de desaceleracao
pisca_led(); //chamada da funcao pisca_led
} //fim da contagem
} //fim do loop infinito
} //fim da funcao principal
Circuito de Simulao

Figura 2: Circuito da pratica 1
Um circuito simples que envolve a adio em cada pino da porta B um resistor de 330
para limitao da corrente e um LED, todos aterrados.
Prtica 2
Acione os LEDs que esto conectados a porta B do PIC 16F887A de acordo com o
boto que for pressionado:
-Boto S0: todos piscam.
-Boto S1: piscam alternados.
-Boto S2: todos desligados.
Fluxograma

Figura 3: Fluxograma da pratica 2
A ideia para realizar tais funcionalidades declara para cada boto, uma funo distinta
para todos os LEDs piscarem, piscarem alternados ou colocar todos desligados
Desenvolvimento
Um programa simples que envolve apenas a utilizao dos pinos B configurados como
sadas e os pinos A como entradas, com um cabealho de configurao bsica. Como
a ideia fazer com que cada boto tenha uma respectiva funo, basta enderear cada
boto um bloco de instrues para quando for pressionado ficar executando a respectiva
ao at que outro boto seja pressionado. Foi criado uma constante simblica tmp
com valor de 200 (#DEFINE tmp 200) que ser usado para determinar o tempo que os
LEDs piscam, e uma varivel global inteira de 1 BYTE x (int8 x;) que ser responsvel
pelo endereo de cada boto assim que pressionado.
A funo principal (void main()) construda de forma simples, inicializando todos os
pinos A como entrada (set_tris_a(0x00)) e os pinos B como sada (set_tris_b(0xFF)) e
logo depois entra na estrutura de repetio infinita (while(true)), nela formada s com
estrutura de deciso if. Um par de condies responsvel para enderear o boto e
executar a sua funo (if(input(PIN_A1)==0)) e (if(x==1)) respectivamente. A condio
(PIN_A0)==0 diz que a mudana da alimentao de 5V (nvel lgico 1) para 0V (nvel
lgico 0), assim entrar no bloco de instrues que so x=1, x=2 e x=3 respectivo para
os trs botes. As outras trs condies responsvel pela ao de cada boto, sendo o
primeiro bloco que faz todos os LEDs piscarem: coloca todos os pinos B em alta
(output_b(0b11111111);), aguarda um tempo de 200 milissegundos (delay_ms(tmp);) e
coloca todos os pinos B em baixa (output_b(0b00000000);) e aguarda novamente 200
milissegundos. O segundo bloco faz todos piscarem alternados: coloca uma metade dos
pinos B em alta e a outra em baixa (output_b(0b10101010);), aguarda um tempo de 200
milissegundos, depois inverte os pinos que estavam e alta para baixa e vice-versa
(output_b(0b01010101);) e aguarda 200 milissegundos. E o terceiro bloco faz todos
desligarem: colocando todos os pinos B em baixa (output_b(0b00000000);).
Cdigo
#include <16F877A.h> //inclusao do PIC
#FUSES NOWDT //WATCH DOG desabilitado
#FUSES BROWNOUT//reset por queda de tensao habilitado
#FUSES NOLVP //programacao em baixa tensao desabilitada
#FUSES XT //oscilador XT
#use delay(clock=4000000) //determinao do cristal oscilador

#DEFINE tmp 200 //constante para o tempo

int8 x=0; //variavel para endereo dos botoes

void main(){ //funcao principal
set_tris_a(0x00); //declarando todos os pinos A como entrada
set_tris_b(0xFF); //declarando todos os pinos B como entrada
while(TRUE){ //loop infinito
if(input(PIN_A1)==0){ //se botao 1 for pressionado
x=1; //endereca a variavel em 1
} //fim da condicao
if(input(PIN_A2)==0){ //se botao 2 for pressionado
x=2; //endereca a variavel em 2
} //fim da condicao
if(input(PIN_A3)==0){ //se botao 3 for pressionado
x=3; //endereca a variavel em 3
} //fim da condicao
if(x==1){ //se enderecamento for igual a 1
output_b(0b11111111); //coloca todos os pinos B em alta
delay_ms(tmp); //aguarda 200 milissegundos
output_b(0b00000000); //coloca todos os pinos B em baixa
delay_ms(tmp); //aguarda 200 milissegundos
} //fim da condicao
if(x==2){ //se enderecamento for igual a 2
output_b(0b10101010); //pinos B1, B3, B5 e B7 em alta, resto em baixa
delay_ms(tmp); //aguarda 200 milisssegundos
output_b(0b01010101); //pinos B0, B2, B4 e B6 em alta, resto em baixa
delay_ms(tmp); //aguarda 200 milissegundos
} //fim da condicao
if(x==3){ //se enderecamento for igual a 3
output_b(0b00000000); //todos os pinos B em baixa
} //fim da condicao
} //fim do loop
} //fim da funcao principal


Circuito de Simulao

Figura 4: Circuito da pratica 2
Um circuito simples que envolve a adio em cada pino da porta B um resistor de 330,
para limitao da corrente, e um LED, todos aterrados e resistores de 330, para
limitao da corrente, alimentandos em 5V em trs pinos da porta A em paralelo botes
aterrados. Assim os trs pinos utilizado na porta A, recebem normalmente sinal de 5V
(nvel lgico alto) e quando o boto pressionado, recebem sinal de 0V (nvel lgico
baixo).
Prtica 3
Acione os LEDs que esto conectados a porta B do PIC 16F887A de acordo com o
boto que for pressionado: (Deve ser usado o TIMER 0 para os ajustes de tempo)
-Boto S0: todos piscam a cada 1 segundo.
-Boto S1: piscam alternados a cada 1/2 segundo.
-Boto S2: desliga os leds.

Fluxograma

Figura 5: Fluxograma da pratica 3
Desenvolvimento
Um programa mais complexo, pois envolve a adio de interrupo de tratamento
automtico em relao a prtica 2. O cabealho continua o mesmo, mas com uma
observao na escolha do valor do clock pois a mudana do valor do cristal de 4MHz
para outro ir interferir nos clculos feitos no programa. Como a prtica requer que o
programa seja feito usando interrupo por TIMER 0 e foi determinado tempos para os
LEDs piscarem (1 segundo e segundo) foi escolhido um oscilador de 4MHz, o PIC
divide o clock internamente por 4 para executar um ciclo de mquina. Para se atingir os
tempo necessrio, utiliza um divisor eletrnico capaz de reduzir a frequncia, o
prescaler, que no PIC16F877A pode assumir valores de 2, 4, 8, 16, 32, 64, 128 ou 256
como mostra a Figura 6.

Figura 6: Taxa de prescaler do PIC16F877A
TIMER 0 possui 8 bits como temporizador/contador de acordo com folha de dado do
PIC, ou seja, sua contagem vai de 0 255. Uma formula genrica para se calcular a
frequncia de contagem :

8

Onde clock o valor do cristal oscilador, ciclomaq igual a 4, prescaler divisor de
frequncia e cont8bits o valor da contagem. Para determinar o tempo de contagem basta
fazer a relao de 1 pela frequncia de contagem:

=
1

Ento para ter um tempo de 1 segundo foi utilizado um prescaler de 64 (setup_timer_0
(RTCC_DIV_64);) e o valor da contagem de 125 (set_timer0(131+get_timer0());)
obtendo o tempo de contagem de 0,008 segundo. E para meio segundo foi utilizado um
prescaler de 16 (setup_timer_0 (RTCC_DIV_16);) e o valor da contagem de 125
(set_timer0(131+get_timer0());) obtendo o tempo de contagem de 0,25 segundos. Para
se chegar ao tempo pedido, uma varivel local inteira de 1 BYTE com caracterstica
esttica cont (static int cont;) foi criada para ser responsvel pela contagem que ir
atingir os valores do tempo corretamente. Uma varivel global inteira de 1 bit x (int1 x;)
foi criada para enderear os botes 1 e 2, uma varivel local inteira de 1 bit led (int1
led;) foi criada para assumir valores lgicos responsveis por acender ou apagar os
LEDs no circuito.
A funo de interrupo TIMER 0 (void interrupo_timer0()) criada a partir de uma
diretiva (#INT_TIMER0), que foi desenvolvida para atender a aes dos botes 1 e 2.
Quando a varivel x assumir valor igual a 0 todos os LEDs piscam a cada 1 segundo,
onde entra na condio (if(x==0)). O comando set_timer0(131+get_timer0()) diz que o
contador ir comear com valor de 131 + o tempo que levou para chegar at a linha
respectiva do cdigo. O comando cont++ uma contagem de incremento de 1 em 1 na
varivel cont, quando a varivel assumir valor de 125 (if(cont==125)) o tempo de
estouro do timer ser atingindo uma vez e levado 1 segundo para chegar nessa
estrutura de condio, assim zerado a varivel cont, tambm atribudo uma
operao lgica inversora na varivel led (led=!led;), ou seja, se o valor da varivel era
1 ser convertido para 0 e vice-versa. Logo em seguida feita toda uma sequncia de
atribuies a cada pino da porta B o valor da varivel led. Um procedimento semelhante
feita quando a varivel x assumir valor igual a 1, entrando na condio que os LEDs
piscam alternados a cada segundo, onde entra na condio (if(x==1)), que tambm
faz o contador iniciar com valor de 131 + o tempo levado para chegar na linha respectiva
do cdigo, um comando de incremento de 1 em 1, quando a varivel atingir o valor de
250 o timer 0 ter estourado duas vezes e assim levado um tempo de meio segundo
para chegar nessa condio (if(cont==250)), assim zerado a varivel de contagem,
atribudo a operao lgica inversora na varivel led que ser atribudo a cada pino da
porta B, mas com um detalhe, que 4 dos 8 pinos ser atribudo novamente com a
inverso da varivel (output_bit(PIN_B1,!led);).
Na funo principal (void main()) feita a configurao de entrada para os pinos A
(set_tris_a(0x00);) e sada para os pinos B (set_tris_b(0xFF);), habilitao da
interrupo global (enable_interrupts(GLOBAL);) que evita do compilador gerar todo
cdigo para tratamento de interrupo. J na estrutura de repetio infinita, feita trs
condies respectiva a cada boto. Na primeira, quando pino A1 mudar de 5V para 0V
(if(input(PIN_A1)==0)), atribui a varivel x em 0, habilita a interrupo TIMER 0
(enable_interrupts(INT_TIMER0);), instala o cristal oscilador interno
(setup_timer_0(RTCC_INTERNAL);) e um prescaler de 64
(setup_timer_0(RTCC_DIV_64);). Na segunda, quando pino A2 muda o valor lgico 1
para 0, atribui a varivel x em 1, habilita a interrupo TIMER 0, instala o cristal oscilador
interno e um prescaler de 16. E na terceira, desabilita a interrupo TIMER 0
(disable_interrupts(INT_TIMER0);) e coloca todos os pinos da porta B em baixo.
Cdigo
#include <16F877A.h>
#use delay (clock=4000000)
#fuses HS,NOWDT,PUT,NOLVP

int1 x; //variavel para enderear cada boto

#INT_TIMER0
void interrupcao_timer0 (){ //funo de interrupo timer0
int1 led; //variaveis respectivas para cada leds. "int1" ou ""static boolean" variavel
de 1 bit
static int8 cont; //variavel para contagem
if(x==0){ //se boto no pino B5 foi presionado
set_timer0(131+get_timer0()); //timer0 ira iniciar em 131 + o que foi acumalado
no pela linhas do codigo
cont++; //contagem em 1
if(cont==125){ //quando cont for 125 tera levado um tempo de 1seg para ativar
a condio
cont=0; //zera o cont
led=!led; //operao logica inversora (1->0) ou (0->1)
output_bit(PIN_B0,led); //joga o valor da variavel (1 ou 0) no pino
respectivo. "1" acende o led e "0" apaga o led
output_bit(PIN_B1,led);
output_bit(PIN_B2,led);
output_bit(PIN_B3,led);
output_bit(PIN_B4,led);
output_bit(PIN_B5,led);
output_bit(PIN_B6,led);
output_bit(PIN_B7,led);
}
}
if(x==1){ //se boto no pino B6 foi presionado
set_timer0(131+get_timer0()); //timer0 ira iniciar em 131 + o que foi acumalado
no pela linhas do codigo
cont++; //contagem em 1
if(cont==250){ //quando cont for 125 tera levado um tempo de 1seg para ativar
a condio
cont=0; //zera o cont
led=!led; //operao logica inversora (1->0) ou (0->1)
output_bit(PIN_B0,led); //joga o valor da variavel (1 ou 0) no pino
respectivo. "1" acende o led e "0" apaga o led
output_bit(PIN_B1,!led);
output_bit(PIN_B2,led);
output_bit(PIN_B3,!led);
output_bit(PIN_B4,led);
output_bit(PIN_B5,!led);
output_bit(PIN_B6,led);
output_bit(PIN_B7,!led);
}
}
}

main (){ //funo principal
set_tris_a(0x00);
set_tris_b(0xFF);
enable_interrupts(GLOBAL);
while (TRUE){ //lao infinito
if (input(PIN_A1)==0){
x=0; //endereo do boto 1
enable_interrupts(INT_TIMER0); //Habilitao da interrupcao GLOBAL e
TIMER 0
setup_timer_0(RTCC_INTERNAL);
setup_timer_0(RTCC_DIV_64); //usa TIMER 0 com CLOCK interno;
PRESCALER dividido por 64
}
if (input(PIN_A2)==0){
x=1; //endereo do boto 2
enable_interrupts(INT_TIMER0); //Habilitao da interrupcao GLOBAL e
TIMER 0
setup_timer_0(RTCC_INTERNAL);
setup_timer_0(RTCC_DIV_16); //usa TIMER 0 com CLOCK interno;
PRESCALER dividido por 16
}
if (input(PIN_A3)==0){
disable_interrupts(INT_TIMER0); //desabilitao as interrupes GLOBAL e
TIMER 0
output_b(0b00000000); //coloca em "baixo" os pinos 0,1,2,3 e 4 do porta B
}
}
}

Circuito de Simulao

Figura 7: Circuito da pratica 3
Um circuito simples que envolve a adio em cada pino da porta B um resistor de 330,
para limitao da corrente, e um LED, todos aterrados e resistores de 330, para
limitao da corrente, alimentandos em 5V em trs pinos da porta A em paralelo botes
aterrados. Assim os trs pinos utilizado na porta A, recebem normalmente sinal de 5V
(nvel lgico alto) e quando o boto pressionado, recebem sinal de 0V (nvel lgico
baixo).
Prtica 4
Indique em trs displays de 7 segmentos conectado aporta B do PIC 16F877A o valor
referente a tenso do potencimetro conectado ao pino A0.
Fluxograma

Figura 8: Fluxograma da pratica 4
A ideia para realizar tal funo efetuar a leitura do potencimetro no momento e feito
o clculo para converso analgico/digital e seta digito para cada casa decimal referente
ao display de 7 segmentos.
Desenvolvimento
A ideia se baseia na comutao dos displays para representar cada nmero referente
posio unidade, dezena, centena e milhar. O clculo para demostrar o valor de
analgico para digital feita de forma simples: com uma tenso de fundo de escala, ou
seja, uma tenso de referncia, a utilizada foi de 5V. Tendo a tenso de referncia,
verifica a capacidade do microcontrolador de armazenar o valor analgico para digital,
o PIC16F877A tem a capacidade de 10 bits, de acordo com datasheet, ento no clculo
a seguir nosso valor 5V analgico assumir em sinal digital um valor de 1023. Com uma
regra de trs, se obtm tais valores:

=
(

)
(2

1)

Onde

o valor final da converso,

o valor analgico lido pelo PIC,

a tenso de fundo de escala e a capacidade de bits de armazenado do PIC.

Para comutao de cada display, utilizado transistores do tipo NPN modelo BC547A
onde so acionados pelos pinos D7, D6, D5 e D4 do MCU.
Cdigo
#include <16F877A.h> //inclusao do PIC
#DEVICE adc=10 //10 bits referente ao sinal analogico
#FUSES NOWDT //WATCH DOG desabilitado
#FUSES NOBROWNOUT //reset por queda de tensao habilitado
#FUSES NOLVP //programacao em baixa tensao desabilitada
#FUSES HS ////oscilador HS
#use delay (clock=4000000) //determinao do cristal oscilador

//atribuicoes para gerar o numero correspondente no display 7 segmento
#DEFINE zero output_b(0b00111111)
#DEFINE um output_b(0b00000110)
#DEFINE dois output_b(0b01011011)
#DEFINE tres output_b(0b01001111)
#DEFINE quatro output_b(0b01100110)
#DEFINE cinco output_b(0b01101101)
#DEFINE seis output_b(0b01111100)
#DEFINE sete output_b(0b00000111)
#DEFINE oito output_b(0b01111111)
#DEFINE nove output_b(0b01100111)

//atribuicoes responsavel por setar cada display independetemente
#DEFINE d7h 0x80
#DEFINE d6h 0x40
#DEFINE d5h 0x20
#DEFINE d4h 0x10

//funcao criada para gerar o numero no display
void display(int x, BYTE end){ //x: reponsavel pelo numero a ser gerado; end:
responsavel por setar o display correspondente
if(x==0){ //se numero for 0
zero; //atribuicao 0
}
if(x==1){ //se numero for 1
um; //atribuicao 1
}
if(x==2){ //se numero for 2
dois; //atribuicao 2
}
if(x==3){ //se numero for 3
tres; //atribuicao 3
}
if(x==4){ //se numero for 4
quatro; //atribuicao 4
}
if(x==5){ //se numero for 5
cinco; //atribuicao 5
}
if(x==6){ //se numero for 6
seis; //atribuicao 6
}
if(x==7){ //se numero for 7
sete; //atribuicao 7
}
if(x==8){ //se numero for 8
oito; //atribuicao 8
}
if(x==9){ //se numero for 9
nove; //atribuicao 9
}
output_d(end); //funcao que ira setar o display
delay_ms(5); //tempo para entrar na comutao do outro display
}

void main(){
int cont=0; //variavel de contagem
int32 u,d,c,m; //variaveis respectivas as casas decimais
int32 valor, med, tensao=0; //para leitura analogica; para media das leituras; para
leitura digital
set_tris_b(0xFF); //seta todos os pinos B como saidas
setup_ADC_ports (all_analog); //utilizar todas as portas analogicas
setup_ADC (ADC_CLOCK_INTERNAL); //utilizar clock interno
set_adc_channel(0); //utilizar canal 0 como leitor analogico
delay_ms(100); //aguarda um tempo para comutacao do pino analogico, tempo
minimo requerido 10us
while(true){ //loop infinito
while(cont!=10){ //loop para conseguir media de 10 leituras
valor=read_adc(); //leitura analogico
med=(valor*5000)/1023; //calculo para conversao analogica/digital
tensao=tensao+med; //incrementacao para media
cont=cont+1; //incremento para contagem
}
tensao=tensao/cont; //calculo da media
cont=0; //zerar contador
u=tensao/10; //divisao para retirar a unidade
u=u*10; //multiplicacao para voltar a unidade zerada
u=tensao-u; //subtracao para obter o valor o numero da unidade pura
d=tensao/100; //divisao para retirar a dezena
d=d*100; //multiplicacao para voltar a dezena zerada
d=(tensao-(d+u))/10; //subtracao para obter o numero da dezena pura
c=tensao/1000; //divisao para retirar a centena
c=c*1000; //multiplicacao para zerar a centena
c=tensao-c; //subtracao para retirar milhar
c=c-((d*10)+u); //calculo para retirar dezena e unidade
c=c/100; //divisao para obter centena pura
m=tensao/1000; //divisao para obter milhar pura
display(m,d7h); //executa funcao para representar a casa milhar
output_d(0x00); //zera os displays
display(c,d6h); //executa funcao para representar a casa centena
output_d(0x00); //zera os displays
display(d,d5h); //executa funcao para representar a casa dezena
output_d(0x00); //zera os displays
display(u,d4h); //executa funcao para representar a casa unidade
output_d(0x00); //zera os displays
tensao=0; //zera a tensao media
}
}


Circuito

Figura 9: Circuito da pratica 4
Circuito onde implementa os pinos B ligados a resistores de 330 conectados aos
quatros displays. Os displays escolhidos so de ctodo comum, ento os transistores
so conectado em seus respectivos aterramentos, com suas bases ligadas aos pinos
D.
Prtica 5
Indique em um display LCD o valor referente a tenso do potencimetro conectado ao
pino A0.
Fluxograma

Figura 10: Circuito da pratica 5
A ideia para realizar tal funo efetuar a leitura do potencimetro no momento e feito
o clculo para converso analgico/digital e imprimi a tenso no display LCD.
Desenvolvimento
A diferena fundamento do cdigo se d na incluso da biblioteca LCD (#include
<mod_lcd.h>) criada pelo autor do livro PIC programao em C do autor Fbio Pereira.
Tal biblioteca responsvel pela impresso do no display LCD (printf
(lcd_escreve,"tensao: %lu mV",tensao);). Requerendo antes a inicializao do display
(lcd_ini();).
Cdigo
#include <16F877A.h> //inclusao do PIC
#device adc=10 //Configura o compilador para conversor A/D de 8 bits
#use delay (clock=4000000) //determinao do cristal oscilador
#fuses XT //oscilador XT
#fuses NOWDT //WATCH DOG desabilitado
#fuses BROWNOUT//reset por queda de tensao habilitado
#fuses NOLVP //programacao em baixa tensao desabilitada
#include <mod_lcd.c> //inclusao da biblioteca LCD

void main () //funcao principal
{
int32 valor,tensao; //valor para conversao

lcd_ini(); //Iniciar o display LCD
setup_ADC_ports (all_analog); //Usar a porta RA0-analogica
setup_adc(ADC_CLOCK_INTERNAL); //Ler junto com pulso clock
set_adc_channel(0); //Selecionar o canal 0
delay_us(10); //Colocar 10us pois o tempo que o pic leva para ler o sinal
while(true){
valor = read_adc(); //Leitura do sinal, valor, analgico
tensao = (valor*5000)/1023; //calculo para converso
lcd_escreve('\f'); //limpa tela do display lcd
printf(lcd_escreve,"tensao: %lu mV",tensao); //texto indicativo do valor de tenso
convertido
delay_ms (250); //aguarda 250ms //tempo de aguardo
}
}


Circuito

Figura 21: Circuito da pratica 5
Tal circuito montado de forma simples, levando em considerao que as conexes no
display LCD baseada na biblioteca inclusa.