04 Delays, Counters, and Timers

Delays, Counters, and Timers
9.1 PIC18 Family Timers

Microcontroller timers in general belong to one of two groups:
1. Delay timers used during system power-up, reset, and watchdog operations
2. Timer-counters used in implementing and measuring time periods and wave-
forms
9.2 Delay Timers

PIC18 microcontrollers have hardware resources that provide a delay period during
reset operations. Reset operations were discussed in Section 2.4 and following. The
timers associated with the reset action are
1. Power-Up Timer (PWRT)
2. Oscillator Start-Up Timer
3. Phase Lock Loop (PLL) timer
4. Watchdog timer
9.2.1 Power-Up Timer (PWRT)

The Power-up Timer provides a fixed time-out period from Power-On Re set (POR).
The timer operates on an internal RC oscillator that keeps the chip in the RESET state.
This delay allows the Vdd signal to rise to an acceptable level. The nominal delay pe-
riod is documented to take 72 ms but it is said to vary from chip to chip, due to differ-
ences in the Vdd and changes in temperature. A configuration bit is provided to
enable/disable the PWRT, as fol lows:
PWRT = ON Power-up timer en abled

PWRT = OFF Power-up timer dis abled
179
180 Chapter 9
The default state is disabled but there is no rea son why the PWRT timer should
not be en abled for most applica tions.
9.2.2 Oscillator Start-Up Timer (OST)

The Oscillator Start-Up Timer (OST) ensures that 1,024 oscillator cycles take place af-
ter the PWRT delay is over and before the RESET stage ends. This delay ensures that
the crys tal oscillator or resonator has started and is stable on power-up. The oscillator
time-out is invoked for the fol lowing oscillator options: XT, LP, and HS. The de lay
takes place on Power-on Reset, Brown-out Reset, or wake-up from SLEEP. It also
takes place on the transition from Timer1 input clock as the sys tem clock to the os cil-
lator. The OST is disabled for all resets and wake-ups in RC and EC oscillator options.
The OST func tion counts oscillator pulses on the OSC1/CLKIN pin. The counter
starts incrementing after the amplitude of the signal reaches the oscillator input
thresholds. This initial delay allows the crystal oscillator or resonator to stabilize
before the de vice ex its the OST delay. The length of the time-out is a func tion of the
crystal/resonator frequency. For low-frequency crystals, this start-up time can be-
come quite long. That is because the time it takes the low-frequency oscillator to
start oscillating is longer than the power-up timer's delay.
The time from when the power-up timer times out to when the oscillator starts to
oscillate is referred to as dead time. There is no minimum or maximum time for this
dead time because it is dependent on the time required for the oscillator circuitry to
have “good” oscillations.
9.2.3 Phase Locked Loop (PLL)

The Phase Locked Loop (PLL) circuit is a programmable option that allows multiply-
ing by 4 the frequency of the crystal oscillator signal. Selecting the PLL option results
in an input clock fre quency of 10 MHz of the internal clock being multiplied to 40 MHz.
The PLL can only be en abled when the os cillator con fig u ra tion bits are pro-
grammed for HS mode. In all other modes, the PLL op tion is disabled and the sys tem
clock will come directly from the OSC1 pin. The con figuration bit for HS and PLL
are selected with the following statement:
#pragma config OSC = HSPLL
When the Phase Locked Loop Os cillator Mode is selected, the time-out sequence
following a Power-on Reset is different from the other oscillator modes. In this case,
a portion of the Power-up Timer is used to provide a fixed time-out that is sufficient
for the PLL to lock to the main oscillator frequency. This PLL lock time-out (TPLL)
is typically 2 ms and follows the oscillator start-up time-out (OST).
Delays, Counters, and Timers 181
Power-Up Delay Summary

Two timers are used in controlling the power-up delays: the Power-up Delay Timer
(PWRT) and the Oscillator Start-up Timer (OST). This duplica tion ensures that no ex -
ternal reset circuitry is required for most applications. Their joint action guarantees
that the de vice is kept in RESET until both, the device power supply and the clock, are
stable.
When the PLL is enabled (HSPLL oscillator mode), the Power-up Timer (PWRT) is
used to keep the de vice in RESET for an extra nominal delay. This additional delay
ensures that the PLL is locked to the crystal frequency.
9.2.4 Watchdog Timer

The Watchdog Timer was discussed in Section 2.1.5. In summary, the Watchdog Timer
is an independent timer with its own clock source. Its purpose is to provide a mech a-
nism by which the processor can recover from a software error that impedes program
continuation, such as an endless loop. The Watch Dog Timer is not designed to recover
from hardware faults, such as a brown-out.
The hardware of the Watch dog Timer is independent of the PIC's internal clock.
Its time-out period can range from approximately 18 milliseconds to 2.3 seconds,
depending on whether the prescaler is used. According to Microchip, the Watch dog
Timer is not very accurate and in the worst case scenario, the time-out period can
extend to sev eral seconds. When the WDT times out, the TO flag in the STATUS reg-
ister is cleared and the program counter is reset to 0x000 so that the program re-
starts. Applica tions can prevent the re set by issuing the clrwdt instruction before
the time-out period ends. When clrwdt executes, the WDT time-out period restarts.
The clrwdt and sleep instructions clear the WDT and the postscaler (if assigned
to the WDT) and prevent it from timing out and generating a device RESET condi-
tion. The WDT has a postscaler field that can extend the WDT Reset period. The
postscaler is selected by the value written to three bits in the CONFIG2H register
dur ing de vice pro gram ming. When a clrwdr in struc tion is ex e cuted and the
postscaler is assigned to the WDT, the postscaler count will be cleared, but the
postscaler assignment is not changed.
Watchdog Timer Uses

Not much information is available regarding the practical uses of the watchdog timer
in any of the PIC microcontrollers, but it is clear that there is more to it than just re-
starting the coun ter with the clrwdt instruction. The timer is supposedly designed to
detect software errors that can hang up a program, but how detects these errors and
which conditions trigger the WDT operation is not clear from the information cur-
rently available. For example, an application that contains a long delay loop may find
that the Watchdog Timer forces an untimely break out of the loop. The Watch dog
Timer provides a powerful error-recovery mechanism but its use requires careful con-
sideration of program conditions that could make the timer malfunction.
182 Chapter 9
9.3 Hardware Timer-Counters

The PIC 18 family of microcontrollers has facilities and devices for controlling and
manipulating time lapses in a program. These are most frequently required in timing,
measuring, and counting operations. It is difficult to imagine an embedded applica-
tion of any complexity that does not re quire some form of counting or timing. In some
of the programs previously developed, we have provided a timed delay using a
do-nothing loop that wastes a series of machine cy cles. In the sec tions that follow, we
investigate and expand the the ory and use of de lay loops and explore the use of
built-in timing and count ing circuits on the PIC 18F devices. The following are possi-
ble applica tions of the timing hardware:
1. Measuring and comparing the arrival time of an event
2. Generating a periodic interrupt
3. Measuring period and pulse width
4. Measuring the frequency and duty cycle of periodic signals
5. Generating specific waveforms
6. Establishing a time reference for an event
7. Counting events
The most frequently used modules in timing operations are the four (or five)
hardware timers of the PIC 18F family, labeled Timer0 to Timer 3. and the Capture
Compare and PWM module (CCP). Timer0, Timer1, and Timer3 are 8- or 16-bit tim-
ers while Timer2 is an 8-bit timer. 16-bit timers have internal registers that operate
in the range 0 to 0xffff (0 to 65,535). 8-bit timers operate in the range 0 to 0xff (0 to
255). Timer2 and Timer4 use the system's internal clock as their clock source, while
the other timers can also use an external clock signal.
In the remaider of the chapter we discuss the four timer modules available in the
18F452.
9.4 Timer0 Module

The basic timer facility on the PIC 18F family is known as the Timer0 module. It is de-
scribed as a free-running timer, as a timer/counter, or simply as TMR0. Timer0 can be
configured as an 8- or 16-bit device. It can be made to run off the internal timer or off an
external one on the TOCKI pin. Its principal fea tures are as follows:
1 Software selectable as an 8-bit or 16-bit timer/counter
2 Readable and writable
3. 8-bit software programmable prescaler
4. Clock source can be external or internal
5. Interrupt-on-overflow from 0xff to 0x00 in 8-bit or on 0xffff in 16-bit mode
6. Edge select for external clock
Control or Timer0 is mainly through the T0CON reg ister shown in Figure 9.1.
bit 7 bit 0
TMR0ON T08BIT T0CS T0SE PSA T0PS2 T0PS1 T0PS0
bit 7 TMR0ON: Timer0 On/Off Control bit

1 = Enables Timer0
0 = Stops Timer0
bit 6 T08BIT: Timer0 8-bit/16-bit Control bit
1 = Timer0 is configured as an 8-bit timer/counter
0 = Timer0 is configured as a 16-bit timer/counter
bit 5 T0CS: Timer0 Clock Source Select bit
1 = Transition on T0CKI pin
0 = Internal instruction cycle clock (CLKO)
bit 4 T0SE: Timer0 Source Edge Select bit
1 = Increment on high-to-low transition on T0CKI pin
0 = Increment on low-to-high transition on T0CKI pin
bit 3 PSA : Timer0 Prescaler Assignment bit
1 = TImer0 prescaler is NOT assigned. Timer0 clock
input bypasses prescaler.
0 = Timer0 prescaler is assigned. Timer0 clock input
comes from prescaler output.
bit 2-0 T0PS2:T0PS0: Timer0 Prescaler Select bits
111 = 1:256 prescale value
Figure 9.1 Timer0 control register (T0CON) bitmap.
All bits in the T0CON reg ister are readable and writeable.
The Timer0 module is the first peripheral device discussed in this book. Periph-
eral devices add specific functionality to the microcontroller. Learning to program
the Timer0 module serves as an introduction to programming PIC 18F peripherals,
of which there is a long list. Figure 9.2 is a block diagram of the Timer0 module in 8-
bit mode.
data bus x 8
0 0
OSC/4
Pout PSout 7 6 5 4 3 2 1 0
Sync with
internal
TOCKI pin
clocks TMR0
7 6 5 4 3 2 1 0
1 1
T0PS0-T0PS2
(Prescaler)
TOSE T0IF
Interrupt flag bit
TOCS set on overflow
(Clock source select) PSA
Figure 9.2 Timer0 module bitmap.

184 Chapter 9
9.4.1 Timer0 Architecture

Several setup operations are required in programming the Timer0 module in its vari-
ous modes. The various steps required for setting up the Timer0 module are as follows:
1. Enable the timer.
2. Select the 8- or 16-bit mode.
3. Select the internal or external clock source.
4. If the timer is used as a counter, then code must select whether the increment
takes place on the falling or the rising edge of the signal.
5. Turn the prescaler function on or off.
6. If the prescaler is on, then select the prescaler value.
16-bit Mode Operation

