Hello all. Back to Pilani, for one last time J Anyway, in this post, I shall be introducing the concept of Timers using ATmega32/16. So if you don’t like using those fancy delay functions that the IDEs provide or simply, want to create your own delay function, this post might be a good start.
So what are Timers?
Needless to say, Timers are those circuits in your controller that allow you to keep track of time. Any time-related activity – like the blink effect in your blinking LED, the rotation of your motor for precisely 5 seconds, those beautiful lighting patterns that you see in Diwali lightings - takes place because of timers in your controller.
Why do I need to know about Timers?
Yes, every IDE has a library that contains delay functions that you can use. But if you are a curious user, you will want to know as to what is happening when you say you want a delay of 1000ms. Or you will want to know why the function can’t give you a delay above a certain fixed value.
Yet another reason – if you want to implement Pulse Width Modulation (PWM), knowledge of timers is essential. So, it is time to ‘time’! Let us begin.
Basic Concept
First of all, you need to know that the clock of your controller may or may not be the same as that of your timer. This simply means, that the rate at which your CPU executes instructions can be different from the rate at which the timer times. Timing is done with the help of a counter register that counts up to its maximum possible value and then again goes to zero, only to repeat the entire cycle. Checking the value of this register against a particular value helps you to achieve the desired delay. The methods of timing differ in the method of checking this value, as described below.
Timers in ATmega32/16
One look at the ATmega32/16 datasheet tells that it has two 8-bit timers and one 16-bit timer. 8-bit and 16-bit refers to the size of the counter register. The counter of the 8-bit timer can count up to 255 (28 – 1) before resetting to 0 and the counter of the 16-bit timer can count up to 65535 (216 – 1) before resetting to 0.
I will be talking about the 8-bit counter named Timer/Counter0, as it is easier to work with than the 16-bit timer. First, I will explain the crude method of checking the register value with an ‘if’ condition. And second, I will explain the ‘Clear on Timer Compare’ (CTC) Mode.
Crude Method
I call this the crude method because it is the easiest method and involves no software complexity. The steps involved in timing using this method are:
1) Enable the timer
2) Decide the timer frequency
3) Decide the delay needed
4) Calculate the counter value that corresponds to the desired delay
5) Use this value in the ‘if’ condition in your program
Enable the timer
Looking at the register description for this timer/counter, on Page 80 of the datasheet, we see that the lowermost three bits of the register TCCR0 are involved in the enabling process. The table on Page 82 tells that to enable the timer, we need to write a ‘1’ to the CS00 bit of TCCR0 register. The corresponding code is:
TCCR0 |= (1<<CS00);
Decide the timer frequency, delay and calculations
As mentioned in the post, the clock of the timer and the CPU may or may not be the same. And this facility is extended to us by the presence of ‘prescaler circuits’ in the controller. These circuits enable us to scale down the CPU frequency (F_CPU) by 8, 64, 256 and 1024 times. For instance, if we are using a prescaler of 64 and F_CPU is 1MHz, then the timer will not see each period of the CPU as 1µs but as 64µs. Therefore, the increment in counter register that would have happened after 1µs will now take place after 64µs. That is, the frequency has been scaled down by 64 times. As a result, longer delays can be realized without the need of an external clock.
Suppose we wish to blink an LED at a frequency of approximately 5 Hz i.e. goes on-off at every 0.2 seconds. We have been given that F_CPU is 1MHz. We have to keep in mind that our counter can’t count above 255. With proper calculation, we see that using a prescaler of 1024 and checking the counter for a value of 199 will do the job roughly.
Calculation: 1µs * 1024 * 200 = 0.2048 seconds.
Now, you will say – “Hey! That’s not right...I need precision.” Well then, you will have to use the 16-bit timer/counter. In that case, you can use a prescaler of 8 and the counter value to be checked is 25000-1 = 24999.
Calculation: 1µs * 8 * 25000 = 0.2 seconds.
Note: The value to be checked is 1 less than the number of counts because the counter starts counting up from 0, not 1.
Code: For 8-bit timer/counter0, register involved for prescaling is TCCR0 and bits are CS02, CS01 and CS00. The table tells that writing a ‘1’ to CS02 and CS00 enable the 1024 prescaler.
TCCR0 |= ((1<<CS02)|(1<<CS00));
Using the ‘if’ condition
Now that you are done with the enabling, configuration and calculations, you need to actually implement the timing effect. This is done by checking the value of the counter against the calculated value. In the 8-bit case, the counter register is named TCNT0. The calculated value in the 8-bit case above was 199.
Code:
if(TCNT >= 199)
{
//your code here
TCNT0 = 0;
}
Observations from the above snippet:
1) Using a ‘>=’ is safer than ‘==’ as it is possible that the controller will miss the exact value due to some glitch.
2) It is necessary to reset the timer at the end of the ‘if’ condition, otherwise you will never get the desired delay (unless the value to be checked is itself 255! :P)
Assuming that the LED is connected to PORTB0 pin, the entire code using the 8-bit counter is:
#include <avr/io.h>
int main(void)
{
DDRB = 0b00000001;
TCCR0 |= ((1<<CS00)|(1<<CS02)); // enabling the timer with 1024 prescaler
// on calculation the value to be checked comes out to be 199
while(1)
{
if(TCNT0 >= 199)
{
PORTB ^= (1<<0); //toggling the status of pin – XOR bit operator in C
TCNT0 = 0;
}
}
}
The code for the 16-bit timer/counter can be made on similar lines using the registers mentioned in the datasheet.
Clear on Timer Compare (CTC) Mode
In this mode of timing, the checking of the counter value with the desired value obtained from calculations is done by the hardware instead of the software i.e. the ‘if’ condition. As a result, the time wasted in executing the piece of code is saved which can be fruitful in a complex application.
The overall funda of working remains the same except that instead of an ‘if’ condition, we store the desired counter value in a particular register and as soon as the counter obtains that value, the controller sets (writes ‘1’) a bit in a register. Hence, we just need to check the status of a bit regularly rather than compare values, which is a much heavier operation.
Registers involved
1) The CTC mode is enabled by writing a ‘1’ to the WGM01 bit in the TCCR0 register (See table on Page 80).
2) The clock frequency selection for CTC is done in the same manner as the crude method.
3) The register used to store the value against which the counter value is to be compared is OCR0. Naturally, it is an 8-bit register.
4) The bit that is set to ‘1’ when the counter reaches the value stored in OCR0 is the OCF0 bit in the TIFR register. A very important behaviour of this bit is that to reset this bit, we have to actually write a ‘1’ to it. The circuitry is such that it requires to be set to be reset.
Code:
#include <avr/io.h>
int main(void)
{
DDRB = 0b00000001;
TCCR0 |= ((1<<CS00)|(1<<CS02)); // enable the timer with a prescaler of 1024
TCCR0 |= (1<<WGM01); // enable the CTC mode
OCR0 = 199; // store 199 into OCR0
while(1)
{
if(TIFR & (1<<OCF0)) // check if bit OCF0 is set to '1'
{
PORTB ^= (1<<0); // toggle status of pin PORTB0
TIFR = (1<<OCF0); // write a '1' to OCF0 to reset it
}
}
}
Therefore, the same timing operation carried out by the Crude Method is carried out by CTC Mode operation in a much more efficient manner.
The aim of this post was to cover the basics of timers in microcontrollers and how they work. A more detailed post on timers later J
See ya!
