Centro de Tecnologia Microgenios - Todos os direitos reservados

Clique aqui para Imprimir o doc

umento

Programando o Timer0

1.0 Estudo dos Timers/Counters do PIC

O TIMER0:
Realizamos nas unidades passada um estudo no muito aprofundado sobre as funes e
caracteristicas dos TIMERS do PIC. Agora chegou o momento de estudarmos mais
profundamente os recursos e a programao dos registradores e modos de trabalho
desses temporizadores e contadores.
O TIMER0 pode operar como temporizador ou como contador. Esse perifrico do PIC
pode operar em dois modos:
Modo 8 bits, com contagem mxima de 0 a 255
Modo 16 bits, com contagem mxima de 0 a 65535
Dizemos que o timer esta operando como temporizador quando a referencia do clock de
incremento da contagem realizada pelo clock interno do PIC, e dizemos que o timer
esta operando como contador quando a referencia do clock de incrremento da contagem
proveniente de um clock externo ao PIC. (pulso aplicado no pino T0CK1
Os Registradores relacionados ao TIMER0 so:

Figra 01 - Registrador relacionados com o TIMER0

TMR0L um registrador de contagem de 8 bits que possui a funo de armazenar a
parte baixa do valor de contagem programada do TIMER0.
TMR0H um registrador de contagem de 8 bits que possui a funo de armazenar a
parte alta do valor de contagem programada do TIMER0.
Os registradores TMROL e TMR0H juntos formam um nico registrador de 16 bits, que
nos permite uma contagem mxima de 0 a 65535.
INTCON um registrador de 8 bits responsvel pela configurao do modo de
operao do TIMER0. Podemos definir atravs desse registrador o valor do prescaler
que desejamos acionar, o modo de operao de contagem de 8 ou 16 bits, seleo da
fonte de clock (interna ou externa) para o timer, seleo de disparo do timer atravs de
borda de subida ou borda de descida do clock externo no pino RA4/T0CK1.
ESTUDE O MATERIAL DA SEGUNDA UNIDADE DO CURSO PARA OBTER
MAIORES INFORMAES SOBRE OS MODOS DE TRABALHO DOS
TIMERS.
A final como realmente funciona um TIMER?
Primeiramente vamos estudar o TIMER0. Analise o diagrama do Timer0 seguinte:

Repare que os esquemas parecem com uma instalao eltrica, no qual vai habilitando
ou desabilitando mdulos, de acordo com o chaveamanto definido pelo operador.

Agora vamos elaborar um desafio:

Exemplo 01:
Vamos programar o TIMER0 para funcionar como temporizador programado para
"estourar" sua contagem em 3 segundos. A cada estouro do TIMER0 ser alterado os
estados dos leds ligado ao PORTD, e uma nova contagem de 3 segundo reiniciada.
Descrio do nosso hardware:

Configuraes:
Cristal: 8 Mhz
Microcontrolador: PIC18F452

Vamos programar nosso TIMER0 passo a passo: Acompanhe a numerao da figura

seguinte:

Numerao Funo
1
Cristal externo
Chave seletora de funo: define se o
2
timer0 ir operar como temporizador
ou contador
PSA : Chave seletora que habilita ou
desabilita a utilizao do prescaler
3
(podemos considerar prescaler como
um "redutor" de tempo)
4
Escala de ajuste do prescaler
Chave seletora do modo de contagem
5
do TIMER0: formato 8 bits ou
formato 16 bits
Registradores de contagem TMR0L e
6
TMR0H (dois registradores de 8 bits,
formando 16 bits)
Bit de sinalizao de estouro do
7
TIMER0 (muita ateno no uso desse
bit)
8
Chave liga desliga do Timer0
Vamos inciar nosso programa
void main(){
//************ configurao do Leds ************************

trisd = 0; //define portd como saida

portd = 0; //estado incial dos leds apagado
//*********** configurao do Timer0 ************************
//vamos seguir a numerao
//cristal de 8Mhz, ciclo de mquina: 8MHz / 4 = 2Mhz --> 1/2Mhz =
0,5us
t0con.t0cs = 0; //numero2: timer0 operando como temporizador
t0con.psa = 0; //numero3: prescaler ativado
t0con.t0ps2 = 1; //numero4: define prescaler 1:128
t0con.t0ps1 = 1; //numero4: define prescaler 1:128
t0con.t0ps0 = 0; //numero4: define prescaler 1:128
t0con.t08bit = 0; //numero5: define contagem no modo 16 bits
tmr0h = ?? ;
tmr0l = ??;
intcon.tmr0if = 0; //numero7: apaga flag de estouro do timer0,
pois fundamental para a sinalizao do estouro
t0con.tmr0on = 1; //numero8: liga timer0
while(1){
if (intcon.tmr0if == 1){
portd = ~portd; //inverte o estado do portd
tmr0l = ??;
tmr0h = ?? ;
intcon.tmr0if = 0; //apaga flag de estouro do timer0 para uma
nova contagem de tempo
}
}
}

Calculo do tempo de estouro do timer0:

Sabemos que a formula para o calculo do estouro do Timer0 :
tempo de estouro = ciclo de mquina * prescaler * (modo 8/16 bits - valor de contagem
inicial em TMR0L e TMR0H)
logo teremos: (lembre-se que nosso objetivo gerar um pisca pisca com tempo de 3
segundos, para isso converteremos 3 segundos para escala de microsegundo: 3000000)
3.000.000us = 0,5us * 128 (65536 - valor de contagem)
Logo teremos:
Valor de contagem = 18661
O valor 18661 justamente o valor que devemos carregar em TMR0L e TMR0H. Para
realizarmos com facilidade esta operao matemtica, basta simplesmente converter
este valor decimal para hexadecima:
18661 (decimal) = 48E5 , teremos ento:
TMR0L = 0XE5;

TMR0H = 0X48;
Com certeza voc dever estar pensando da onde surgio o valor 1:128 do prescaler no
exerccio?? Na formula de temporizao do Timer0, mais fcil encontrarmos o valor
de carregagem nos registradores de contagem TMR0H e TMR0L do que o valor do
prescaler, pois lembre-se que temos algumas poucas opes de valores de prescaler, que
j so pr-definidas no hardware do PIC. No exerccio adotamos um valor alto do
prescaler, pois nossa temporizao de 3 segundos considerado um tempo alto para
quem trabalha em escalas de us segundos.
pronto, nosso programa final esta pronto, basta compilarmos e visualizarmos seu
funcionamento no kit de desenvolvimento.
Programa Final:
void main(){
//************ configurao do Leds ************************
trisd = 0; //define portd como saida
portd = 0; //estado incial dos leds apagado
//*********** configurao do Timer0 ************************
//vamos seguir a numerao
//numero1: cristal de 8Mhz, ciclo de mquina: 8MHz
/ 4 = 2Mhz --> 1/2Mhz = 0,5us
t0con.t0cs = 0; //numero2: timer0 operando como temporizador
t0con.psa = 0; //numero3: prescaler ativado
t0con.t0ps2 = 1; //numero4: define prescaler 1:128
t0con.t0ps1 = 1; //numero4: define prescaler 1:128
t0con.t0ps0 = 0; //numero4: define prescaler 1:128
t0con.t08bit = 0; //numero5: define contagem no modo 16 bits
tmr0l = 0xe5;
tmr0h = 0x48 ;

//carrega o valor baixo do numero 18661

//carrega o valor alto do nmero 18661

intcon.tmr0if = 0; //numero7: apaga flag de estouro do timer0,

pois fundamental para a sinalizao do estouro
t0con.tmr0on = 1; //numero8: liga timer0
while(1){
if (intcon.tmr0if == 1){ //monitorando estado do flag de estouro
do timer0
portd = ~portd; //inverte o estado do portd
tmr0l = 0xe5;
//carrega o valor baixo do numero 18661
tmr0h = 0x48 ; //carrega o valor alto do nmero 18661
intcon.tmr0if = 0; //apaga flag de estouro do timer0 para uma
nova contagem de tempo
}
}
}

Dica: Refaa o programa acima criando um pisca pisca com temporizao de 5

segundos (ligado e desligado).

Exemplo 02:

Vamos elaborar um programa de varredura de teclado utilizando os recursos de

temporizao do Timer0.
Neste novo exemplo, iremos realizar um programa que ir ler os estados de 2 teclas
ligada ao PIC a cada 20ms. Enquando nosso timer0 permanece incrementando sua
contagem, ficaremos alternando o estado de um led para simbolizar o funcionamento do
programa.
Nosso hardware:

Configuraes:
Cristal: 8 Mhz
Microcontrolador: PIC18F452

Esboo do programa:
Calculo do tempo de estouro TIMER0:
tempo de estouro = ciclo de mquina * prescaler * (modo 8/16 bits - valor de contagem
inicial em TMR0L e TMR0H)
Logo: (lembre-se que nosso tempo desejado agora de 20ms, ou seja, 20 000us

20.000us = 0,5us * 16 * (65536 - valor de contagem)

portanto:
valor de contagem = 63036

O valor 63036 justamente o valor que devemos carregar em TMR0L e TMR0H. Para
realizarmos com facilidade esta operao matemtica, basta simplesmente converter
este valor decimal para hexadecima:
63036 (decimal) = F63C , teremos ento:
TMR0L = 0X3C;
TMR0H = 0XF6;

Programa:
//********************** rotina de varredura do teclado
**************************************
void varredura_teclas(){
if (portb.f0 == 0 ){
portb.f7 = 1;
}

//verifica se tecla rb0 foi pressionada

if (portb.f1 == 0 ){
portb.f7 = 0;
}

//verifica se tecla rb1 foi pressionada

portb.f6 = ~portb.f6;
led rb6

//fica constantemente alterando o estado do

//esta alterao ocorre a cada 20ms

tmr0l = 0x3c;
//carrega o valor baixo do numero 18661
tmr0h = 0xf6; //carrega o valor alto do nmero 18661
intcon.tmr0if = 0; //apaga flag de estouro do timer0 para uma nova
contagem de tempo
}
//********************** programa
principal*****************************************************
void main(){
//************
trisb.f0 =
trisb.f1 =
trisb.f6 =
trisb.f7 =

configurao do Leds ************************

1; //define portb.rb0 como entrada
1; //define portb.rb1 como entrada
0; //define portb.rb6 como sada
0; //define portb.rb7 como sada

portb.f6 = 0; //apaga led rb6

portb.f7 = 0; //apaga led rb7
//*********** configurao do Timer0 ************************
//vamos seguir a numerao
//numero1: cristal de 8Mhz, ciclo de mquina: 8MHz

/ 4 = 2Mhz --> 1/2Mhz = 0,5us

t0con.t0cs = 0; //numero2: timer0 operando como temporizador
t0con.psa = 0; //numero3: prescaler ativado
t0con.t0ps2 = 0; //numero4: define prescaler 1:16
t0con.t0ps1 = 1; //numero4: define prescaler 1:16
t0con.t0ps0 = 1; //numero4: define prescaler 1:16
t0con.t08bit = 0; //numero5: define contagem no modo 16 bits
tmr0l = 0x3c;
tmr0h = 0xf6 ;

//carrega o valor baixo do numero 63036

//carrega o valor alto do nmero 63036

intcon.tmr0if = 0; //numero7: apaga flag de estouro do timer0,

pois fundamental para a sinalizao do estouro
t0con.tmr0on = 1; //numero8: liga timer0
while(1){
if (intcon.tmr0if == 1) varredura_teclas();
}
}

Obs: Podemos substituir o seguinte trecho do nosso programa por uma simples linha de
cdigo:
t0con.t0cs = 0; //numero2: timer0 operando como temporizador
t0con.psa = 0; //numero3: prescaler ativado
t0con.t0ps2 = 0; //numero4: define prescaler 1:16
t0con.t0ps1 = 1; //numero4: define prescaler 1:16
t0con.t0ps0 = 1; //numero4: define prescaler 1:16
t0con.t08bit = 0; //numero5: define contagem no modo 16 bits

e
t0con.tmr0on = 1; //numero8: liga timer0

por:
t0con = 0b10000011;

Desafio: Faa voc mesmo um programa de varredura de teclado operando o timer0

com tempo de varredura de 80ms.

voltar para o topo da pagina

Centro de Tecnologia Microgenios - Curso de Microcontroladores PIC - Programao

em C
Microgenios 1998 - 2008. Todos os direitos reservados. proibido cpia parcial ou
integral desse material sem prvio aviso. Maiores informaes:
suporte@microgenios.com.br