Normally, applications will not change the timer mode once it has been selected. Nev-
ertheless, code can change between 8- and 16-bit modes by carefully considering
when interrupts are generated during counter rollover. Rules are as follows:
1. When Timer0 is changed from 8- to 16-bit mode on the same counting cycle as the
rollover condition occurs, then no interrupt is generated.
2. When Timer0 is changed from 16- to 8-bit mode on the same counting cycle as the
rollover condition occurs, then an interrupt is generated.
The high byte of the Timer0 counter (TMR0H) is not directly readable or writable
by code. In fact, TMR0H is not the high byte of the timer/counter, but a buf fered ver -
sion of this byte. TMR0H is updated with the con tents of the high byte of Timer0
during a read of the timer low byte (TMR0L). This design allows code to read all 16
bits of Timer0 without worrying that a rollover con dition did not occur between the
read of the high and low bytes. Code simply reads the low byte of Timer0, followed
by a read of TMR0H, which contains the value in the high byte at the time that the
low byte was read.
Writing to the high byte of Timer0 must take place through the TMR0H buffer reg-
ister. In this case, Timer0 high byte is updated with the con tents of TMR0H when a
write occurs to TMR0L. This design allows code to update all 16 bits of Timer0 (high
and low bytes) at the same time. When performing a write of TMR0, the carry is held
off during the write of the TMR0L register. Writes to the TMR0H register only mod-
ify the holding latch, not the timer. The operation requires the following steps:
1. Load the TMR0H register.
2. Write to the TMR0L register.
Some instructions (bsf and bcf) are used to read the con tents of a reg ister, make
changes to that content, and write the result back to the register. This sequence is
known as a read-modify-write. With regard to the TMR0L register, the read cycle of
the read-modify-write operation does not update the TMR0H reg ister; there fore the
TMR0H buffer remains unchanged. When the write cycle takes place, then the con-
tents of TMR0H are placed in the high bytes of the Timer0 register.
The sample program Timer0_Delay.asm developed later in this chapter shows the
setup and operation of Timer0 in 16-bit mode as well as reading and writing to the
TMR0H and TMR0L registers. Many re ports of bugs in the Timer0 16-bit mode found
on the Internet are due to pro grams that have not followed the correct read/write
sequence when accessing the Timer0 high byte.
Timer and Counter Modes
Timer0 can operate in a timer or a counter mode. The timer mode is selected by clear-
ing the T0CS bit in the T0CON register. Without a prescaler, in timer mode the Timer0
module increments on every instruction cycle. If the TMR0 register is written, the in-
crement is inhibited for the following two instruction cycles. Code can work around
this by writing an adjusted value to the TMR0 register.
Counter mode is selected by setting the T0CS bit (T0CON register). In counter
mode, Timer0 increments either on every rising or falling edge of the T0CKI pin. The
edge is determined by the Timer0 Source Edge Select bit T0SE in the T0CON regis-
ter. Clearing the T0SE bit selects the rising edge of the signal.
Timer0 Interrupt
When the interrupt flag bit is set, Timer0 generates an interrupt when the TMR0 regis-
ter over flow. In the 8-bit mode, this takes place when the count goes from 0xff to 0x00.
In the 16-bit mode, the in terrupt is generated when the counter goes from 0xffff to
0x0000.
This interrupt overflow sets the TMR0IF bit in the INTCON register. The interrupt
can be disabled by clearing the TMR0IE bit in the INTCON register. The TMR0IF flag
bit must be cleared in software in the interrupt service routine. The TMR0 interrupt
can not awaken the processor from SLEEP, as the timer is shut off during SLEEP.
External Clock Source
When an external clock signal is selected, the Timer0 hardware must ensure that the
clock signal can be synchronized with the internal clock.
When no prescaler is used, the ex ter nal clock in put is used in stead of the
prescaler output. When a prescaler is used, the ex ternal clock input is divided by
the prescaler so that the prescaler output is symmetrical. For the external clock to
meet the sam pling require ment, the rip ple-counter must be taken into ac count.
Therefore, it is necessary for T0CKI to have a period of at least 4TSCLK (and a small
RC delay) divided by the prescaler value. The only requirement on T0CKI high and
low time is that they do not violate the minimum pulse width requirement. Because
the prescaler out put is synchronized with the internal clock, there is a small delay
from the time the external clock edge occurs to the time the Timer0 module is actu-
ally incremented. The actual magnitude of this delay can be obtained from the de-
vices' data sheets.
186 Chapter 9
Timer0 Prescaler
Timer0 contains a prescaler that allows controlling the timer's rate by acting as a cycle
divider. The PSA bit in the T0CON register (Prescaler Assign ment Bit) allows turn ing
the prescaler on and off.
Past errors in some PIC18 data sheets have created confusion regarding the ac-
tion of the PSA bit. For example, the 18F Family Reference Manual (DS39513A)
states on page 13-7 that “Setting the PSA bit will enable the prescaler.” In that same
document, the T0CON register bitmap shows that it is a value of 0 in the PSA bit that
assigns the prescaler to Timer0. Actually, this is the case. Regarding Timer0, the PSA
bit is active low, so a value of 0 turns on the prescaler while a value of 1 turns off the
prescaler assignment.
The rate of the prescaler is determined by bits 0:2 in the T0CON register as shown
in Figure 9.1. The 3-bit field allows selecting eight different prescaler rates: a value
of 0x7 enables a 1:256 prescaler value while a value of 0x0 selects a prescaler rate of
1:2. The prescaler select bits are readable and writable but the prescaler count can-
not be read or written. All instructions that write to the Timer0 register, such as clrf
TMR0, bsf TMR0,x, movwf TMR0, and others) will clear the prescaler count if the
prescaler has been enabled. However, writes to TMR0H do not clear the prescaler
count be cause writing to the latch does not change the con tents of Timer0. The
prescaler is cleared by writing to TMR0L.
9.4.2 Timer0 as a Delay Timer

One of the simplest and most useful applica tions of the Timer0 module is as a simple
delay timer. Two common techniques are available:
1. Polling the value in the timer counter register to detect when the counter rolls
over
2. Enabling an interrupt that takes place when the counter rolls over
We begin by investigating the first case, that is, Timer0 registers are polled to im-
plement a de lay loop. Applica tions in which the Timer0 register is polled directly
are said to use a free running timer. There are two advantage in free running timers
over conventional delay loops:
1. The prescaler provides a way of slowing down the count.
2. The delay is independent of the number of machine cycles in the loop body.
These factors determine that, in most cases, it is easier to implement an accurate time
delay using the Timer0 module than by count ing instruction cycles.
Calculating the time taken by each counter itera tion consists of dividing the
clock speed by 4. For example, a 18F452 PIC running on a 4 MHz oscillator clock, in-
crements the counter every 1 MHz. If the prescaler is not used, the counter register
is incremented at a rate of 1 µs. or 1,000,000 times per second. If the prescaler is set
to the maximum divisor value (256), then each increment of the timer takes place at
a rate of 1,000,000/256 µs, which is approximately 3.906 ms. This is the slowest pos-
sible rate of the timer in a machine running at 4 MHz. It is often necessary to employ
supplementary counters in order to achieve larger delays.
Recall that the timer register (TMR0) is both read able and writable. This makes
possible several timing techniques; for example, code can set the timer register to
an initial value and then count up un til a predetermined limit is reached. Suppose
that we define that the difference between the limit and the initial value is 100; then
the routine will count 100 times the timer rate per beat.
As another ex ample, consider a routine in 8-bit mode that allows the timer to
start from zero and count up un restricted. In this case, when the count reaches the
maximum value (0xff), the routine would have introduced a delay of 256 times the
timer beat rate. Now consider the case in which the maximum value (256) was used
in the prescaler and the timer ran at a rate of 1,000,000 beats per second. This means
that each timer beat will take place at a rate of 1,000,000/256, or approximately
3,906 timer beats per second. If now we develop a routine that delays execution un-
til the maximum value has been reached in the counter register, then the delay can
be calculated by dividing the number of beats per second (3,906) by the number of
counts in the delay loop. In this case, 3,906/256 results in a delay of approximately
15.26 iterations of the delay routine per second.
A general formula for calculating the number of timer beats per second is as fol-
lows:
C
T=
4 PR
where T is the number of clock beats per sec ond, C is the system clock speed in Hz, P is
the value stored in the prescaler, and R is the number of iteration, counted in the tmr0
register. The range of both P and R in this formula is from 1 to 256. Also notice that the
reciprocal of T (1/T) gives the time delay, in seconds, per iteration of the delay routine.
Long Delay Loops
In the previous section we saw that even when using the largest possible prescaler and
counting the maximum number of timer beats, the lon gest timer delay that can be ob-
tained in a 4-MHz system is approximately 1/15th second. Consequently, applications
that mea sure time in seconds or in minutes must find ways of keep ing count of large
number of rep etitions of the timer beat.
In implementing counters for larger de lays we must be care ful not to introduce
round-off errors. In the previous example, a timer cycles at the rate of 15.26 times
per second. The closest integer to 15.25 is 15, so if we now set up a seconds counter
that counts 15 iterations, the counter would introduce an er ror of approximately 2%.
Considering that each iteration of the timer contains 256 individual beats, there are
3,906.25 individual timer beats per second at the maximum pre-scaled rate.
188 Chapter 9
This means that if we were to implement a coun ter to keep track of individual
pre-scaled beats, instead of timer iterations, the count would proceed from 0 to
3,906 instead of from 0 to 15. Approximating 3,906.25 by the closest integer (3,906)
introduces a much smaller round-off error than ap proximating 15.26 with 15. In this
same example, we could eliminate the prescaler so that the timer beats at the clock
rate, that is, at 1,000,000 beats per second. In this option a counter that counts from
0 to 1,000,000 would have no intrinsic error due to round-off. Which solution is more
adequate depends on the accuracy required by the application and the acceptable
complexity of the code.
Delay Accuracy Issues

The ac tual implementation of a delay routine based on multi-byte counters presents
some difficulties. If the timer register (TMR0)is used to keep track of timer beats, then
detect ing the end of the count presents a subtle problem. Our program could detect
timer overflow reading the tmr0 and testing the zero flag in the status register. Be-
cause the movf in struction affects the zero flag, one could be tempted to code:
wait:
movf tmr0,w ; Timer value into w
btfss sta tus,z ; Was it zero?
goto wait
; If this point is reached tmr0 has over flowed
But there is a problem: the timer ticks as each instruction executes. Because the goto
instruction takes two machine cycles, it is possible that the timer overflows while the
goto instruction is in progress; therefore the overflow condition would not be de-
tected. One possible solution found in the Microchip documentation is to check for
less than a nominal value by testing the carry flag, as follows:
wait1:
movlw 0x03 ; 3 to w
subwf TMR0,w ; Sub tract w - tmr0
btfsc sta tus,c ; Test carry
goto wait1
One adjustment that is sometimes necessary in free running timers results from
the fact that when the TMR0 register is written, the count is inhibited for the follow-
ing two instruction cycles. Software can usu ally compensate for the skip by writing
an adjusted value to the timer register. If the prescaler is assigned to timer0, then a
write operation to the timer register determines that the timer will not increment
for four clock cycles.
Black–Ammerman Method
A more elegant and accurate solution has been described by Roman Black in a Web ar-
ticle titled Zero-error One Second Timer. Black credits Bob Ammerman with the sug-
gestion of using Bresenham's algorithm for creating accurate PIC timer periods. In the
Black–Ammerman method, the coun ter works in the background, either by polling or
interrupt-driven. In either case, the timer count value is stored in a 3-byte register
which is decremented by the software.
In their inter rupt-driven ver sion, TMR0 gener ates an in ter rupt when ever the
counter register overflows, that is, every 256th timer beat (assuming no prescaler).
The inter rupt han dler routine dec re ments the mid-order reg ister that holds the
3-byte timer count. This is appropriate because every unit in the mid-order register
represents 256 units of the low-order counter, which in this case is the tmr0 register.
If the mid-order reg ister underflows when dec remented, then the high-order one is
dec remented. If the high-order one underflows, then the count has reached zero and
the de lay ends. Because the counter is interrupt-driven, the processor can continue
to do other work in the fore ground.
An even more inge nious option proposed by Black is a background counter that
does not rely on interrupts. This is accomplished by introducing a 1:2 de lay in the
timer by means of the prescaler. Because now the timer beats at one-half the in-
struction rate, 128 timer cycles will be required for one complete iteration at the full
instruction rate. By test ing the high-order bit of the timer coun ter, the routine can
detect when the count has reached 128. At that time, the mid-range and high-range
counter variables are updated (as in the non-interrupt ver sion of the software de -
scribed in the previous paragraph). The high-order bit of the timer is then cleared,
but the low-order bits are not changed. This allows the timer counter not to lose
step in the count, which re mains valid until the next time the high-order bit is again
set. During the pe riod between the up dating of the 3-byte coun ter and the next poll-
ing of the timer register, the program can con tinue to perform other tasks.
Delays with 16-Bit Timer0
In many cases the complica tions mentioned in the previous sections can be avoided
by running Timer0 in the 16-bit mode. For example, if the maximum delay that can be
obtained in 8-bit mode, given a machine running at 4MHz, is 1/15th second (0.0666 sec-
ond), then switching to 16-bit mode makes the maximum delay of ap proximately 17
seconds.
9.4.3 Counter and Timer Programming

