Centro de Tecnologia Microgenios - Todos os direitos reservados

Clique aqui para Imprimir o doc

umento

Introduo ao estudo dos TIMERS

1.0 Os Timers/Counters
1.1 TIMER0
1.2 TIMER1
1.3 TIMER2
1.4 TIMER3

Os Timers/Counters
Os timers so ferramentas internas dos microcontroladores em geral
que servem para contagem de tempo, eventos, temporizao entre
outras funes.
O PIC18F452 possui internamente 4 TIMERS:

TIMER0
TIMER1
TIMER2
TIMER3

Vamos conhecer cada um desses temporizadores:

voltar para o topo da pgina

TIMER0

O TIMER0 um temporizador/contador de 8 ou 16 bits que

possuem duas funes bsicas:

Contagem de eventos externos (quando a entrada de

clock feita por meio do pino RA4/T0CKI;

Temporizao (contagem de tempo) quando os pulsos

de contagem proveniente do clock interno do PIC (o clock do
sistema dividido por 4).
O TIMER0 pode ser configurado para trabalhar com prescaler
dedicado. O prescaler nada mais do que um contador/divisor
programvel que utilizado para reduzir a freqncia do sinal de
clock aplicado ao TIMER0 por um fator conhecido.

O valor do prescaler pode ser configurado a partir dos bits

T0PS2, T0PS1 e T0PS0 do registrador T0CON (TIMER0 CONTROL
REGISTER);
O prescaler passa a ser uma importantssima ferramentas do
timer, pois atravs dele conseguimos gerar tempos muito maiores.
Quando o TIMER0 configurado para operar no modo de 8
bits, podemos efetuar contagens de 0 a 255 (limite da capacidade
para 8 bits). Quando a contagem chega at seu valor mximo de
255, o prximo pulso acarretaria o que chamamos de "estouro de
contagem", fazendo com que o valor de contagem de incio
novamente a partir do 0 (zero).
No caso anterior, caso tenhamos a interrupo do TIMER0
habilitada, no momento que ocorre o "estouro de contagem", seria
gerado um pedido de interrupo do TIMER0.
No modo 16 bits do TIMER0, seu funcionamento igual ao
modo de 8 bits, porm neste cado a faixa de contagem de 0 a
65535.
Os valores de iniciais de temporizao/contagem devem ser
carregados nos registradores especiais intitulado de TMR0L (TIMER0
Module Low Byte Register) e TMR0H (TIMER0 Module Hight Byte
Register);
Quando programamos os timers para atuarem como
temporizadores, estamos considerando que os pulsos que
incrementam os registradores de contagem so proveniente do valor
do oscilador / 4, ou seja, caso estivermos utilizando um cristal de
4MHz, iremos incrementar em uma unidade os registradores de
contagem a cada 1 us, pois 4Mhz/4 = 1MHz = 1us (microsegundos).

Dica:
Repare que a unidade resultante da diviso da Frequencia do
oscilador / 4 (ciclo de mquina) esta em MHz ( unidade de
frequncia), neste caso para sabermos o tempo (periodo), basta dividir 1
/ seu valor.

Ex: 1 / (Fosc / 4 )
Para um cristal de 8 MHz teremos o seguinte tempo de ciclo de
mquina:
1 / (8 / 4) = 0,5 us (microsegundos).

Os Registradores relacionados ao TIMER0 so:

Figura 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 TMR0L 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.

Faa download do diagrama esquemtico do TIMER0 disponvel na

informaes complementar dessa unidade.

Registradores
TIMER0:

de

configurao

do

O registrador T0CON responsvel pela configurao pelo modo de

operao do Timer0, de vital importncia conhecer todas as funes de
seus bits.

T0CON: (TIMER0 Counter Register)

TMR0ON T08BIT
Bit7

Bit6

T0CS

T0SE

PSA

T0PS2

T0PS1

T0PS0

Bit5

Bit4

Bit3

Bit2

Bit1

Bit0

TMR0ON: Bit de controle para ligar e desligar a contagem

do TIMER0;
0 - TIMER para de contagem
1 - Habilita a contagem do TIMER0
T08BIT: Bit de seleo de funcionamento do TIMER0 em 8
ou 16 bits;
0
TIMER0
configurado
para
funcionar
como
contador/temporizador em 16 bits;
1 - TIMER0 esta configurado para funcionar como contador
/temporizador de 8 bits;
T0CS: Bit de seleo de fonte de clock para o TIMER0;
0 - A fonte de clock proveniente do meio interno do chip
1 - A fonte de clock proveniente do pino T0CKI (meio
externo)
T0SE: Bit de seleo de borda (vlido somente caso a fonte
de clock seja pelo meio externo ao chip)
0 - Contagem do timer ocorre por borda de subida no Pino
T0CKI
1 - O incremento do timer ocorre na borda de descida no
pino T0CKI
/PSA: Bit de seleo da utilizao do prescaler;
1 - TIMER0 no utiliza prescaler. A cada alterao do pulso
de clock, corre incremento de uma unidade nos registradores de
contagem.
0 - TIMER0 utiliza prescaler.
T0PS2; T0PS1; T0PS0 : Bits de seleo de fonte de
prescaler

T0PS2 T0PS1 T0PS0 Prescaler

1

1:256

1:128

1:64

1:32

1:16

1:8

1:4

1:2

Configurao do Prescaler:
Como sabemos, atravs do prescaler conseguimos tempos
maiores com os timers, para entendermos melhor sua utilizao
acompanhe o exemplo abaixo:
Digamos que o ciclo de mquina no PIC sej de 1us e o
TIMER0 esteja configurado no modo 8 bits (contagem de 0 a 255) e
sem o presacaler. O TIMER0 ira "estourar" sua contagem em 256us.
Agora digamos que para o mesmo anunciado anterior,
configuramos e acionamos o prescaler para 1:2. Nosso intervalo de
"estouro" do TIMER0 no mais ser 256us mas sim 512us.
Se ao invs de prescaler de 1:2 utilizarmos prescaler 1:32, o
tempo agora ser de 256us x 32 = 8192us.

Como calcular o tempo de estouro do TIMER0?

Para calcular o tempo de "estouro" do TIMER com prescaler,
utilizamos a seguinte frmula:
Tempo de estouro: ciclo de mquina x prescaler x (modo 8
/16bits valor de contagem).
Em que:

Ciclo de mquina: o valor da relao entre: 1 / (Fosc / 4 ),

onde Fosc justamente a frequencia do cristal.
Obs: modo PLL desabilitado, iremos estudar esta funo mais
adiante.
Prescaler : o fator de diviso programado. Podemos
considerar como sendo um "redutor" de frequencia.
Modo 8/16bits: o modo de contagem programado no TIMER0,
para 8 bits o valor 256, e para 16 bits, o valor ser de 65535.
Valor de contagem: o valor de carregagem no registrador de
contagem TMR0H eTMR0L.

Exemplo:
Precisamos ligar e desligar um rel a cada segundo ( um segundo
ligado e um segundo desligado), estamos utilizamdo um cristal
de 8Mhz, utilizaremos para isso os recursos do Temporizador Timer0,
acompanhe:
T0CON = 0B10000110; //configura timer modo 16 bits, com prescaler 1:128, fonte de
clock interno
TMR0L = 0XF6;
//carrega valores de contagem C2F6 equivale a
TMR0H = 0XC2;
//carrega valores de contagem

Calculo do tempo de estouro do Timer0:

Tempo de estouro: 1 / (8 / 4) x 128 x (65536 49910 )
Tempo de estouro: 1.000.064 us (microsegundos) ou aproximadamente
1 segundo.

obs: o valor 49910 surgio da converso do valor em hexadecimal

F6C2 para decimal

O registrador INTCON
O registrador INTCON possui diversar funes, entre elas a de
habilitar algumas interrupes do PIC (veremos mais adiante no nosso
curso) e de armazenar os bits de estatus de estouro do TIMER0:

INTCON (Interrupt Control)

GIE/GIEH PEIE/GIEL TMR0IE
Bit7

Bit6

Bit5

INT0IE

RBIE

TMR0IF

INT0IF

RBIF

Bit4

Bit3

Bit2

Bit1

Bit0

Iremos estudar todos esses bits mais adiante em nosso curso,

pois eles tratam das configuraes das interrupes, e neste momento
no importante conhecer alguns deles. Vamos apresentar somente os
bits que so utilizados nos TIMERS.
INTCON. GIEH = bit de acionamento da "chave geral das
interrupes" e habilitao das interrupes de alta prioridade
0 - liga a chave geral das interrupes
1 - desliga a chave geral das interrupes
INTCON. GIEL = bit de habilitao das interrupes de baixa
prioridade
0 - TIMER0 no ocorreu estouro de contagem (overflow)
1 - TIMER0 ocorreu estouro de contagem (overflow). Este bit deve
ser apagado por software.
INTCON.TMR0IE = bit que habilita interrupo do TIMER0 na
ocorrncia do estouro de contagem.
0 - Desabilita interrupo do TIMER0 por ocorrencia de estouro de
contagem (overflow)
1 - Habilita interrupo do TIMER0 por ocorrncia de estouro de
contagem (overflow).
INTCON. TMR0IF = bit sinalizador de estouro do TIMER0
0 - TIMER0 no ocorreu estouro de contagem (overflow)
1 - TIMER0 ocorreu estouro de contagem (overflow). Este bit deve
ser apagado por software.

Aprendendo a programar os TIMER0:

Conhecemos os registradores responsveis pela configurao do
TIMER0 do PIC, agora vamos configur-los:
Vamos nos recordar da frmula do TIMER0:
Tempo de estouro: ciclo de mquina x prescaler x (modo 8
/16bits valor de contagem).

Exemplo 1 :
Se tivermos conectado ao nosso PIC um cristal de 8 MHz e o TIMER0 seja
programado como temporizador, com prescaler de 1:4, modo 8 bits e contagem inicial
em TMR0L = 0, teremos ento:
Tempo de estouro: ciclo de mquina x prescaler x (modo 8
/16bits valor de contagem).
Tempo de estouro: 0,5us * 4 *(255 - 0)
Tempo de estouro: 510us

Exemplo 2 :
Se tivermos conectado ao nosso PIC um cristal de 8 MHz e o TIMER0 seja
programado como temporizador, com prescaler de 1:256, modo 16 bits e contagem
inicial em TMR0L = 0 e TMR0H = 0, teremos ento:
Tempo de estouro: ciclo de mquina x prescaler x (modo 8
/16bits valor de contagem).
Tempo de estouro: 0,5us * 256 * (65536 - 0)
Tempo de estouro: 8.388.608us, ou seja, 8, 388 segundos

Obs: Repare que este o tempo mximo de estouro do TIMER0

Vamos realizar mais um exemplo de programa:
vamos supor que desejamos que um led conectado ao pino RB0
do PIC pisque em intervalos de 1 segundo (ligado e desligado) utilizando
os recursos de temporizao do TIMER0.
Cristal: 8Mhz
PIC18F452
TIMER0 / MODO 16BITS
Acompanhe o esquema eletrico abaixo:

Primeiramente devemos programar os TIMER0:

Para este exemplo, vamos programar o TIMER0 no modo 16
bits (contagem de 0 a 65535), prescaler de 1:16, clock interno, cristal de
8Mhz e modo HSPLL desativado (multiplicador do oscilador), termos
ento:
tempo de estouro do TIMER0 = ciclo de mquina x prescaler x
(modo 8/16 bits - valor de contagem do TIMER0)
logo:
1 000 0000 = 0,5 * 16 * (65536 - X)
x = 59464
Concluimos que o valor de carregagem em TMR0L e TMR0H dever ser
de 59464, ou seja, TMR0L = 0X48; , TMR0H = 0XE8; (valores 59464
convertido em hexadecimal igual a E848)
Exemplo:

/*********************************************************
************
Centro de tecnologia Microgenios
Configurao parcial de um programa de configurao do
TIMER0
**********************************************************
*************/

Comandos:
T0CON = 0b10000011; //configura temporizador 16 bits,
com prescaler ativado em 1:16, clock interno
TMR0L = 0x48;
//carrega valores de contagem em
TMR0L - registrador baixo de contagem
TMR0H = 0xE8;
//carrega valores de contagem em
TMR0H - registrador alto de contagem

O programa abaixo tem por funo configurar o modo de

trabalho do TIMER0. Repare que o registrador T0CON foi configurado
da seguinte forma:

TIMER0 ligado. (TMR0ON = 1)

Clock interno (T0CS = 0)
Modo de contagem de 16 bits (T08BIT = 0)
Prescaler ligado (PSA = 0)
Prescaler 1:16 (T0PS2 = 0, T0PS1 = 1, T0PS0 = 1)

Os registradores de contagem TMR0L e TMR0H

inicializados com o valor 59464.

sero

Vamos realizar mais um exemplo de programa:

O programa seguinte tem por objetivo alterar os estados dos leds conectados ao
PORTB em intervalos de 1 segundo.
Hardware:
Cristal: 8 Mhz
Microcontrolador: PIC18f452
Temporizador: Timer0

/*********************************************************
************
Centro de tecnologia Microgenios
Placa: Kit PICGenios
Programa: Pisca Pisca utilizando o TIMER0 do PIC
Objetivo: Este programa tem por objetivo piscar os leds
do portb em
intervalo de 1 segundo (ligado e desligado) utilizando o
TIMER0 do PIC.
Modo programado: 16 bits, prescaler 1:128
**********************************************************
*************/
void main() {
T0CON = 0b10000110;
prescaler
TMR0L = 0XF7;
TMR0H = 0XC2;
intcon.tmr0if = 0;
TRISB = 0;
PORTB = 0xFF;

//funo principal do programa

//configura timer modo 16 bits, com
//carrega valores de contagem
//carrega valores de contagem
// PORT B configurado como sada
// Initialize PORT B

do {
if (intcon.tmr0if == 1) { //se o flag de estouro do
TIMER0 for igual a 1, ento
PORTB = ~PORTB; // inverte o estado do portb
TMR0L = 0xF7;
TMR0H = 0XC2;
Iintcon.tmr0if = 0; // apaga flag de entouro do
TIMER0
//para uma nova contagem
}

} while(1);

// loop

Calculo do tempo de estouro do timer0

tempo de estouro do TIMER0 = ciclo de mquina x prescaler x
(modo 8/16 bits - valor de contagem do TIMER0)
tempo de estouro = 0,5 * 128 * (65536 - 49911)
Tempo de estouro = 1.000,000 us ou 1 segundo
Estudo detalhado do programa:
void main() {
//funo principal do programa
T0CON = 0b10000011; //configura timer modo 16 bits, com
prescaler 128
TMR0L = 0XF7;
//carrega valores de contagem
TMR0H = 0xC2;
//carrega valores de contagem
intcon.tmr0if = 0; // apaga flag de entouro do TIMER0

Os comandos seguinte configuram o portb como sada.

TRISB = 0;
PORTB = 0xFF;

// PORT B configurado como saida

// Initialize PORT B

Repare que nosso TIMER0 j foi configurado e iniciou a

contagem dos pulsos de ciclo de mquina. Agora precisamos monitorar o
bit de estouro do TIMER0, pois no sabemos a que momento o estouro
vai ocorrer, o que sabemos que vai levar 1 segundos para ocorrer o
estouro, ou seja, o bit TMR0IF vai para 1. Para isso, utilizaremos o
comando de tomada de deciso IF, que ter a seguinte funo:
Se o bit de estouro intcon.tmr0if for igual a 1, representa que o
TIMER0 estourou, e os comandos do bloco IF so executados. Toda a
vez que o TIMER0 estura, ou seja, o timer chega at 1 segundos,
invertido o estado do portb e reiniciado a contagem do TIMER0.
if (intcon.tmr0if == 1) { //se o flag de estouro do
TIMER0 for igual a 1, ento
PORTB = ~PORTB; // inverte o estado do portb
TMR0L = 0XF7;
//carrega valores de
contagem
TMR0H = 0xC2;
//carrega valores de
contagem
intcon.tmr0if = 0; // apaga flag de entouro do
TIMER0

Modo Contador do TIMER0:

Vamos fazer mais um exemplo de programa utilizando o
TIMER0 do PIC:

Neste novo exemplo de programa, vamos programar o TIMER0

do PIC para trabalhar como contador de pulsos externos. Neste modo, os
pulsos externos, so aplicados no pino RA0/T0CK1 do PIC. Devemos
contar apenas 10 pulsos externos, que neste caso, configuraremos o
TIMER0 do PIC no modo 8 bits com prescaler 1:1, e os pulsos sero
lidos por borda de descida. Ao completar a contagem de 10 pulsos, o led
conectado ao pino RB7 do PIC dever acender para sinalizar o fim da
contagem.
Esquema eltrico:

Para realizar o seguinte desafio necessrio configurar os

seguintes registradores do TIMER0:

INTCON.TMR0IF (Bit de estouro do TIMER0)

TMR0L (registrador de contagem do TIMER0)
T0CON (registrador de configurao do modo de
operao do TIMER0)
Programa:
/*********************************************************
************

Centro de tecnologia Microgenios

Placa: Kit PICGenios
Programa: Pisca Pisca utilizando o contador T0CK1 do PIC
Objetivo: Este programa tem por objetivo piscar os leds
do portb a cada
10 pulsos gerados no pino contador RA4/T0CK1 do PIC.
**********************************************************
*************/
void main() {
T0CON = 0b11100000;
prescaler 1:1
TRISB.f7 = 0;
saida
PORTB.f7 = 0;
TMR0L = 246;
pulsos

//funo principal do programa

//configura timer modo 8 bits, com
// PORT B configurado como
// Initializa PORT B
//carrega valores de contagem de

//como somente vamos contar 10

pulsos, temos: (255 - 10 = 245)
intcon.tmr0if = 0;
do {
if (intcon.tmr0if == 1) { //se o flag de estou for
igual a 1, ento
PORTB.f7 = ~PORTB.f7;
// inverte o estado do pino
RB0
TMR0L = 246;
//recarrega valor de
contagem de contagem
intcon.tmr0if = 0;
// Seta T0IE, apaga flag de
entouro do TIMER0
//para uma nova contagem
}
} while(1);
// loop
}

Estudo detalhado do programa:

Repare que o nos comandos abaixo que o registrador T0CON
foi configurado como contador de pulsos externos, modo de operao do
TIMER0 de 8 bits, com prescaler 1:1.
O registrador de contagem TMR0L o registrador onde ser
armazenado os valores de contagem dos pulsos externos, e neste caso ele
foi pr configurado com o valor 246, devido a necessidade de contarmos
apenas 10 pulsos. Devemos lembrar que os registradores de contagem do
TIMER0 so incrementados em 1 unidade e contam para cima, neste
caso, como desejamos programar o TIMER0 para que a cada 10 pulsos
no pino RA0/T0CK1 seja gerado um estouro, devemos carregar em
TMR0L o valor da diferena entre o valor mximo de contagem para o
modo 8 bits, que 256, pelo valor da quantidade de pulsos a ser contado,
que neste cado 10. Ento teremos:
256 - 10 = 246

O TIMER1:
Realizamos nas unidades passadas um estudo no muito
aprofundado sobre as funes e caractersticas 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 TIMER1 pode operar como temporizador ou como contador
de 16 bits, suas caractersticas so muito parecida com a do TIMER0.
Dizemos que o timer est operando como temporizador quando
a referncia do clock de incremento da contagem realizada pelo clock
interno do PIC, e dizemos que o timer esta operando como contador
quando a referncia do clock de incremento da contagem proveniente
de um clock externo ao PIC. (pulso aplicado no pino
RB6/T1OSO/T1CK1).
Registradores de configurao do TIMER1:

Figra 01 - Registrador relacionados com o TIMER0

P1R1: um registrador onde armazenado os bits de status das

interrupes e estouro dos timers.
P1E1: um registrador de 8 bits onde habilitado as interrupes do
PIC.
TMR1L um registrador de contagem de 8 bits que possui a funo
de armazenar a parte baixa do valor de contagem programada do
TIMER0.
TMR1H 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.
T1CON um registrador de 8 bits responsvel pela configurao do
modo de operao do TIMER1. 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
RB6/T10S0/T1CK1.

T1CON: (TIMER1 CONTROL REGISTER):

RD16
Bit7

--Bit6

T1CKPS1

T1CKPS0

T10SCEN

Bit5

Bit4

Bit3

T1SYNC
Bit2

TMR1CS
Bit1

RD16: bit de leitura e escrita em 16bits

0 leitura e escrita em 16 bits habilitada
1 leitura e escrita em 16 bits desabilitada
T1CKPS1; T1CKPS0: Bits de seleo de fonte de prescaler

T1CKPS1 T0CKPS0 Prescaler

1

1:8

1:4

1:2

1:1

T1OSCEN: Habilitao do oscilador externo de baixa

frequencia nos pinos T1OSO e T1OSI
0 - Oscilador desligado
1 - Oscilador Ligado
T1SYNC: Controle do sincronismo interno. Caso TMR1CS =
0, esse bit descartado
0 - Sincronismo ligado
1 - Sincronismo desligado
TMR1CS: Bit de seleo de clock;
0 - A base de clock para o TIMER1 interna (Fosc/4);
1 - Clock externo no pino RC0/T1CK1;
TMR1ON: Habilita TIMER1;
0 - TIMER1 desligado
1 - TIMER1 ligado

Obs: Bit6 no implementado, lido como "0".

Abaixo o diagrama simplificado do Timer1:

TMR1ON
Bit0

Faa download do diagrama esquemtico do TIMER1 disponvel na

informaes complementar dessa unidade.

O TIMER1 opera de maneira identica a do timer anterior, suas

diferenas bsicas que este novo timer pode operar como temporizador
para o modo Capture/Compare para o modo CCP. Foi implementado
neste novo Timer a possibilidade de ligarmos um outro cristal oscilador,
de forma que nos permite ligar cristais de baixa frequncia, tais como
32,768 KHz, para maiores preciso na temporizao.
Obs: Este segundo cristal dever ser ligado entre os pinos RC0 e RC1 e
em iptese alguma poderemos dispensar o uso do cristal oscilador
principal Fosc.
A figura 01 apresenta o diagrama de funcionamento do
TIMER1 operando com o oscilador de baixa frequncia.

Figura 01
Abaixo segue um exemplo de ligao ( Revista Elektor / Ano 4 N 43)

Programando o TIMER1 do PIC.

Para exemplificar a utilizao do TIMER1 do PIC vamos
analizar um exemplo de programa:
/*********************************************************
************
Centro de tecnologia Microgenios
Configurao parcial de um programa de configurao do
TIMER1
**********************************************************
*************/
T1CON = 0B10110001; //liga TIMER1, prescaler 1:8, modo
temporizador 16 bits.
PIR1.TMR1IF = 0; //apaga flag de estouro do TIMER1
TMR1L = 0;
//carrega valor de contagem baixa do
TIMER1

TMR1H = 0;
TIMER1

//carrega valor de contagem alta do

O programa acima configura o TIMER1 para operar em 16bits com

prescaler 1:8, clock interno.
Anlise detalhado do programa:
Sabendo que nosso microcontrolador esta trabalhando com um cristal
externo de 4MHz, vamos calcular o tempo de estouro do TIMER1:

Configurao do TIMER1:

Modo de Operao: 16 bits

Fonte de oscilao: Ciclo interno.
Prescaler: 1:8

Tempo de estouro:,

Clculo: (65535 - valor do registrador de contagem) x (1 (Fosc

/ 4)) x Prescaler

65535 x 1us x 8 = 524, 28 ms, ou 0.5 segundos.

Exemplo de programa:

/*********************************************************
************
Centro de tecnologia Microgenios
Placa: Kit PICGenios
Programa: Pisca Pisca utilizando o TIMER1 do PIC
Objetivo: Este programa tem por objetivo piscar os leds
do portb em
intervalo de 0,5 segundo (ligado e desligado) utilizando o
TIMER1 do PIC.
Modo programado: 8 bits, prescaler 1:16
**********************************************************
*************/
void main()
//funo principal do programa
{
TRISB = 0;
//define portb como saida
T1CON = 0B10110001; //liga TIMER1, prescaler 1:8, modo
16bits.
PIR1.TMR1IF = 0; //apaga flag de estouro do TIMER1
TMR1L = 0;
TIMER1

//carrega valor de contagem baixa do

TMR1H = 0;
TIMER1
PORTB = 0x00;

//carrega valor de contagem alta do

//reseta portb

do {
if (PIR1.TMR1IF == 1)
//se flag estiver
representa que houve o estouro do timer1
{
PORTB = ~PORTB;
//inverte o valor
TMR1L = 0;
//recarrega valor
contagem baixa do timer1
TMR1H = 0;
//recarrega valor
contagem alta do timer1
PIR1.TMR1IF = 0;
//resseta flag de
timer1 para uma nova contagem.
}
} while (1);
}

em 1,
do portb
de
de
estouro do

voltar para o topo da pgina

O TIMER2 :

O TIMER2 um timer de 8 bits com recarga automtica.

Esse TIMER tem um registrador de configurao, um de contagem e
outro de comparao. Ele possui um registrador de contagem de 8 bits (

0 a 255) chamado TMR2. Diferentemente dos outros timers, o TIMER2

possui um prescale e um postscaler. Os registradores especiais
responsvel pela configurao do TIMER2 so:

T2CON (TIMER2 CONTROL REGISTER): Configura o

setup do TIMER2;

TMR2: Registrador de contagem do TIMER2 (8 bits);

PR2: Registrador de comparao do TIMER2

Dizemos que o TIMER2 um timer com recarga automtica
pois quando o valor carregado em PR2 igual ao de contagem TMR2,
o valor de TMR2 zerado e inicia-se uma nova contagem, ou melhor
dizendo, temporizao.

Os registradores relacionados com o TIMER2 so:

Atravs do registrador T2CON, podemos configurar o modo de

operao do TIMER2, tais como: valor do prescale e postcale e ligar ou
desligar o timer2.
Faa download do diagrama esquemtico do TIMER3 disponvel na
informaes complementar dessa unidade.

Registradores de configurao do TIMER2:

Registradores de configurao do TIMER2:
T2CON: (TIMER1 CONTROL REGISTER):

--Bit7

TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0

Bit6

Bit5

Bit4

Bit3

TMR2ON
Bit2

T2CKPS1
Bit1

TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0: Bits de ajuste do

postcale:

TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0 Postscale

1:1

1:2

1:3

1:4

1:5

1:6

1:7

1:8

1:9

T2CKPS0
Bit0

1:10

1:11

1:12

1:13

1:14

1
1

1
1

1
1

0
1

1:15
1:16

O funcionamento do postcale muito semelhante ao

prescaler, sua diferena bsica est na contagem. Em vez de contar
pulsos de ciclos de mquina, o postcale conta n comparaes do
TIMER2 com PR2. Aps n comparaes, o flag de estouro do TIMER2
sinalizado com nvel lgico 1.
TMR2ON: Habilitao do TIMER2;
0 - TIMER2 desligado
1 - TIMER 2 ligado
T2CKPS1 T2CKPS0: Bits responsveis pelo ajuste de
prescaler:

T2CKPS1 T2CKPS0 Prescaler

0

1:1

1:4

1:16
X pode ser 1 ou 0

Para exemplificar, vamos estudar um programa que tem como

funo piscar um led conectado ao pino RB0 do PIC em intervalos de 1
segundo (ligado e desligado). Neste exemplo iremos utilizar o TIMER2
com ajuste de prescale e postcale para entendermos o funcionamento.
Esquema eltrico:

Programa:
/*********************************************************
************
Centro de tecnologia Microgenios
Configurao parcial de um programa de configurao do
TIMER2
**********************************************************
*************/
T2CON = 0b01111111;
//programa TIMER2 com prescaler
1:16, postcale 1:16
TMR2 = 0;
//inicia contagem a partir do 0
PR2 = 0;
//inicia contagem a partir do 0

Descrio detalhada do programa:

Para calcularmos o tempo de estouro do TIMER2 utilizamos as seguintes
contas (observe que estamos utilizando um cristal externo de 4MHz):
Tempo de estouro do TIMER2 = valor do prescale x valor do postcale x PR2 x ( 1
/(Fosc/4) )

que nos resulta:

Tempo de estouro do TIMER2 = 16 x 16 x 255 x 1us = 65280us

Exemplo de Programa:
/*********************************************************
******************
Microgenios solues eletrnica Ltda
Programa: Pisca Pisca utilizando o TIMER2
Compilador: MikroC
Objetivo: Este programa tem por objetivo piscar o led
conectado ao pino RB0 do PIC em intervalos de 1 segundo
(ligado / desligado) APROXIMADAMENTE.
**********************************************************
*****************/
unsigned short i; //define varivel i
//************************* subrotina de inverso do led
*******************
void inverte_led() { //subrotina de inverso do estado do
led
PORTB.f0 = ~PORTB.f0;
}
//************************ funo principal do programa
******************
void main() {
i = 0;
TRISB = 0;
PORTB = 0;
T2CON = 0b01111111;
//programa TIMER2 com prescaler
1:16, postcale 1:16
PR2 = 200;
//inicia contagem a partir do 0
while (1)
{
if (pir1.tmr2if == 1) //se o TIMER2 estourar os
comandos sero executados
{
i++;
//foi criado a varivel i para que
somente depois de
//15 estouros do TIMER2, a
subrotina de inverso do
//estado do led seja chamada.
//a varivel i incrementada em
um unidade a cada
//estouro do TIMER2
if (i > 15)

//caso i seja maior que 15, ento

chama subrotina de
{
inverte_led();
//inverso dos leds
i = 0;
//zera novamente i para uma
nova contagem
}
PIR1.TMR2IF = 0; //apaga o bit de sinalizao de
estouro do TIMER2

//para inciar uma nova contagem

}
}
}

O TIMER3 :
O TIMER3 um temporizador e contador de 16 bits. Possui
internamente dois registradores de 8 bits, TMR3L e TMR3H, que juntos
formam um registrador de 16 bits (contagem de 0 a 65535).
Os registradores relacionados com o TIMER3 so:

Atravs do registrador T3CON, podemos configurar o modo de

operao do TIMER3, tais como: valor do prescale , ligar ou desligar o
TIMER3, seleo de clock interno ou externo (contador) e fonte do timer
para o mdulo CCP do PIC.

Faa download do diagrama esquemtico do TIMER3 disponvel na

informaes complementar dessa unidade.
Registradores de configurao do TIMER3:
O registrador de controle do TIMER3;
T3CON: (TIMER3 CONTROL REGISTER);
RD16
Bit7

T3CCP2
Bit6

T3CKPS1

T3CKPS0

Bit5

Bit4

T3CCP1
Bit3

T3SYNC
Bit2

TMR3CS
Bit1

TMR3ON
Bit0

RD16: bit de leitura e escrita em 16bits

0 leitura e escrita em 16 bits habilitada
1 leitura e escrita em 16 bits desabilitada
T3CCP2 T3CCP1: Habilita a fonte de timer para o mdulo
CCP;
T3CCP2 T3CCP1
0

Prescaler
TIMER1 fonte
de timer para
os mdulos
CCP
TIMER1 fonte
de timer para
o mdulo
CCP1
TIMER3 fonte
de timer para
o mdulo
CCP2
TIMER3 fonte
de timer para
os mdulos
CCP

T3CKPS1 T3CKPS0: bits de ajuste do prescaler do TIMER3;

T3CKPS1 T3CKPS0 Prescaler

0
0
1
1

0
1
0
1

1:1
1:2
1:4
1:8

/T3SYNC: Controle de sincronismo interno. Caso TMR3CS =

0, este bit descartado;

obs: este bit somente utilizado para trabalhar com outro cristal
ligado ao T1OSO e T1OSI.
0 - Sincronismo ligado
1 - Sincronismo desligado
TMR3CS: Seleo de Clock
0 - Clock Interno ( Fosc/ 4 )
1 - clock externo no pino T1CK1
TMR3ON: Habilitao do TIMER3;
0 - TIMER3 desligado

1 - TIMER3 ligado

Para exemplificar a utilizao do TIMER3, vamos programar

seus registradores:

Primeiramente devemos programar os TIMER3:

Para este exemplo, vamos programar o TIMER3 no modo 16
bits (contagem de 0 a 65535), prescaler de 1:8, clock interno, cristal de
4Mhz e modo HSPLL desativado (multiplicador do oscilador), termos
ento:
Tempo de estouro do TIMER0 = valor de contagem do TIMER0 x
PRESCALER X tempo de ciclo de mquina
65535 x 8 x 1us = 524280 us, ou 0.524 segundos.
Logo o tempo de estouro do TIMER3 ser a cada 0.524 segundos.

/*********************************************************
************
Centro de tecnologia Microgenios
Configurao parcial de um programa de configurao do
TIMER3
**********************************************************
*************/

T3CON =
1:8, modo
TMR3l =
TMR3H =

0b10110001;
//programa TIMER3 com prescaler
16 bits, clock interno
0;
//inicia contagem a partir do 0
0;
//inicia contagem no modo 16 bits

Descrio detalhada do programa :

O programa abaixo tem por funo configurar o modo de

trabalho do TIMER3. Repare que o registrador T3CON foi configurado
da seguinte forma:

TIMER3 ligado. (TMR3ON = 1)

Clock interno (TMR3CS = 0)
Modo temporizador em 16 bits (RD16 = 1)
Prescaler 1:8 (T3CKPS1 = 0, T3CKPS0 = 1)

Os registradores de contagem dos pulsos dos clocks internos do

PIC so inicializados a partir do zero.
voltar para o topo da pgina

Centro de Tecnologia Microgenios - Curso de Microcontroladores PIC - Programao

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