apostila curso pic microgenios c

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 não muito aprofundado sobre as funções e

caracteristicas dos TIMERS do PIC. Agora chegou o momento de estudarmos mais

profundamente os recursos e a programação dos registradores e modos de trabalho

desses temporizadores e contadores.

O TIMER0 pode operar como temporizador ou como contador. Esse periférico do PIC

pode operar em dois modos:

Modo 8 bits, com contagem máxima de 0 a 255

Modo 16 bits, com contagem máxima 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 são:

Figra 01 - Registrador relacionados com o TIMER0

TMR0L é um registrador de contagem de 8 bits que possui a função de armazenar a

parte baixa do valor de contagem programada do TIMER0.

TMR0H é um registrador de contagem de 8 bits que possui a função 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 máxima de 0 a 65535.

INTCON é um registrador de 8 bits responsável pela configuração do modo de

operação do TIMER0. Podemos definir através desse registrador o valor do prescaler

que desejamos acionar, o modo de operação de contagem de 8 ou 16 bits, seleção da

fonte de clock (interna ou externa) para o timer, seleção de disparo do timer através 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 INFORMAÇÕES 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 instalação elétrica, no qual vai habilitando

ou desabilitando módulos, 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.

Descrição do nosso hardware:

Configurações:

Cristal: 8 Mhz

Microcontrolador: PIC18F452

Vamos programar nosso TIMER0 passo a passo: Acompanhe a numeração da figura

seguinte:

Numeração Função

1 Cristal externo

2

Chave seletora de função: define se o

timer0 irá operar como temporizador

ou contador

3

PSA : Chave seletora que habilita ou

desabilita a utilização do prescaler

(podemos considerar prescaler como

um "redutor" de tempo)

4 Escala de ajuste do prescaler

5

Chave seletora do modo de contagem

do TIMER0: formato 8 bits ou

formato 16 bits

6

Registradores de contagem TMR0L e

TMR0H (dois registradores de 8 bits,

formando 16 bits)

7

Bit de sinalização de estouro do

TIMER0 (muita atenção no uso desse

bit)

8 Chave liga desliga do Timer0

Vamos inciar nosso programa

void main (){

//************ configuração do Leds ************************

trisd = 0; //define portd como saida

portd = 0; //estado incial dos leds apagado

//*********** configuração do Timer0 ************************

//vamos seguir a numeração

//cristal de 8Mhz, ciclo de máquina: 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 . t08bit = 0; //numero5: define contagem no modo 16 bits

tmr0h = ?? ;

tmr0l = ??;

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

pois é fundamental para a sinalização 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 máquina * 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 operação matemática, basta simplesmente converter

este valor decimal para hexadecima:

18661 (decimal) = 48E5 , teremos então:

TMR0L = 0XE5;

TMR0H = 0X48;

Com certeza você deverá estar pensando da onde surgio o valor 1:128 do prescaler no

exercício?? Na formula de temporização do Timer0, é mais fácil 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 opções de valores de prescaler, que

já são pré-definidas no hardware do PIC. No exercício adotamos um valor alto do

prescaler, pois nossa temporização 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 (){


trisd = 0; //define portd como saida

portd = 0; //estado incial dos leds apagado



//numero1: cristal de 8Mhz, ciclo de máquina: 8MHz

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







tmr0l = 0xe5 ; //carrega o valor ba ixo do numero 18661

tmr0h = 0x48 ; //carrega o valor alto do número 18661

intcon . tmr0if = 0; //numero7: apaga flag de estouro do 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 número 18661

intcon . tmr0if = 0; //apaga flag de estouro do timer0 para uma

nova contagem de tempo

}

}

}

Dica: Refaça o programa acima criando um pisca pisca com temporização de 5

segundos (ligado e desligado).

Exemplo 02:

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

temporização 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:

Configurações:

Cristal: 8 Mhz

Microcontrolador: PIC18F452

Esboço do programa:

Calculo do tempo de estouro TIMER0: tempo de estouro = ciclo de máquina * 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 operação matemática, basta simplesmente converter

este valor decimal para hexadecima:

63036 (decimal) = F63C , teremos então:

TMR0L = 0X3C;

TMR0H = 0XF6;

Programa:

//********************** rotina de varredura do teclado

************************************** void varredura_teclas (){

if ( portb . f0 == 0 ){ //verifica se tecla rb0 foi pressionada

portb . f7 = 1;

}

if ( portb . f1 == 0 ){ //verifica se tecla rb1 foi pressionada

portb . f7 = 0;

}

portb . f6 = ~portb . f6 ; //fica constantemente alterando o estado do

led rb6

//esta alteração ocorre a cada 20ms

tmr0l = 0x3c ; //carrega o valor baixo do numero 18661

tmr0h = 0xf6 ; //carrega o valor alto do número 18661

intcon . tmr0if = 0; //apaga flag de estouro do timer0 para uma nova

contagem de tempo

}

//********************** programa

principal*********************** ******************************

void main (){


trisb . f0 = 1; //define portb.rb0 como entrada

trisb . f1 = 1; //define portb.rb1 como entrada

trisb . f6 = 0; //define portb.rb6 como saída

trisb . f7 = 0; //define portb.rb7 como saída

portb . f6 = 0; //apaga led rb6

portb . f7 = 0; //apaga led rb7



//numero1: cristal d e 8Mhz, ciclo de máquina: 8MHz

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




t0con . t0ps1 = 1; //numer o4: define prescaler 1:16



tmr0l = 0x3c ; //carrega o valor baixo do numero 63036

tmr0h = 0xf6 ; //carrega o valor alto do número 63036

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



while( 1){

if ( intcon . tmr0if == 1) varredura_tecl as ();

}

}

Obs: Podemos substituir o seguinte trecho do nosso programa por uma simples linha de

código:







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

por:

t0con = 0b10000011;

Desafio: Faça 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 - 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]

apostila curso pic microgenios c

Documents