Software routines that use the Timer0 module range in complexity from simple, ap-
proximate de lay loops to configurable, interrupt-driven counters that must meet very
high timing accuracy requirements. When the time period to be measured does not ex-
ceed the one that can be obtained with the prescaler and the timer register count, then
the cod ing is straightforward and the pro cessing is uncomplicated. How ever, if this is
not the case, the following elements should be examined before at tempting to design
and code a Timer0-based routine:
1. What is the required accuracy of the timer delay?
2. Does the program suspend execution while the delay is in progress, or does the
application continue executing in the foreground?
3. Can the timer be interrupt-driven or must it be polled?
4. Will the delay be the same on all calls to the timer routine, or must the routine pro-
vide delays of different magnitudes?
5. How long must the delay last?
190 Chapter 9
In this section we explore several timer and counter routines of different com -
plexity and requirements. The first one uses the Timer0 module as a counter. Later
we develop a simple delay loop that uses the timer0 register instead of the do-noth-
ing instruc tion count cov ered pre vi ously. We con clude with an inter rupt-driven
timer routine that can be changed to implement different delays.
Programming a Counter
The 18F452 PIC can be pro grammed so that port RA4/TOCKI is used to count events or
pulses by initializing the Timer0 module as a counter. When interrupts are not used,
the process requires the following preparatory steps:
1. Port A, line 4, (RA4/TOCKI) is defined for input.
2. The Timer0 register (TMR0) is cleared.
3. The Watchdog Timer internal register is cleared by means of the clrwdt instruc-
tion.
4. The T0CON register bits PSA and PSO:PS2 are initialized if the prescaler is to be
used.
5. The T0CON register bit TOSE is set so as to increment the count on the
high-to-low transition of the port pin if the port source is active low. Otherwise
the bit is cleared.
6. The T0CON register bit TOCS is set to select action on the RA4/TOCKI pin.
Once the timer is set up as a counter, any pulse received on the RA4/TOCKI pin
that meets the restrictions mentioned earlier is counted in the TMR0L and TMR0H
registers. If Timer0 is set in the 8-bit mode, then the TMR0H register is not used.
Software can read and write to the Timer0 registers in order to obtain or change the
event count. If the timer interrupt is enabled when the timer is defined as a coun ter,
then an interrupt takes place every time the counter overflows, that is, when the
count cycles from 0xff to 0x00 or from 0xffff to 0x0000 according to the active
mode.
Timer0_as_Counter.asm Program
The program named Timer0_as_Counter.asm, listed later in this chapter and con-
tained in this book's online software pack age, uses the circuits mentioned in the previ-
ous paragraph to dem onstrate the pro gramming of the Timer0 module in the counter
mode. The program detects and counts action on DIP switch #3, wired to port
RA4/TOCKI. The value of the count in hex digits in the range 0x00 to 0x0f is displayed
in the seven-segment LED connected to Port B.
The loca tion and use of the code table were discussed in Sections 7.3 and 7.4. The
main() function starts by selecting bank 0, initializing Port A for digital operations,
and trissing Port A for input and Port C for output as in several preced ing programs.
Code first clears the watchdog time and the TMR0L register, and then proceeds as
follows:
;=================================
; Check value in TMR0L and dis play
;=================================
; Ev ery clos ing of DIP switch # 3 (con nected to line
; RA4/TOCKI) adds one to the value in the TMR0L reg is ter.

; Loop checks this value, ad justs to the range 0 to 15
; and dis plays the re sult in the seven-seg ment LED on
; port B
checkTmr0:
movf TMR0L,w ; Timer reg is ter to w
; Elim i nate four high or der bits
andlw b'00001111' ; Mask off high bits
; At this point the w reg is ter con tains a 4-bit value
; in the range 0 to 0xf. Use this value (in w) to
; ob tain seven-seg ment dis play code
call codeTable
movwf PORTC ; Dis play switch bits
goto checkTmr0
Notice that the program provides no way of detecting when the count exceeds
the displayable range. This means that no display update takes place as the timer cy-
cles from binary 00001111 to binary 11111111.
A Timer/Counter Test Circuit

Either the circuit in Figure 7.2 or the or Demo Board 18F452-A (in Figure 7.3) can be
used to demonstrate the Timer0_as_Counter program. Both circuits have a seven-seg-
ment LED wired to lines RC0:RC6 and a DIP switch wired to Port A, line 4, which is the
RA4/T0CKI line. By selecting the counter mode of Timer0, any action on the T0CKI line
will be reflected in the TMR0x registers.
Timer0 _Delay.asm Program

One of the simplest uses of the Timer0 module is to implement a de lay loop. In this
case the Timer0 module is initialized to use the internal clock by clearing the TOCS bit
of the T0CON register. If the prescaler is to be used, the PSA bit is cleared and the de-
sired pre-scaling is selected by means of bits 2:0 of the T0CON register. Either the cir-
cuit in Figure 7.2 or the or Demo Board 18F452-A (in Figure 7.3) can be used to
demonstrate a simple application that uses Timer0 as a delay timer. Both circuits have
eight LEDs wired to lines RC0:RC7.
The program named Timer0_Delay.asm, listed later in this chapter and contained
in this book's online software pack age, uses a timer-based delay loop to flash in se-
quence eight LEDs that display the binary values from 0x00 to 0xff. The delay rou-
tine executes in the fore ground, so that pro cessing is suspended while the count is
in progress. The program executes in the 16-bit mode so the code can demonstrate
the issues related to reading and writing to the 16-bit registers TMR0L and TMR0H.
These issues were discussed in Section 9.6.1.
Setting up Timer0 as a delay counter requires selecting the required bits in the
T0CON register. The following code frag ment shows the program's initialization
routine to set up the timer.
;==============================
; setup Timer0 as de lay timer
;==============================
clrf TMR0H ; Clear high latch
clrf TMR0L ; Write both bytes
clrwdt ; Clear watch dog timer
192 Chapter 9
; Setup the T0CON reg is ter

; |------------- On/Off con trol
; | 1 = Timer0 en abled
; ||------------ 8/16 bit mode se lect
; || 0 = 16-bit mode
; |||----------- Clock source
; ||| 0 = In ter nal clock
; ||||---------- Source edge se lect
; |||| 1 = high-to-low
; |||||--------- Prescaler as sign ment
; ||||| 1 = prescaler not as signed
; |||||||| ----- No prescaler
; ||||||||
movlw b'10011000'
movwf T0CON
The previous code snippet starts by clearing both counter registers. This requires
first clearing the buffer register TMR0H and then the low-byte register TMROL. This
last write operation updates both the high and the low byte of the timer simulta-
neously. The bits selected in the T0CON register enable the timer, select the 16-bit
mode, enable the clock source as the internal clock, activate the signal edge in
high-to-low mode, while the prescaler is left unassigned.
The program then pro ceeds to an endless loop that increments the value in the
Port C register by one. Because Port C is wired to eight LEDs on the demo circuit,
the display shows the binary value in the port. The rou tine calls a proce dure that im-
plements a de lay in a do-nothing loop that uses Timer0 overflow. Code is as follows:
;=================================
; end less loop call ing
; de lay routiney
;=================================
; Dis play Port C count on LEDs
showLEDs:
incf PORTC,f ; Add one to reg is ter
call tmr0_de lay ; De lay rou tine
goto showLEDs
;=================================
; Timer0 de lay rou tine
;=================================
tmr0_de lay:
cy cle:
movf TMR0L,w ; Read low byte to latch
; high byte
movf TMR0H,w ; Now read high byte
sublw 0xff ; Sub tract max i mum count
btfss STATUS,Z ; Test zero flag
goto cy cle
; Re set coun ter
clrf TMR0H ; Clear high byte buffer
clrf TMR0L ; Write both low and high
re turn
end
The delay routine is the procedure named tmr0_delay. To make the code more
readable, we have added a second label named cycle at this same address. The code
reads the high byte of the timer, then the low one (this updates both bytes.) The
value 0xff is then sub tracted from the high byte. The subtrac tion returns zero and
sets the zero flag if the value in TMR0H is also 0xff. If the test is true, then the goto
cy cle instruction is skipped, both timer reg isters are cleared, and execution returns
to the caller. If the test is false, then the timer register test loop repeats. In a 4-MHz
test circuit the entire cycle takes approximately 15 seconds.
A Variable Time-Lapse Routine
A variable time-lapse routine can be de signed so that it can be ad justed to produce de -
lays within a certain time range. Such a pro ce dure would be a useful tool in a program-
mer's library. In previous sections we have de veloped de lay routines that do so by
counting timer pulses. This same idea can be used to de velop a routine that can be ad-
justed so as to produce accurate delays within a certain range.
The routine itself can be implemented to varying degrees of sophistication re-

garding the control parameters. One implementation could receive the desired time
lapse as parameters passed by the caller. Another option would be a proce dure that
reads the de sired time lapse from pro gram con stants. In the pro gram named
Timer0_VarDelay.asm listed later in this chapter and con tained in this book's soft-
ware, we develop a procedure in which the desired time delay is loaded from three
constants defined in the source. These con stants contain the val ues that are loaded
into local variables as they represent the desired wait period in machine cycles. Us-
ing machine cy cles instead of time units (such as microseconds or milliseconds) the
procedure becomes easily adaptable to devices running at different clock speeds.
Because each PIC instruction requires four clock cycles, the device's clock speed in
Hz is divided by four in order to de termine the number of machine cy cles per time
unit.
For example, a processor equipped with a 4-MHz clock executes at a rate of

4,000,000/4 machine cycles per second, that is, 1,000,000 instruction cycles per sec-
ond. To produce a one-quarter second delay requires a wait period of 1,000,000/4 or
250,000 instruction cycles. By the same token, an 18f452 running at 8 MHz executes
2,000,000 instructions per second. In this case, a one-quarter second delay would re-
quire waiting 500,000 instruction cycles.
Timer0_VarDelay.asm Program
The program titled Timer0_VarDelay.asm, listed later in this chapter and contained in
the book's software package, uses timer0 to produce a variable-lapse delay. As previ-
ously described, the delay is calculated based on the number of machine cycles neces-
sary for the desired wait period. The program uses a variation of the Black-Ammerman
method described earlier in this chapter. Code requires a prescaler of 1:2 so that each
timer iteration takes place at one-half the clock rate. This scheme simplifies using the
Timer0 beat as an it eration counter. After initializing Port C for output, the pro gram
sets or clears the T0CON register bits as follows:
;==============================
; setup Timer0 as coun ter
194 Chapter 9
; 8-bit mode
;==============================
; Prescaler is as signed to Timer0 and initialzed
; to 2:1 rate
; |------------- On/Off con trol
; ||------------ 8/16 bit mode se lect
; || 1 = 8-bit mode
; |||----------- Clock source
; ||| 0 = in ter nal clock
; ||||| 0 = prescaler as signed
; ||||||||------ Prescaler se lect
; |||||||| 1:2 rate
movlw b'11010000'
movwf T0CON
; Clear reg is ters
clrf TMR0L
The constants that define the time lapse period are entered in #define statements
so they can be easily edited to accommodate other delays and processor speeds. In
a 4-MHz system, a delay of one-half second requires 500,000 timer cycles, while a de-
lay of one-tenth second requires a count of 10,000. Because this delay value must be
entered in three 1-byte variables, the value is converted to hexadecimal so it can be
installed in three constants; for ex ample,
1,000,000 = 0x0f4240 = one sec ond at 4MHz

500,000 = 0x07a120 = one-half sec ond at 4MHz
10,000 = 0x002710 = one-tenth sec ond at 4MHz
For example, values for one-half second are installed in constants as follows:
500,000 = 0x07 0xa1 0x20

