Introduction to AVR Timers
Timers are used everywhere. Without timers, you would end up nowhere! The range of timers vary from a few microseconds (like the ticks of a processor) to many hours (like the lecture classes ), and AVR is suitable for the whole range! AVR boasts of having a very accurate timer, accurate to the resolution of microseconds! This feature makes them suitable for timer applications. Let’s see how.
You come across timers everyday. Simplest example hangs on your wall or maybe tied around your wrist. You can say that they have a unique property to measure time. Everything in this world is synchronized with time. You wake up at, say, 6 o’clock; you work everyday for 8 hours; you need to drink water every 4 hours, etc. But the concept of timers isn’t confined to your daily routines. Every electronic component works on a time base. This time base helps to keep all the work synchronized. Without a time base, you would have no idea as to when to do a particular thing.
Thus, timers is an important concept in the field of electronics. You can generate a time base using a timer circuit, using a microcontroller, etc. Since all the microcontrollers work at some predefined clock frequency, they all have a provision to set up timers.
AVR boasts of having a timer which is very accurate, precise and reliable. It offers loads of features in it, thus making it a vast topic. In this tutorial, we will discuss the basic concepts of AVR Timers. We will not be dealing with any code in this tutorial, just the concepts. The procedure of generating timers and their codes will be discussed in subsequent posts.
Timers as registers
So basically, a timer is a register! But not a normal one. The value of this register increases/decreases automatically. In AVR, timers are of two types: 8-bit and 16-bit timers. In an 8-bit timer, the register used is 8-bit wide whereas in 16-bit timer, the register width is of 16 bits. This means that the 8-bit timer is capable of counting 2^8=256 steps from 0 to 255 as demonstrated below.
Similarly a 16 bit timer is capable of counting 2^16=65536 steps from 0 to 65535. Due to this feature, timers are also known as counters. Now what happens once they reach their MAX? Does the program stop executing? Well, the answer is quite simple. It returns to its initial value of zero. We say that the timer/counter overflows.
In ATMEGA32, we have three different kinds of timers:
The best part is that the timer is totally independent of the CPU. Thus, it runs parallel to the CPU and there is no CPU’s intervention, which makes the timer quite accurate.
Apart from normal operation, these three timers can be either operated in normal mode, CTC mode or PWM mode. We will discuss them one by one.
Since childhood, we have been coming across the following formula:
Now suppose, we need to flash an LED every 10 ms. This implies that its frequency is 1/10ms = 100 Hz. Now let’s assume that we have an external crystal XTAL of 4 MHz. Hence, the CPU clock frequency is 4 MHz. Now, as I said that the timer counts from 0 to TOP. For an 8-bit timer, it counts from 0 to 255 whereas for a 16-bit timer it counts from 0 to 65535. After that, they overflow. This value changes at every clock pulse.
Let’s say the timer’s value is zero now. To go from 0 to 1, it takes one clock pulse. To go from 1 to 2, it takes another clock pulse. To go from 2 to 3, it takes one more clock pulse. And so on. For F_CPU = 4 MHz, time period T = 1/4M = 0.00025 ms. Thus for every transition (0 to 1, 1 to 2, etc), it takes only 0.00025 ms!
Now, as stated above, we need a delay of 10 ms. This maybe a very short delay, but for the microcontroller which has a resolution of 0.00025 ms, its quite a long delay! To get an idea of how long it takes, let’s calculate the timer count from the following formula:
Substitute Required Delay = 10 ms and Clock Time Period = 0.00025 ms, and you get Timer Count = 39999. Can you imagine that? The clock has already ticked 39999 times to give a delay of only 10 ms!
Now, to achieve this, we definitely cannot use an 8-bit timer (as it has an upper limit of 255, after which it overflows). Hence, we use a 16-bit timer (which is capable of counting up to 65535) to achieve this delay.
Assuming F_CPU = 4 MHz and a 16-bit timer (MAX = 65535), and substituting in the above formula, we can get a maximum delay of 16.384 ms. Now what if we need a greater delay, say 20 ms? We are stuck?!
Well hopefully, there lies a solution to this. Suppose if we decrease the F_CPU from 4 MHz to 0.5 MHz (i.e. 500 kHz), then the clock time period increases to 1/500k = 0.002 ms. Now if we substitute Required Delay = 20 ms and Clock Time Period = 0.002 ms, we get Timer Count = 9999. As we can see, this can easily be achieved using a 16-bit timer. At this frequency, a maximum delay of 131.072 ms can be achieved.
Now, the question is how do we actually reduce the frequency? This technique of frequency division is called prescaling. We do not reduce the actual F_CPU. The actual F_CPU remains the same (at 4 MHz in this case). So basically, we derive a frequency from it to run the timer. Thus, while doing so, we divide the frequency and use it. There is a provision to do so in AVR by setting some bits which we will discuss later.
But don’t think that you can use prescaler freely. It comes at a cost. There is a trade-off between resolution and duration. As you must have seen above, the overall duration of measurement has increased from a mere 16.384 ms to 131.072 ms. So has the resolution. The resolution has also increased from 0.00025 ms to 0.002 ms (technically the resolution has actually decreased). This means each tick will take 0.002 ms. So, what’s the problem with this? The problem is that the accuracy has decreased. Earlier, you were able to measure duration like 0.1125 ms accurately (0.1125/0.00025 = 450), but now you cannot (0.1125/0.002 = 56.25). The new timer can measure 0.112 ms and then 0.114 ms. No other value in between.
Let’s take an example. We need a delay of 184 ms (I have chosen any random number). We have F_CPU = 4 MHz. The AVR offers us the following prescaler values to choose from: 8, 64, 256 and 1024. A prescaler of 8 means the effective clock frequency will be F_CPU/8. Now substituting each of these values into the above formula, we get different values of timer value. The results are summarized as below:
Now out of these four prescalers, 8 cannot be used as the timer value exceeds the limit of 65535. Also, since the timer always takes up integer values, we cannot choose 1024 as the timer count is a decimal digit. Hence, we see that prescaler values of 64 and 256 are feasible. But out of these two, we choose 64 as it provides us with greater resolution. We can choose 256 if we need the timer for a greater duration elsewhere.
Thus, we always choose prescaler which gives the counter value within the feasible limit (255 or 65535) and the counter value should always be an integer.
We will discuss how to implement it in later posts.
Well, this is not exclusively related to timers, but I thought of discussing it as it is used in a variety of places. Let me explain it using an analogy. Say now you are reading my post. It’s dinner time and your mom (only if you live with your mom ;)) calls you for dinner. What do you do (if she gets too creepy)? You save your work and attend to your mom’s call, then return and resume reading. This is an example of interrupt.
In most microcontrollers, there is something called interrupt. This interrupt can be fired whenever certain conditions are met. Now whenever an interrupt is fired, the AVR stops and saves its execution of the main routine, attends to the interrupt call (by executing a special routine, called the Interrupt Service Routine, ISR) and once it is done with it, returns to the main routine and continues executing it.
For example, in the condition of counter overflow, we can set up a bit to fire an interrupt whenever an overflow occurs. Now, during execution of the program, whenever an overflow occurs, an interrupt is fired and the CPU attends to the corresponding ISR. Now it’s up to us what do we want to do inside the ISR. We can toggle the value of a pin, or increment a counter, etc etc.
If you didn’t get the concept of interrupts and ISR, behold for sometime till we discuss it how to implement it in hardware.
So folks, I guess this much is enough for you to get a hold of what timers are and the features of AVR Timers. From the next post, we will implement these concepts and learn how to code the AVR!
So grab the RSS feeds or subscribe to my blog to stay updated! And don’t forget to post your response down below!
Can i have an accuracy of 1 millisecond for measuring time in atmega2560 (16MHz freq)?
What should be the prescalar for 8/16 bit timer?
Nice way to explain it. Spent months trying to understand what timer in AVR really mean. Thanks
I know what is timer and other stuff, but the way you dfine it, it made me learn again, thanks
If u Want to understand TCNT and Over flow concept Try these code in C compiler it will help you a lot visonary …………………………
volatile int TCNT0=0;
volatile int Overflow=0;
printf(“\t\t\t\t\tEnter the Time :”);
// while (Count1 ==200)
printf(“\n STOP “);
printf(“\n Overflow Reached “);
Why you need to fire an interrupt when counter overflows?Anyway the counter will start from zero!
This is a Awesome Explanation of Pre-scaler.
Please Suggest me if I want 30 Minute Delay
then what can do for that?
Hi Mayank thank u for your wonderfull Tutorial For Embedded platform clear and indepth explanation. i undertsood timer concept by this tutorial, i have task using ” input capture method” on arduino uno avr uc please do help me, iam trying to measuring the freq from square wave signal(signal can be connected from function generator to the arduino ). iam getting confusion during rising edge and falling edge how the timers are incremented how can we calculate the freq by using input capture method please share any links with clear explanations else is there any other method to measure freq for sqaure wave(if i generated square wave with 15kHz from function generator it should print same freq on serial terminal)…
Mayank pls give the conclusion for this i was stuck since 2 weeks
thanks and appreciate your time
Disclaimer: My own experience with the AVR family is not centred around the Arduino platform and the Uno and it’s ilk, but rather the ATTiny, which have fewer resources. As such, you get familiar with accomplishing things with those limited resources through conservation and multiplexing.
If you reduce the processor speed with a prescaler, it will run fewer instructions per second, thus allowing you less time to accomplish tasks. For many things, a reduced clock speed may be fine (for instance, it reduces power consumption, so it is a valid technique for extending battery life – it’s also necessary if you want reliable operation from lower supply voltages, and if your device is just monitoring the status of something and raising a signal for use by something else, full clock may not be needed) – for other applications, you may need all the clock speed you can get.
If you implement your own timer interrupt handler, you could run at whatever speed you want the processor to run at (within the limits of the internal oscillator or provided crystal, and the prescaler), and instead have a separate counter that you decrement, and in your main loop, when that counter is zero, you do whatever it is you want done every ‘x’ period and reset the counter (if the operation is consistently very brief, such as driving an output high or low, you could invoke it directly from the overflow counter when the count reaches 0).
Have something that overflows with a decimal remainder? You can track and adjust for that in the timer interrupt handler so that an error doesn’t creep in over multiples of interrupts. On uCs operating from an internal oscillator (i.e. no crystal), your timing is a little less precise, and if your use of the timer is to control a flashing LED or a duty cycle on something, you may not need great precision. Being a few mS off across a 10 minute cycle may not be a big deal. If you’re timing an Olympic trial, yes someone is going to raise the issue of calibration. Running a laundry cycle, probably not.
If you set up the overflow handler to some fraction of the interval you otherwise need events on, you could have an array of counters which are individually decremented during the overflow handler.
Beware setting the timer prescaler very low (especially on 8-bit counters) – you could find yourself spending most of your time servicing the overflow interrupt.
Thank you for explaining so well. Kudos!
I am not clear why -1 is there in formula of timer count.
as everything starts with 0 not 1 so after getting result you should subtract it with 1