---- ---- ----
| | |___ lowCnt
| |________ midCnt
|_____________ highCnt
Code can read these constants and move them to local variables at the beginning
of each timer cycle, as in the following code fragment
;==============================
; set reg is ter vari ables
;==============================
; Pro ce dure to ini tial ize lo cal vari ables for a
; de lay pe riod de fined in lo cal con stants highCnt,
; midCnt, and lowCnt.
setVars:
movlw highCnt ; From con stants
movwf countH
movlw midCnt
movwf countM
movlw lowCnt
movwf countL
re turn
The actual delay routine is a variation of the Black-Ammerman method described

in Section 9.4.2. In this case, a back ground counter is made possible by introducing
a 1:2 timer delay by means of the prescaler. This delay makes the timer beat run at
one-half the instruction rate, that is, 128 timer cycles represent one complete timer
cy cle. By testing the high-order bit of the timer coun ter (TMR0L in 8-bit mode), the
routine easily detects when the count has reached 128. At that time, the mid-range
and high-range counter variables are updated by decrementing the counters, thus
tak ing care of pos si ble over flows. When the house keep ing has con cluded, the
high-order bit of the timer is cleared, but the low-order bits are not changed. Be-
cause the count is kept in the low-order bits during housekeep ing operations, the
timer coun ter does not lose step, which re mains valid until the next time the
high-order bit is again set.
In implementing this scheme, the TMR0L register provides the low-order level of
the count. Be cause the counter counts up from zero, code must pre-install a value in
the coun ter reg is ter that rep re sents one-half the num ber of timer it er a tions
(prescaler is in 1:2 mode) required to reach a count of 128. For example, if the value
in the low counter variable is 140, then
140/2 = 70
128 - 70 = 58
Because the timer starts counting up from 58, when the count reaches 128,140 timer
beats would have elapsed. The formula for calculating the value to pre-install in the
low-level counter is as fol lows:
Value in TMR0L = 128 - (x/2)
where x is the number of iterations in the low-level counter variable.
Code is as follows:
;==================================
; vari able-lapse de lay pro ce dure
; us ing Timer0
;==================================
; ON ENTRY:
; Vari ables countL, countM, and countH hold
; the low-, mid dle-, and high-or der bytes
; of the de lay pe riod, in timer units
TM0delay:
; For mula:
; Value in TMR0L = 128 - (x/2)
; where x is the num ber of it er a tions in the low-level
; coun ter vari able
; First cal cu late xx/2 by bit shift ing
rrncf countL,f ; Di vide by 2
; now sub tract 128 - (x/2)
movlw d'128'
196 Chapter 9
; Clear the bor row bit (mapped to Carry bit)

bcf STATUS,C
subfwb countL,w
; Now w has ad justed re sult. Store in TMR0L
movwf TMR0L
; Rou tine tests timer over flow by test ing bit 7 of
; the TMR0L reg is ter.
cy cle:
btfss TMR0L,7 ; Is bit 7 set?
goto cy cle ; Wait if not set
; At this point TMR0 bit 7 is set
; Clear the bit
bcf TMR0L,7 ; All other bits are pre served
; Sub tract 256 from beat coun ter by dec re ment ing the
; mid-or der byte
decfsz countM,f
goto cy cle ; Con tinue if mid-byte not zero
; At this point the mid-or der byte has over flowed.
; High-or der byte must be dec re ment ed.
decfsz countH,f
goto cy cle
; At this point the time cy cle has elapsed
re turn
Interrupt-Driven Timer
Interrupt-driven timers and counters have the advan tage over polled routines that the
time lapse counting takes place in the back ground, which makes it possible for an ap-
plica tion to continue to do other work in the fore ground. De veloping a timer routine
that is interrupt-driven presents no major programming challenges. The initialization
consists of configuring the OPTION and the INTCON register bits for the task at hand.
In the particular case of an interrupt-driven timer, the following are necessary:
1. The external interrupt flag (INTF in the INTCON Register) must be initially
cleared.
2. Global interrupts must be enabled by setting the GIE bit in the INTCON register.
3. The timer0 overflow interrupt must be enabled by setting the TOIE bit in the
INTCON register.
In the present example program, named Timer0_VarInt, the prescaler is not used
with the timer, so the initialization code sets the PSA bit in the OPTION register in
order to have the prescaler assigned to the Watchdog Timer. The following code
fragment is from the Timer0_VarInt program:
main:
; Set BSR for bank 0 op er a tions
movlb 0 ; Bank 0
; Ini tial ize all lines in PORT C for out put
movlw B'00000000' ; 0 = out put
movwf TRISC ; Port C tris reg is ter
movwf PORTC
;==============================
; 8-bit mode
;==============================
bcf INTCON,TMR0IE
; |------------- On/Off con trol
; ||------------ 8/16 bit mode se lect
; || 1 = 8-bit mode
; |||----------- Clock source
; |||||||| ----- Prescaler se lect
; |||||||| 1:2 rate
movlw b'11011000'
movwf T0CON
; Clear reg is ters
clrf TMR0L
;===============================
; Set up for Timer0 interupt
;===============================
; Dis able in ter rupt pri or ity lev els in the RCON reg is ter
; set ting up the mid range com pat i bil ity mode
bsf RCON,IPEN ; En able in ter rupt pri or i ties
; INTCON reg is ter in i tial ized as fol lows:
; (IPEN bit is clear)
; |------------ high-pri or ity in ter rupts
; ||----------- low-pri or ity pe riph eral
; |||---------- timer0 over flow in ter rupt
; ||||--------- ex ter nal in ter rupt
; |||||-------- port change in ter rupt
; ||||||------- over flow in ter rupt flag
; |||||||------ ex ter nal in ter rupt flag
; ||||||||----- RB4:RB7 in ter rupt flag
movlw b'10100000'
movwf INTCON
; Set INTCON2 for fall ing edge op er a tion
bcf INTCON2,INTEDG0
; Re-en able timer0 in ter rupt
bsf INTCON,TMR0IE ; Ac ti vate Timer0 in ter rupt
bcf INTCON,TMR0IF ; Clear in ter rupt f
As in the program Timer0_VarDelay developed previously in this chapter, the

timer operates by decrementing a 3-byte counter that holds the number of timer
beats required for the programmed delay. In the case of the Timer0_VarInt program,
the routine that initializes the register variables for a one-half second delay also
makes the adjustment so that the initial value loaded into the tmr0 register is cor-
rectly adjusted. The code is as follows:
;==============================
; set reg is ter vari ables for
; one-half sec ond de lay
;==============================
; de lay of one-half sec ond on a 16F84 at 4 MHz.
; Timer is setup for a 500,000 clock beats as
; fol lows: 500,000 = 0x07 0xa1 0x20
198 Chapter 9
; 500,000 = 0x07 0xa1 0x20

; ---- ---- ----
; | | |___ countL)
; | |________ countM
; |_____________ countH
onehalfSec:
movlw 0x07
movwf countH
movlw 0xa1
movwf countM
movlw 0x20
movwf countL
; The tmr0 reg is ter pro vides the low-or der level of
; the count. Because the coun ter counts up from zero,
; in or der to en sure that the ini tial low-level de lay
; count is cor rect, the value 256 - xx must be cal cu lated
; where xx is the value in the orig i nal countL vari able.
movf countL,w ; w holds low-or der byte
sublw d'256'
; Now w has ad justed re sult. Store in tmr0
movwft mr0
re turn
The in ter rupt ser vice rou tine in the Timer0_VarInt pro gram receives con trol
when the tmr0 register overflows, that is, when the count goes from 0xff to 0x00.
The service routine then proceeds to decrement the mid-range counter register and
adjust, if necessary, the high-order counter. If the count goes to zero, the han dler
toggles the LED on port B, line 0, and re-initializes the counter variables by calling
the onehalfSec pro ce dure described previously. The interrupt handler is coded as
follows:
;=======================================================
; In ter rupt Ser vice Rou tine
;=======================================================
; Ser vice rou tine re ceives con trol when the timer
; reg is ter tmr0 over flows, that is, when 256 timer beats
; have ellapsed
IntServ:
; First test if source is a timer0 in ter rupt
btfss INTCON,toif ; TOIF is timer0 in ter rupt
goto notTOIF ; Go if not RB0 or i gin
; If so clear the timer in ter rupt flag so that count con tin ues
bcf INTCON,toif ; Clear in ter rupt flag
; Save con text
movwf old_w ; Save w reg is ter
swapf STATUS,w ; STATUS to w
movwf old_sta tus ; Save STATUS
;=========================
; in ter rupt ac tion
;=========================
; mid-or der byte
decfsz countM,f
goto exitISR ; Con tinue if mid-byte not zero
decfsz countH,f
goto exitISR
; At this point count has ex pired so the pro grammed time

; has ellapsed. Ser vice rou tine turns the LED on line 0,
; port B on and off at ev ery con clu sion of the count.
; This is done by xoring a mask with a one-bit at the
; port B line 0 po si tion
movlw b'00000001' ; Xoring with a 1-bit pro duces
; the com ple ment
xorwf portb,f ; Com ple ment bit 2, port B
; Re set one-half sec ond coun ter
call onehalfSec
;=========================
; exit ISR
;=========================
exitISR:
; Re store con text
swapf old_sta tus,w ; Saved sta tus to w
movfw STATUS ; To STATUS reg is ter
swapf old_w,f ; Swap file reg is ter in it self
swapf old_w,w ; re-swap back to w
; Re turn from in ter rupt
notTOIF:
retfie
Notice that one of the initial operations of the service routine is to clear the TOIF
bit in the INTCON register. This action reenables the timer interrupt and prevents
counting cycles from being lost. Because the interrupt is generated every 256 beats
of the timer, there is no risk that by enabling the timer interrupt flag a reentrant in-
terrupt will take place.
The interrupt-based timer program named Timer0_VarInt can be tested either on

the circuit in Figure 7.2 or the or Demo Board 18F452-A (in Figure 7.3).
9.5 Other Timer Modules

The PIC 18F family of microcontrollers provide either three or four timer modules in
addition to Timer0. These are designated Timer1, Timer2, Timer3, and Timer4 mod-
ules. The programming and applica tion of these other timer modules are similar to
that of the Timer0 module previously described. The main difference between Timer0
and the other three timer modules relate to the available clock sources and special
fea tures that pro vide interac tion with other hardware modules. The Timer4 module is
only available in some specific devices of the PIC 18F family.
9.5.1 Timer1 Module

The Timer1 module is a 16-bit device that can perform timing and counting operations.
It contains two 8-bit registers labeled TMR1H and TMR1L. Both registers are readable
and writable. The register pair increments from 0000H to FFFFH and then rolls over
back to 0000H. Timer1 can be enabled to generate an interrupt on overflow of the
timer registers. In this case, the interrupt is reflected in the interrupt flag bit TMR1IF.
The interrupt is enabled by set ting the set ting the TMR1IE interrupt enable bit.
Timer1 can operate in one of three modes:

200 Chapter 9
1. As a synchronous timer
2. As a synchronous counter
3. As an asynchronous counter
The operating mode is selected by clock select bit, TMR1CS (T1CON register),
and the syn chronization bit, T1SYNC. In the timer mode, Timer1 increments ev ery
instruction cycle. In the counter modes, it increments on every rising edge of the ex-
ternal clock input pin T1OSI. Timer1 is turned on and off by means of the TMR1ON
control bit in the T1CON register.
Timer1 has an internal reset input that can be generated by a CCP module as well
as the capability of operating off an external crystal. When the Timer1 oscillator is
enabled (T1OSCEN is set), the T1OSI and T1OSO pins be come inputs and their cor-
responding TRIS values are ignored. Figure 9.3 shows the bitmap of the Timer1 con-
trol reg ister (T1CON.)
bit 7 bit 0
RD16 - T1CKPS1 T1CKPS2 T1OSCEN T1SYNC TMR1CS TMR1ON
bit 7 Rd16: 16-bit Read/Write Mode Enable bit

1 = Enables register Read/Write in one 16-bit operation
0 = Enables register Read/Write in two 8-bit operations
bit 6 Unimplemented:
bit 5:4 T1CKPS1:T1CKPS0: Timer1 Input Clock Prescale Select bits
11 = 1:8 Prescale value
bit 3 T1OSCEN: Timer1 Oscillator Enable bit
1 = Timer1 oscillator is enabled
0 = Timer1 oscillator is turned off
bit 2 T1SYNC: Timer1 External Clock Input Synchronization Select
When TMR1CS = 1:
1 = Do not synchronize external clock input
0 = Synchronize external clock input
When TMR1CS = 0
Timer1 uses the internal clock
bit 1 TMR1CS: Timer1 Clock Source Select bit
1 = External clock from pin T1OSO/T13CKI (rising edge)
0 = Internal clock at FOSC/4
bit 0 TMR1ON: Timer1 On bit
1 = Timer1 enabled
0 = Timer1 stopped
Timer1 in Timer Mode
Timer1 is set in timer mode by clearing the TMR1CS (T1CON register) bit (see Figure
9.3). In the timer mode the input clock to the timer is the processor's main clock at
FOSC/4. In this mode, the synchronize control bit, T1SYNC (T1CON register), has no
effect because the internal clock is always synchronized.
Timer1 in Synchronized Counter Mode

Synchronized counter mode is selected by setting the TMR1CS bit (see Figure 9.3). In
this mode, the timer increments on ev ery rising edge of input signal on the T1OSI pin
(when the Timer1 oscillator enable bit (T1OSCEN) is set) or the T1OSO/T13CKI pin
(when the T1OSCEN bit is cleared.) If the T1SYNC bit is cleared, then the external
clock input is synchronized with internal phase clocks. During SLEEP mode, Timer1
will not increment even if the external clock is present, because the synchronization
circuit is shut off. The prescaler, however, will continue to increment.
External Clock Input Timing in Synchronized Mode

When Timer1 is set to use an external clock input in synchronized counter mode, it
must meet the following requirements:
1. There is a delay in the actual incrementing of TMR1 after synchronization.
2. When the prescaler is 1:1, the external clock input is the same as the prescaler
output.
3. The synchronization of T1CKI with the internal phase clocks is accomplished by
sampling the prescaler output on alternating TSCLK clocks of the internal phase
clocks. Therefore, it is necessary for the T1CKI pin to be high for at least 2TSCLK
(and a small RC delay) and low for at least 2TSCLK (and a small RC delay).
4. When a prescaler other than 1:1 is used, the external clock input is divided by the
asynchronous prescaler so that the prescaler output is symmetrical.
5. In order for the external clock to meet the sampling requirement, the prescaler
counter must be taken into account. Therefore, it is necessary for the T1CKI pin
to have a period of at least 4TSCLK (and a small RC delay) divided by the
prescaler value.
6. Finally, the T1CKI pin high and low times cannot violate the minimum pulse width
requirements.
Timer1 Read and Write Operations

Timer1 read and write modes allow the 16-bit timer register to be read/written as two
8-bit registers or as one 16-bit register. The mode is selected by means of the RD16 bit.
When the RD16 control bit (T1CON register) is set (see Figure 9.3), the address for
TMR1H is mapped to a buffer register for the high byte of Timer1. This determines that
a read from TMR1L will load the con tents of the high byte of Timer1 into the Timer1
high byte buffer. This scheme makes it possible to accurately read all 16 bits of Timer1
without hav ing to determine if a rollover took place when a read of the high byte was
followed by a read of the low byte.
16-bit Mode Timer1 Write

As is the case with a read operation, a write to the high byte of Timer1 must also take
place through the TMR1H buffer register. Therefore Timer1 high byte is updated with
the contents of TMR1H when a write occurs to TMR1L. This allows writing all 16 bits
to both the high and low bytes of Timer1 in a single operation. Figure 9.4 shows the ar -
chitecture of the Timer1 when configured for 16-bit Read/Write mode.
202 Chapter 9
Figure 9.4 Timer1 block diagram.
No tice in Fig ure 9.4 that the high byte of Timer1 is not directly read able or
writable in the 16-bit mode. Instead, all reads and writes take place through the
Timer1 high byte buffer register. Also notice that writes to TMR1H do not clear the
Timer1 prescaler.
16-bit Read-Modify-Write
Read-modify-write instructions, such as BSF and BCF, read the con tents of a reg ister,
make the appropriate changes, and then place the result back into the same register.
When Timer1 is configured in 16-bit mode, the read portion of a read-modify-write in-
struction of TMR1L will not update the contents of the TMR1H buffer. The TMR1H
buffer will re main unchanged. When the write of TMR1L portion of the instruction
takes place, the contents of TMR1H are placed into the high byte of Timer1.
Reading and Writing Timer1 in Two 8-bit Operations
When Timer1 is in Asynchronous Counter Mode for 16-bit operations (RD16 = 1), the
hardware ensures a valid read of TMR1H or TMR1L. However, reading the 16-bit timer
in two 8-bit values (RD16 = 0) poses the problem of a possible timer overflow between
the reads. For write operations, the program can stop the timer and write the desired
values. Turning off the timer pre vents a write con tention that could occur when writ-
ing to the timer registers while the register is incrementing. On the other hand, reading
may produce an unpredictable value in the timer register and requires special care in
some cases. This happens because two separate reads are required to read the entire
16-bits.
The following code fragment shows a routine to read the 16-bit timer value with-
out experienc ing the timer overflow issues previously mentioned. This scheme is
useful if the timer cannot be stopped.
; Read ing a 16-bit timer
; Code as sumes the vari ables named tmph and tmpl
; All in ter rupts are dis abled
movf TMR1H,w ; Read high byte
movwf tmph
movf TMR1L,w ; Read low byte
movwf tmpl
subwf tmph,w ; Sub tract 1st read and 2nd read
btfsc STATUS,z ; is re sult = 0 ?
goto CONTINUE ; good 16-bit read
; TMR1L may have rolled over be tween the read of the high
; and low bytes. Read ing the high and low bytes now will
; read a good value.
movwf TMPH
movf TMR1L, w ; Read low byte
movwf TMPL
CONTINUE:
; Code con tin ues at this la bel
Writing a 16-bit value to the 16-bit TMR1 register is straightforward. First the
TMR1L register is cleared to ensure that there are many Timer1 clock/oscillator cy-
cles before there is a rollover into the TMR1H register. The TMR1H register is then
loaded, and then the TMR1L register, as shown in the following code fragment.
; Writ ing a 16-bit timer

; Code as sumes the vari ables names hi_byte and low_byte
clrf TMR1L ; Clear ing the low byte
; to en sure no roll over
; into TMR1H
movlw hi_byte ; Value to load into tmr1h
movwf TMR1H,f ; Write high byte
movlw lo_byte ; value to load into TMR1L
movwf TMR1L,f ; Write low byte
; re-en able the in ter rupt (if re quired)
; Code con tin ues here
9.5.2 Timer2 Module

The Timer2 is an 8-bit timer with a prescaler, a postscaler, and a period register. By us-
ing the prescaler and postscaler at their maximum settings it is possible to obtain a
time period equal to the one of a 16-bit timer. Timer2 is designed to be used as the
time-base for the PWM module. Figure 9.5 IS a block diagram of Timer2.
TMR2
output
Sets flag bit

Prescaler Reset TMR2IF
FOSC/4 TMR2
1:1 - 1:4 - 1:16
Comparator Posscaler
T2CKPS1:T2CKPS0 1:1 to 1:16
EQ
T2OUTPS3:T2OUTPS0
PR2
Figure 9.5 Timer2 block diagram.

204 Chapter 9
In Figure 9.5 note that the postscaler counts the number of times that the TMR2
register matched the PR2 register. This can be useful in reducing the overhead of
the interrupt service routine on the CPU performance. Figure 9.6 is a bitmap of the
T2CON register.
bit 7 bit 0
- TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0 TMR2ON T2CKPS1 T2CKPS0
bit 7 Unimplemented (reads as 0)
bit 6-3 TOUTPS3:TOUTPS0: Postscale select bits

0000 = 1:1 Postscale
.
.
.
bit 2 TMR2ON: Timer2 ON

1 = Timer2 is on
0 = Timer2 is off
bit 1-0 T2KPS1:T2KPS0: Prescale select bits

00 = Prescale is 1
01 = Prescale is 4
1x = Prescale is 16
Timer Clock Source

The Timer2 module has a single source of input clock, which is the device clock
(FOSC/4). However, the clock speed can be controlled by selecting one of the three
prescale options (1:1, 1:4, or 1:16). This is accomplished by means of the control bits
T2CKPS1:T2CKPS0 in the T2CON register (see Figure 9.6).
TMR2 and PR2 Registers

The TMR2 register is readable and writable, and is cleared on all device resets. Timer2
increments from 0x00 until it matches the period register (PR2) and then resets to
0x00 on the next increment cycle. PR2 is also a readable and writable register. The
TMR2 register is cleared and the PR2 register is set when a WDT, POR, MCLR, or a BOR
reset occurs.
Programming Timer2 is simplified by means of the interaction between the TMR2

and the PR2 register. On timer start-up the TMR2 register is initialized to 0x00 and
the PR2 register to 0xff. In this state, TMR2 operates as a simple counter and resets
as it reaches 0xff. Application code can define a timing period by setting these regis-
ters accordingly. For example, to obtain a time period of 50 cycles an application
can set the PR2 register to 50 and then monitor when the TMR2 register overflows
(TMR2IF flag is set) or when a Timer2 interrupt is generated.
If the PR2 register is cleared (set to 0x00), the TMR2 register will not increment
and Timer2 will be disabled. Timer2 can also be shut off by clearing the TMR2ON
control bit (T2CON register). When Timer2 is not used by an applica tion it is rec om-
mended to turn it off be cause this minimizes the power consumption of the module.
Prescaler and Postscaler
Four bits serve to select the postscaler. This allows the postscaler rate from 1:1 to
1:16. After the postscaler overflows, the TMR2 interrupt flag bit (TMR2IF) is set to in-
dicate the Timer2 overflow. This is useful in reducing the software overhead of the
Timer2 interrupt service routine, because it will only execute when the postscaler is
matched. The prescaler and postscaler counters are cleared when any of the following
occurs:
1. Aa write to the TMR2 register
2. A write to the T2CON register
3. Any device reset (Power-on Re set, MCLR re set, Watchdog Timer Reset,
Brown-out Reset)
During sleep, TMR2 will not increment. The prescaler will retain the last prescale
count, ready for operation to resume after the device wakes from sleep.
Timer2 Initialization
The following code frag ment shows the initialization of the Timer2 module, including
the prescaler and postscaler:
clrf T2CON ; stop timer2, prescaler = 1:1,

; postscaler = 1:1
clrf TMR2 ; clear timer2 reg is ter
clrf INTCON ; dis able in ter rupts
lrf PIE1 ; dis able pe riph eral in ter rupts
clrf PIR1 ; clear pe riph eral in ter rupts flags
movlw 0x72 ; postscaler = 1:15
; prescaler = 1:16
movwf T2CON ; timer2 is off
movlw pr2value ; value to load into the
movwf PR2 ; PR2 reg is ter.
bsf T2CON, TMR2CON ; timer2 starts to in cre ment
; the timer2 in ter rupt is dis abled, do poll ing on the
; over flow bit
t2_ovfl_wait
btfss PIR1, TMR2IF ; has tmr2 in ter rupt oc curred?
goto t2_ovfl_wait ; no, con tinue loop
; timer has over flowed
bcf PIR1, TMR2IF ; yes, clear flag and con tinue.
9.5.3 Timer3 Module

The Timer3 module is a 16-bit timer/counter consisting of two 8-bit registers labeled
TMR3H and TMR3L. Both registers are readable and writable. The register pair
(TMR3H:TMR3L) increments from 0000h to FFFFh and rolls over to 0000h. The
Timer3 Interrupt is generated on over flow and is latched in the TMR3IF interrupt flag
bit. This interrupt can be enabled/disabled by setting/clearing the TMR3IE interrupt
enable bit. Figure 9.7 is a block diagram of the Timer3 module.
206 Chapter 9
CCP special trigger
Set TMR3IF flag

bit on overflow
T3CCPx
Synchronized
0
clock input
CLR
TMR3H TMR3L
TMR3 1
TMR3ON
(on/off)
T1SYNC
TT1P 1
Synchronize
Prescaler
1-2-4-8
det
FOSC/4
internal 0
clock
SLEEP input
T3CKPA1:T3CKPS0
TMR3CS
Figure 9.7 Timer3 block diagram for 16-bit modes.
Timer3 can operate in one of three modes:

1. As a synchronous timer
2. As a synchronous counter
3. As an asynchronous counter
The following features are characteristic of the Timer3 module:
• TMR3 also has an internal “reset input,” that can be generated by a CCP module.
• TMR3 has the capability to operate off an external crystal/clock.
• TMR3 is the alternate time base for capture/compare.
Figure 9.8 is a bitmap of the Timer3 Control Register.
Timer3 increments every instruction cycle while in the timer mode. In counter
mode, it increments on every rising edge of the external clock input. The Timer3 in-
crement can be enabled or disabled by setting or clearing control bit TMR3ON
(T3CON register in Figure 9.8). Timer3 also has an internal “reset input.” This reset
can be generated by a CCP special event trigger (Capture/Compare/PWM) module.
When the Timer1 oscillator is enabled (T1OSCEN, in T1CON, is set), the T1OSCI1
and T1OSO2 pins are con figured as oscillator input and out put, so the cor respond-
ing values in the TRIS register are ignored. The Timer3 module also has a software
programmable prescaler. The operating mode is determined by clock select bit,
TMR3CS (T3CON register), and the synchronization bit, T3SYNC (Figure 9.8).
bit 7 bit 0
RD16 T3CPP2 T3CKPS1 T3CKPS0 T3CCP1 T3SYNC TMR3CS TMR3ON
bit 7 Rd16: 16-bit Read/Write Mode Enable bit

1 = Enables register Read/Write in one 16-bit operation
0 = Enables register Read/Write in twso 8-bit operations
bit 6,3 T3CCP2:T3CCP1t: Timer3 and Timer1 CCPx Enable bits

1x = Timer3 is clock source for capture/compare of CCP modules
01 = Timer3 is clock source for capture/compare of CCP2
Timer1 is clock source for capture/compare of CCP1
00 = Timer1 is clock source for capture/compare of CCP modules
bit 5:4 T3CKPS1:T3CKPS0: Timer3 Input Clock Prescale Select bits

bit 2 ~T3SYNC: Timer3 External Clock Input Synchronization Select

When TMR3CS = 1:
1 = Do not synchronize external clock input
0 = Synchronize external clock input
When TMR3CS = 0
Timer1 uses the internal clock
bit 1 TMR3CS: Timer1 Clock Source Select bit

1 = External clock form pin T1OSO/T13CKI (rising edge)
0 = Internal clock at FOSC/4
bit 0 TMR3ON: Timer3 On bit

1 = Timer3 enabled
0 = Timer3 stopped
Timer3 in Timer Mode

Timer mode is selected by clearing the TMR3CS bit (T3CON register in Figure 9.8). In
this mode, the input clock to the timer is FOSC/4. The synchronize control bit,
T3SYNC (T3CON register in Figure 9.8), has no effect because the internal clock is al-
ways synchronized.
Timer3 in Synchronized Counter Mode

The Timer3 counter mode is selected by setting bit TMR3CS (see Figure 9.8). In the
counter mode, the timer increments on ev ery rising edge of input on the T1OSI pin
(when enable bit T1OSCEN is set) or the T13CKI pin (when bit T1OSCEN is cleared). If
the T3SYNC bit is cleared, then the ex ternal clock input is synchronized with internal
phase clocks. The synchronization is done after the prescaler stage, which operates
asynchronously. Notice that Timer3 gets its external clock input from the same source
as Timer1. The configuration of the Timer1 and Timer3 clock input will be controlled
by the T1OSCEN bit in the Timer1 control register.
During SLEEP mode, Timer3 will not increment even if an external clock is pres-
ent, as the syn chronization circuit is shut off. The prescaler, however, will continue
to increment.
208 Chapter 9
External Clock Input Timing

The external clock input used for Timer3 in synchronized counter mode must meet
certain requirements:
• When the prescaler is 1:1, the external clock input is the same as the prescaler out-
put. In this case, there is synchronization of T1OSI/T13CKI with the internal phase
clocks. Therefore, it is necessary for T1OSI/T13CKI to be high for at least 2TSCLK
(and a small RC delay) and low for at least 2TSCLK.
• When a prescaler other than 1:1 is used, the external clock input is divided by the
asynchronous prescaler. In this case, the prescaler output is symmetrical.
Timer3 in Asynchronous Counter Mode

When the ~T3SYNC bit is set, the ex ternal clock input is not synchronized. In this case,
the timer continues to increment asynchronously to the internal phase clocks. The
timer will continue to run during SLEEP and can generate an in terrupt on over flow
that will wake up the processor.
Because the counter can operate in sleep, Timer3 can be used to implement a
true real-time clock. This also explains why in asynchronous counter mode, Timer3
cannot be used as a time base for capture or compare operations.
External Clock Input Timing with Unsynchronized Clock

If the T3SYNC con trol bit is set, the timer will increment completely asynchronously.
Also note that the con trol bit T3SYNC is not usable when the sys tem clock source co-
mes from the same source as the Timer1/Timer3 clock input. This is because the
T1CKI input will be sampled at one quarter the frequency of the incoming clock.
Timer3 Reading and Writing

Timer3 allows the 16-bit timer register to be read/written as two 8-bit registers or one
16-bit register. Which mode is selected is determined by the RD16 bit (see Figure 9.8).
Timer3 is configured for 16-bit reads when the RD16 control bit (T3CON register) is
set. In this case, the address for TMR3H is mapped to a buffer register. A read from
TMR3L will load the contents of the high byte of Timer3 into the Timer3 high byte
buffer. This scheme provides a mechanism to accurately read all 16 bits of Timer3
without hav ing to determine whether a read of the high byte followed by a read of the
low byte is valid due to a rollover between reads.
Writing in 16-Bit Mode

Writing the high byte of Timer3 must also take place through the TMR3H buffer regis-
ter. In this case, the Timer3 high byte is updated with the con tents of TMR3H when a
write occurs to TMR3L. Here again, this allows writing all 16 bits to both the high and
low bytes of Timer3 at once.
The high byte of Timer3 is not directly read able or writable in this mode. All
reads and writes must take place through the Timer3 high byte buffer reg ister.
Writes to TMR3H do not clear the Timer3 prescaler. The prescaler is only cleared on
writes to TMR3L.
16-Bit Read-Modify-Write Operation

Instructions that perform read-modify-write, such as BSF or BCF, first read the con -
tents of a register, then make the appropriate changes, and finally place the result
back into the reg ister. When Timer3 is configured in 16-bit mode, the read portion of a
read-modify-write instruction of TMR3L will not update the contents of the TMR3H
buffer. In this case, the TMR3H buffer remains unchanged. However, when the write
portion of the instruction takes place, the contents of TMR3H will be placed into the
high byte of Timer3.
Reading in Asynchronous Counter Mode

The hardware ensures a valid read operation of TMR3H or TMR3L while the timer is
running from an external asynchronous clock. However, reading the 16-bit timer in
two 8-bit values poses problems because the timer may overflow between the reads.
Regarding write operations it is recommended that code stop the timer and write
the desired values, although a write contention may occur by writing to the timer
registers, while the register is incrementing. In this case an unpredictable value may
result. Microchip provides no information on how to prevent or how to cor rect this
possible error.
Reading the 16-bit value requires some care because two separate reads are re-
quired to read the entire 16-bits. The following code snippet shows reading a 16-bit
timer value in cases when the timer cannot be stopped and while avoiding a timer
rollover error.

movf TMR3H, w ; Read high byte
movwf TMPH
movwf TMPL
subwf TMPH, w ; Sub 1st read with 2nd read
btfsc STATUS,Z ; Is re sult = 0
goto CONTINUE ; Good 16-bit read
; If the zero flag is not set, then TMR3L may have rolled
; over be tween the read of the high and low bytes. Read ing
; the high and low bytes now will pro duce a valid value.
movwf TMPH
movwf TMPL
CONTINUE:
; Pro gram con tin ues at this la bel
To write a 16-bit value to the 16-bit TMR3 register is straightforward. First, the
TMR3L register is cleared to ensure that there are many Timer3 clock/oscillator cy-
cles before there is a rollover into the TMR3H register. The TMR3H register is then
loaded, and finally, the TMR3L register is loaded. The following code snippet shows
the sequence of operations.
210 Chapter 9

clrf TMR3L ; Clear Low byte, En sures no
; roll over into TMR3H
movlw HI_BYTE ; Value to load into TMR3H
movwf TMR3H, F ; Write High byte
movlw LO_BYTE ; Value to load into TMR3L
movwf TMR3H, F ; Write Low byte
CONTINUE;
; Pro gram code con tin ues at this la bel
Timer1 Oscillator in Timer3

The 18F452 PIC has an alternate crystal oscillator circuit that is built into the device
and is labeled the Timer1 Oscillator. The output of this oscillator can be se lected as the
input into Timer3. The Timer1 Oscillator is primarily intended to operate as a time
base for real-world timing operations, that is, the oscillator is primarily intended for a
32-kHz crystal, which is an ideal frequency for real-time keeping.
The fact that the SLEEP mode does not disable the Timer1 facilitates its use in
keeping real-time. The Timer1 Oscillator is also designed to minimize power con-
sumption, which can be a factor in real-time applications. The Timer1 Oscillator is
enabled by setting the T1OSCEN control bit (T1CON register in Figure 9.8). After
the Timer1 Oscillator is enabled, the user must provide a software time delay to en-
sure its proper start-up.
9.6 C-18 Timer Functions

The C18 Hardware Peripherals Library contains functions to enable, disable, config-
ure, open, and close timers and to read and write to timer registers. The functions are
furnished in four function groups:
• CloseTimerx, where x is any digit from 0 to 4, to disable a specific timer.
• OpenTimerx, where x is any digit from 0 to 4, to configure and enable a specific
timer.
• ReadTimerx, where x is any digit from 0 to 4, to read the value currently in the
timer registers.
• WriteTimerx, where x is any digit from 0 to 4, to write a value into a specified timer
register.
The timer-related functions require including the timer.h header file. The func-
tions are described in the following subsections.
9.6.1 CloseTimerx Function

This function disables the interrupt and the spec ified timer; for example,
CloseTimer0();
closes the Timer0 module.
9.6.2 OpenTimerx Function

This function opens and configures a specific Timer device available in the hardware.
The arguments are bits that are logically anded to obtain the desired timer configura-
tion. The following arguments are found in the timers.h file:
En able Timer0 In ter rupt:

TIMER_INT_ON In ter rupt en abled
TIMER_INT_OFF In ter rupt dis abled
Timer Width:
T0_8BIT 8-bit mode
T0_16BIT 16-bit mode
Clock Source:
T0_SOURCE_EXT Ex ter nal clock source (I/O pin)
T0_SOURCE_INT In ter nal clock source (TOSC)
Ex ter nal Clock Trig ger (for T0_SOURCE_EXT):
T0_EDGE_FALL Ex ter nal clock on fall ing edge
T0_EDGE_RISE Ex ter nal clock on ris ing edge
Prescale Value:
T0_PS_1_1 1:1 prescale
The following code snippet opens and configures Timer0 to disable interrupts,
en able the 8-bit data mode, use the in ter nal clock source, and se lect the 1:32
prescale.
// con fig ure timer0

OpenTimer0( TIMER_INT_OFF &
T0_8BIT &
T0_SOURCE_INT &
T0_PS_1_32 );
The C-18 functions for specific timers may con tain support for other hard ware
devices. For example, the arguments in OpenTimer1, OpenTimer2, and OpenTimer3
functions include interaction with CCP modules.
9.6.3 ReadTimerx Function

The ReadTimerx functions allow reading the value of the specified timer register. The
x parameter can take values representing any of the available timer modules, such as
ReadTimer0 to ReadTimer4. The function's prototype is as follows:
un signed int ReadTimerx (void);
The function takes data from the available timer registers as fol lows:
Timer0: TMR0L,TMR0H
Timer1: TMR1L,TMR1H
Timer2: TMR2
Timer3: TMR3L,TMR3H
212 Chapter 9
Timer4: TMR4
When the ReadTimerx function is used in the 8-bit mode for a timer module that
may be configured in 16-bit mode (for example, timer0, timer1, and Timer3) ), the
read operation does not ensure that the high-order byte will be zero. In this case,
code may cast the result to a char for correct results. For example,
// Read ing a 16-bit re sult from a 16-bit timer

// op er at ing in 8-bit mode:
un signed int re sult;
re sult = (un signed char) ReadTimer0();
9.6.4 WriteTimerx Function

The WriteTimerx functions allow writing a value to the specified timer register. The x
parameter can take values representing any of the available timer modules, such as
WriteTimer0 to WriteTimer4. The function's prototype is as follows:
void WriteTimerx (un signed int);
The function places data in the available timer registers as fol lows:
Timer0: TMR0L,TMR0H
Timer1: TMR1L,TMR1H
Timer2: TMR2
Timer3: TMR3L,TMR3H
Timer4: TMR4
For example:
WriteTimer0(32795);
9.7 Sample Programs

The following programs demonstrate the pro gramming discussed in this chapter.
9.7.1 Timer0_as_Counter Program
; File name: Timer0_as_Coun ter.asm

; Date: Oc to ber 3, 2012
; No copy right
; Pro ces sor: PIC 18F452
;
; Port di rec tion and wir ing for this pro gram:
; PORT PINS DIRECTION DEVICE
; C 0-6 Out put 7-seg ment LED
; A 3 In put DIP Sw
;
; De scrip tion:
; A dem on stra tion pro gram to count ac tions on DIP switch
; # 3 (wired to RA4/T0CKI pin) and dis play count on the
; seven seg ment LED wired to Port C.
; Cir cuit is DemoBoard 18F452-A or equiv a lent.
;
;=========================================================
; def i ni tion and in clude files
;=========================================================
pro ces sor 18F452 ; De fine pro ces sor
#in clude <p18F452.inc>
; ==========================================================
; con fig u ra tion bits
;===========================================================
config OSC = HS ; As sumes high-speed res o na tor
config WDT = OFF ; No watch dog timer
config LVP = OFF ; No low volt age pro tec tion
config DEBUG = OFF ; No back ground debugger
;
; Turn off bank ing er ror mes sages
errorlevel -302
;============================================================
; pro gram
;============================================================
org 0 ; start at ad dress
goto main
; Space for in ter rupt han dlers
;=============================
; in ter rupt in ter cept
;=============================
org 0x008 ; High-pri or ity vec tor
retfie
org 0x018 ; Low-pri or ity vec tor
retfie
;================================
; Ta ble to re turns 7-seg ment
; codes
;================================
org $+2
; Note: Ta ble is placed in low pro gram mem ory at
; an ad dress where PCL = 0x1A. This pro vides space
; for 115 retlw in struc tions (at 2 bytes per
; in struc tion). 18 en tries are ac tu ally used in
; this ex am ple. By know ing the lo ca tion of the
; ta ble (at 0x1A in this case) we make sure that
; a code page bound ary is not strad dled while
; ac cess ing ta ble en tries because the in struc tion:
; addwf PCL,F
; does not up date the PCH reg is ter.
; Ad dresses (PCL value) in cre ment by two for
; each se quen tial in struc tion in the ta ble.
codeTable:
addwf PCL,F ; PCL is pro gram coun ter latch
retlw 0x3f ; 0 code
retlw 0x06 ; 1
retlw 0x5b ; 2
retlw 0x4f ; 3
retlw 0x66 ; 4
retlw 0x6d ; 5
retlw 0x7d ; 6
retlw 0x07 ; 7
retlw 0x7f ; 8
retlw 0x6f ; 9
retlw 0x00 ; Pad ding
214 Chapter 9
;============================================================
; main pro gram en try point
;============================================================
main:
movlb 0 ; Bank 0
; Init Port A for dig i tal op er a tion
clrf PORTA,0
clrf LATA,0
; ADCON1 is the con fig u ra tion reg is ter for the A/D
; func tions in Port A. A value of 0b011x sets all
; lines for dig i tal op er a tion
movlw B'00000110' ; Dig i tal mode
movwf ADCON1,0
; Port A. Set lines 2 to 5 for in put
movlw B'00111100' ; w = 00111100 bi nary
movwf TRISA,0 ; port A (lines 2 to 5) to in put
movlw B'00000000' ; 0 = out put
movwf TRISC,0 ; Port C tris reg is ter
;==============================
;==============================
clrf TMR0L
; |------------- On/Off con trol
; ||------------ 8/16 bit mode se lect
; || 1 = 8-bit mode
; |||----------- Clock source
; ||| 1 = T0CKI pin
; ||||| 1 = prescaler NOT assigned
; ||||||||
movlw b'11111000'
movwf T0CON
;=================================
; Check value in TMR0L and dis play
;=================================
; Ev ery clos ing of DIP switch # 3 (con nected to line
; RA4/TOCKI) adds one to the value in the TMR0L reg is ter.
; Loop checks this value, ad justs to the range 0 to 15
; and dis plays the re sult in the seven-seg ment LED on
; port B
checkTmr0:
movf TMR0L,w ; Timer reg is ter to w
; Elimate four high or der bits
andlw b'00001111' ; Mask off high bits
; At this point the w reg is ter con tains a 4-bit value
; in the range 0 to 0xf. Use this value (in w) to
; ob tain seven-seg ment dis play code
call codeTable
movwf PORTC ; Dis play switch bits
goto checkTmr0
end
9.7.2 Timer0_Delay Program
; File name: Timer0_De lay.asm

; No copy right
;
; C 0-7 Out put LEDs
;
; De scrip tion:
; Pro gram to dem on strate pro gram ming of the 18F452 Timer0
; mod ule. Pro gram flashes eight LEDs in se quence count ing
; from 0 to 0xff. Timer0 is used to de lay the count.
; Cir cuit is DemoBoard 18F452-A or equiv a lent.
;
;=========================================================
;=========================================================
; ==========================================================
;===========================================================
;
errorlevel -302
;
;============================================================
; pro gram
;============================================================
goto main
;=============================
;=============================
retfie
retfie
;============================================================
;============================================================
main:
movlb 0 ; Bank 0
; Init Port A for dig i tal op er a tion
clrf PORTA,0
clrf LATA,0
; ADCON1 is the con fig u ra tion reg is ter for the A/D
; func tions in Port A. A value of 0b011x sets all
; lines for dig i tal op er a tion
movlw B'00000110' ; Dig i tal mode
216 Chapter 9
movwf ADCON1,0
; Port A. Set lines 2 to 5 for in put
movlw B'00111100' ; w = 00111100 bi nary
movwf TRISA,0 ; port A (lines 2 to 5) to in put
movlw B'00000000' ; 0 = out put
clrf PORTC ; Turn off all LEDs
;==============================
; setup Timer0 as de lay timer
;==============================
clrf TMR0H ; Clear high latch
clrf TMR0L ; Write both bytes
; |------------- On/Off con trol
; ||------------ 8/16 bit mode se lect
; || 0 = 16-bit mode
; |||----------- Clock source
; ||| 0 = In ter nal clock
; |||||||| ----- No prescaler
; ||||||||
movlw b'10011000'
movwf T0CON
;=================================
; end less loop call ing
; de lay routiney
;=================================
; Dis play Port C count on LEDs
showLEDs:
incf PORTC,f ; Add one to reg is ter
call tmr0_de lay ; De lay rou tine
goto showLEDs
;=================================
; Timer0 de lay rou tine
;=================================
tmr0_de lay:
cy cle:
movf TMR0L,w ; Read low byte to latch
; high byte
movf TMR0H,w ; Now read high byte
sublw 0xff ; Sub tract max i mum count
btfss STATUS,Z ; Test zero flag
goto cy cle
; Re set coun ter
clrf TMR0H ; Clear high byte buffer
clrf TMR0L ; Write both low and high
re turn
end
9.7.3 Timer0_VarDelay Program

; File name: Timer0_VarDelay.asm
; No copy right

;
;
; De scrip tion:
; Us ing timer0 to pro duce a vari able-lapse de lay.
; The de lay is cal cu lated based on the num ber of ma chine
; cy cles nec es sary for the de sired wait pe riod. For
; ex am ple, a ma chine run ning at a 4 MHz clock rate
; ex e cutes 1,000,000 in struc tions per sec ond. In this
; case a 1/2 sec ond de lay re quires 500,000 in struc tions.
; The wait pe riod is passed to the de lay rou tine in three
; editable con stants which hold the high-, mid dle-, and
; low-or der bytes of the coun ter.
; The rou tine uses Timer0 in 8-bit mode.
;
;=========================================================
;=========================================================
; ==========================================================
;===========================================================
;
;=====================================================
; timer con stant def i ni tions
;=====================================================
; Three timer con stants are de fined in or der to im ple ment
; a given de lay. For ex am ple, a de lay of one-half sec ond
; in a 4MHz ma chine, re quires a count of 500,000, while
; a de lay of one-tenth sec ond re quires a count of 10,000.
; These num bers are con verted to hex a dec i mal so they can
; be in stalled in three con stants, for ex am ple:
; 1,000,000 = 0x0f4240 = one sec ond at 4MHz
; 500,000 = 0x07a120 = one-half sec ond at 4MHz
; 10,000 = 0x002710 = one-tenth sec ond at 4MHz
; Val ues for one-half sec ond in stalled in con stants
; as fol lows:
; 500,000 = 0x07 0xa1 0x20
; ---- ---- ----
; | | |___ lowCnt
; | |________ midCnt
; |_____________ highCnt
;
#de fine highCnt 0x07
#de fine midCnt 0xa1
#de fine lowCnt 0x20
; Con stants can be ed ited for dif fer ent de lays
;=====================================================
; vari ables in PIC RAM
;=====================================================
; Lo cal vari ables
cblock 0x00 ; Start of block
218 Chapter 9
; 3-byte aux il iary coun ter for de lay.

countH ; High-or der byte
countM ; Me dium-or der byte
countL ; Low-or der byte
endc

errorlevel -302
;
;============================================================
; pro gram
;============================================================
goto main
;=============================
;=============================
retfie
retfie
;============================================================
;============================================================
main:
movlb 0 ; Bank 0
movlw B'00000000' ; 0 = out put
;==============================
; 8-bit mode
;==============================
; Prescaler is as signed to Timer0 and initialzed
; to 2:1 rate

; |------------- On/Off con trol
; ||------------ 8/16 bit mode se lect
; || 1 = 8-bit mode
; |||----------- Clock source
; ||||| 0 = prescaler as signed
; |||||||| 1:2 rate
movlw b'11010000'
movwf T0CON
; Clear reg is ters
clrf TMR0L
;============================
; dis play loop
;============================
mloop:
; Turn on LED
bsf PORTC,0
; Ini tial ize coun ters and de lay
call setVars
call TM0delay
; Turn off LED
bcf PORTC,0
; Re-ini tial ize coun ter and de lay
call setVars
call TM0delay
goto mloop
;==================================
; vari able-lapse de lay pro ce dure
; us ing Timer0
;==================================
; ON ENTRY:
; Vari ables countL, countM, and countH hold
; the low-, mid dle-, and high-or der bytes
; of the de lay pe riod, in timer units
; Rou tine logic:
; The prescaler is as signed to timer0 and setup so
; that the timer runs at 1:2 rate. This means that
; ev ery time the coun ter reaches 128 (0x80) a to tal
; of 256 ma chine cy cles have elapsed. The value 0x80
; is de tected by test ing bit 7 of the coun ter
; reg is ter.
TM0delay:
; Note:
; The TMR0L reg is ter pro vides the low-or der level
; of the count. Because the coun ter counts up from zero,
; code must pre-in stall a value in the coun ter reg is ter
; that rep re sents the one-half the num ber of timer
; it er a tions (pre-scaler is in 1:2 mode) re quired to
; reach a count of 128. For ex am ple: if the value in
; the low coun ter vari able is 140
; then 140/2 = 70. 128 - 70 = 58
; In other words, when the timer coun ter reaches 128,
; 70 * 2 (140) timer beats would have elapsed.
; For mula:
; Value in TMR0L = 128 - (x/2)
; where x is the num ber of it er a tions in the low-level
; coun ter vari able
; First cal cu late xx/2 by bit shift ing
rrncf countL,f ; Di vide by 2
; now sub tract 128 - (x/2)
movlw d'128'
; Clear the bor row bit (mapped to Carry bit)
bcf STATUS,C
subfwb countL,w
; Now w has ad justed re sult. Store in TMR0L
movwf TMR0L
; Rou tine tests timer over flow by test ing bit 7 of
; the TMR0L reg is ter.
cy cle:
btfss TMR0L,7 ; Is bit 7 set?
goto cy cle ; Wait if not set
; At this point TMR0 bit 7 is set
; Clear the bit
bcf TMR0L,7 ; All other bits are pre served
220 Chapter 9
; mid-or der byte

decfsz countM,f
goto cy cle ; Con tinue if mid-byte not zero
decfsz countH,f
goto cy cle
; At this point the time cy cle has elapsed
re turn
;==============================
;==============================
setVars:
movwf countH
movlw midCnt
movwf countM
movlw lowCnt
movwf countL
re turn
end
9.7.4 Timer0_VarInt Program
; File name: Timer0_VarInt.asm

; No copy right
;
;
; De scrip tion:
; Us ing timer0 to pro duce an in ter rupt-driven vari able
; lapse de lay. The de lay is cal cu lated based on the
; num ber of ma chine cy cles nec es sary for the de sired
; wait pe riod as in the pro gram Timer0_VariLapse.asm.
; The rou tine uses Timer0 in 8-bit mode.
;
;=========================================================
;=========================================================
; ==========================================================
;===========================================================
;
;=====================================================
; timer con stant def i ni tions
;=====================================================
; Three timer con stants are de fined in or der to im ple ment

; a given de lay. For ex am ple, a de lay of one-half sec ond
; in a 4MHz ma chine, re quires a count of 500,000, while
; a de lay of one-tenth sec ond re quires a count of 10,000.
; These num bers are con verted to hex a dec i mal so they can
; be in stalled in three con stants, for ex am ple:
; 1,000,000 = 0x0f4240 = one sec ond at 4MHz
; 500,000 = 0x07a120 = one-half sec ond at 4MHz
; 10,000 = 0x002710 = one-tenth sec ond at 4MHz
; Val ues for one-half sec ond in stalled in con stants
; as fol lows:
; 500,000 = 0x07 0xa1 0x20
; ---- ---- ----
; | | |___ lowCnt
; | |________ midCnt
; |_____________ highCnt
;
#de fine highCnt 0x07
#de fine midCnt 0xa1
#de fine lowCnt 0x20
; Con stants can be ed ited for dif fer ent de lays
;=====================================================
; vari ables in PIC RAM
;=====================================================
; Lo cal vari ables
cblock 0x00 ; Start of block
; 3-byte aux il iary coun ter for de lay.
countH ; High-or der byte
countM ; Me dium-or der byte
countL ; Low-or der byte
endc

errorlevel -302
;
;============================================================
; pro gram
;============================================================
goto main
;=============================
;=============================
goto IntServ
;
retfie
;============================================================
;============================================================
main:
movlb 0 ; Bank 0
movlw B'00000000' ; 0 = out put
movwf TRISC ; Port C tris reg is ter
movwf PORTC
;==============================
222 Chapter 9

; 8-bit mode
;==============================
bcf INTCON,TMR0IE
; |------------- On/Off con trol
; ||------------ 8/16 bit mode se lect
; || 1 = 8-bit mode
; |||----------- Clock source
; |||||||| 1:2 rate
movlw b'11011000'
movwf T0CON
; Clear reg is ters
clrf TMR0L
;===============================
; Set up for Timer0 interupt
;===============================
; Dis able in ter rupt pri or ity lev els in the RCON reg is ter
; set ting up the mid range com pat i bil ity mode
bsf RCON,IPEN ; En able in ter rupt pri or i ties
; INTCON reg is ter in i tial ized as fol lows:
; (IPEN bit is clear)
; |------------ high-pri or ity in ter rupts
; ||----------- low-pri or ity pe riph eral
; |||---------- timer0 over flow in ter rupt
; ||||--------- ex ter nal in ter rupt
; |||||-------- port change in ter rupt
; ||||||------- over flow in ter rupt flag
; |||||||------ ex ter nal in ter rupt flag
; ||||||||----- RB4:RB7 in ter rupt flag
movlw b'10100000'
movwf INTCON
; Set INTCON2 for fall ing edge op er a tion
bcf INTCON2,INTEDG0
; Re-en able timer0 in ter rupt
bsf INTCON,TMR0IE ; Ac ti vate Timer0 in ter rupt
bcf INTCON,TMR0IF ; Clear in ter rupt flag
;============================
; dis play loop
;============================
; Re-ini tial ize coun ter and de lay
; call setDelay
movlw b'00000001'
movwf PORTC
call setDelay
mloop:
nop
goto mloop
;==============================
;==============================

setDelay:
movwf countH
movlw midCnt
movwf countM
movlw lowCnt
movwf countL
; The timer0 reg is ter pro vides the low-or der level
; of the count. Because the coun ter counts up from zero,
; in or der to en sure that the ini tial low-level de lay
; count is cor rect the value 256 - xx must be cal cu lated
; where xx is the value in the orig i nal countL reg is ter.
movf countL,w ; w holds low-or der byte
sublw .255
; Now w has ad justed re sult. Store in TMR0
movwf TMR0L
re turn
re turn
;=======================================================
; In ter rupt Ser vice Rou tine
;=======================================================
; This is a high-pri or ity in ter rupt so crit i cal reg is ters
; are saved and re store au to mat i cally
; Ser vice rou tine re ceives con trol when the timer
; reg is ter TMR0 over flows, that is, when 256 timer beats
; have elapsed
IntServ:
; First test if source is a timer0 in ter rupt
btfss INTCON,TMR0IF ; T0IF is timer0 in ter rupt
goto notTOIF ; Go if not RB0 or i gin
; If so clear the timer in ter rupt flag so that count con tin ues
bcf INTCON,TMR0IF ; Clear in ter rupt flag
;=========================
; in ter rupt ac tion
;=========================
; mid-or der byte
decfsz countM,f
goto exitISR ; Con tinue if mid-byte not zero
decfsz countH,f
goto exitISR
; At this point count has ex pired so the pro grammed time
; has elapsed. Ser vice rou tine turns the LED on line 0,
; port B on and off at ev ery con clu sion of the count.
; This is done by XORing a mask with a one-bit at the
; port C line 0 po si tion
movlw b'00000001' ; Xoring with a 1-bit pro duces
; the com ple ment
xorwf PORTC,f ; Com ple ment bit 0, port C
; Re set de lay con stants
call setDelay
;=========================
; exit ISR
;=========================
224 Chapter 9
exitISR:
notTOIF:
retfie 0x01
end ; END OF PROGRAM
9.7.5 C_Timer_Show Program
// Pro ject name: C_Timer_Show

// Source files: C_Timer_Show.c
// Date: Jan u ary 17, 2013
// Pro ces sor: PIC 18F452

// En vi ron ment: MPLAB IDE Ver sion 8.86
// MPLAB C-18 Com piler
//
// TEST CIRCUIT: Demo Board 18F452A or cir cuit wired as
// fol lows:
// PORT PINS DIRECTION DEVICE
// C 0-3 Out put Green LEDs
// C 4-7 Out put Red LEDs
//
// De scrip tion:
// A dem on stra tion pro gram to dis play the low-or der byte of
// the timer reg is ter on the LEDs wired to PORT C.
//
// INCLUDED CODE
#in clude <p18f452.h>
#in clude <tim ers.h>
#pragma config WDT = OFF

#pragma config OSC = HS
#pragma config LVP = OFF
#pragma config DEBUG = OFF
// Pro to type
void TimerDelay (un signed int);
/***********************************************************
main pro gram
************************************************************/
void main(void)
{
un signed char timerVar = 0;
/* Initalize di rec tion reg is ters */
TRISC = 0;
PORTC = 0;
/* Con fig ure Timer0 to no in ter rupts, 16-bit data,
in ter nal clock source and 1:1 prescaler */
OpenTimer0(
TIMER_INT_OFF &
T0_16BIT &
T0_SOURCE_INT &
T0_PS_1_1 );
while(1) {
TimerDelay(40000);
PORTC = timerVar;
timerVar++;
}
}
void TimerDelay (un signed int pe riod) {

un signed int timerCnt = 0;
// Re set the timer
WriteTimer0(0x0);
while (timerCnt < pe riod) {
timerCnt = ReadTimer0();
}
re turn;
}

04 Delays, Counters, and Timers

Uploaded by

Copyright:

Available Formats

04 Delays, Counters, and Timers

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

04 Delays, Counters, and Timers

Uploaded by

Copyright:

Available Formats

Delays, Counters, and Timers

9.1 PIC18 Family Timers

9.2 Delay Timers

9.2.1 Power-Up Timer (PWRT)

PWRT = ON Power-up timer en abled

9.2.2 Oscillator Start-Up Timer (OST)

9.2.3 Phase Locked Loop (PLL)

#pragma config OSC = HSPLL

Power-Up Delay Summary

9.2.4 Watchdog Timer

Watchdog Timer Uses

9.3 Hardware Timer-Counters

9.4 Timer0 Module

bit 7 TMR0ON: Timer0 On/Off Control bit

Figure 9.1 Timer0 control register (T0CON) bitmap.

Figure 9.2 Timer0 module bitmap.

9.4.1 Timer0 Architecture

16-bit Mode Operation

Timer and Counter Modes

External Clock Source

9.4.2 Timer0 as a Delay Timer

Long Delay Loops

Delay Accuracy Issues

9.4.3 Counter and Timer Programming

; RA4/TOCKI) adds one to the value in the TMR0L reg is ter.

A Timer/Counter Test Circuit

Timer0 _Delay.asm Program

; Setup the T0CON reg is ter

The routine itself can be implemented to varying degrees of sophistication re-

For example, a processor equipped with a 4-MHz clock executes at a rate of

1,000,000 = 0x0f4240 = one sec ond at 4MHz

500,000 = 0x07 0xa1 0x20

The actual delay routine is a variation of the Black-Ammerman method described

Value in TMR0L = 128 - (x/2)

where x is the number of iterations in the low-level counter variable.

; Clear the bor row bit (mapped to Carry bit)

As in the program Timer0_VarDelay developed previously in this chapter, the

; 500,000 = 0x07 0xa1 0x20

; At this point count has ex pired so the pro grammed time

The interrupt-based timer program named Timer0_VarInt can be tested either on

9.5 Other Timer Modules

9.5.1 Timer1 Module

Timer1 can operate in one of three modes:

RD16 - T1CKPS1 T1CKPS2 T1OSCEN T1SYNC TMR1CS TMR1ON

bit 7 Rd16: 16-bit Read/Write Mode Enable bit

Figure 9.3 Timer1 control register (T1CON) bitmap.

Timer1 in Timer Mode

Timer1 in Synchronized Counter Mode

External Clock Input Timing in Synchronized Mode

Timer1 Read and Write Operations

16-bit Mode Timer1 Write

Figure 9.4 Timer1 block diagram.

; Writ ing a 16-bit timer

9.5.2 Timer2 Module

Sets flag bit

Figure 9.5 Timer2 block diagram.

- TOUTPS3 TOUTPS2 TOUTPS1 TOUTPS0 TMR2ON T2CKPS1 T2CKPS0

bit 7 Unimplemented (reads as 0)