Delay function using timer/counter 1

Question

i have made a function called _MY_Delay() which use 16bit timer/counter1 in ATMEGA16 , and used this function to blink a LED . the problem is i didn't work and i don't know the reason , here is my code :

 #define  F_CPU 1000000
 #include <avr/io.h>
 #include <avr/interrupt.h>

 void _MY_Delay(int delay){
 int n = (delay*F_CPU)/(1000*64) ; // number of counts required for the given delay 
 OCR1BL = n;                    // n =T(overflow time)*F_cpu / 64
 OCR1BH = n >> 8 ;
 while (!(TIFR & 1<<OCF1B));
 }


 int main(void)
 {
 DDRA = 0x00;
 DDRA |= 0x01;
 TCCR1B = (1<<CS10)|(1<<CS11); //divide by 64 (prescaler)
 sei();
 TIMSK |= 1<< OCIE1B ;
 WDTCR = 0x00; // disable watchdog timer 
 while(1)
 {
    PORTA |= 0x01 ;
    _MY_Delay(100);
    PORTA &= ~(0x01);
    _MY_Delay(100);
 }
 }

Answer 1

The primary problem is with your arithmetic.

The argument to _MY_Delay() is declared as int, and you're passing in the value 100.

The first thing you do is divide the argument by 1000. The result of this division will always be zero.

You'll get more useful results if you do the multiplication first:

void _MY_Delay(int delay){
  int n = (delay*F_CPU)/1000; // number of counts required for the given delay 
  ...
}

... but make sure that the intermediate result won't overflow an integer. If so, use a long.

Answer 2

The problem with your current code is that you enable the timer1 output compare B interrupt while you don't use an interrupt handler, this leads to a reset of the mcu.

Remove the following line from your code and it will work

TIMSK |= 1<< OCIE1B ; // enables timer1 output compare B interrupt

Regarding your delay function, since you don't use an interrupt and the execution waits for the timer to finish, you may as well use the _delay() function of the delay library with the same results (unless you just want to experiment with timers).

#include <util/delay.h>

void my_delay_ms(uint16_t n) {
 while(n--) {    // loop until 0
  _delay_ms(1);  // 1ms delay
 }
}

It uses a 16bit variable so you can use it for delays up to 65535ms (65.5 sec) (you can use an 8bit variable for delays up to 255ms if you wish). There is a small overhead in the delay caused by the loop, but if you are interested in accurate delays then you should use a timer interrupt anyway.

As an example, for 0.5sec delay you call it as my_delay_ms(500)

Answer 3

I'm not familiar with the CPU so cannot speak to the register usage. However, this line: PORTA |= 0x00; is not the way to turn a bit off rather use: PORTA &= ~(0x01);

As a side note: The C compiler(s) prepend one or two underscores on any names so there can be confusion in the compiler with names that already have a leading underscore

the document at: <http://www.atmel.com/images/doc2466.pdf>
contains the details of the chip and the register names and bit
definitions and the details of how to access those registers in C

amongst other things, the section titled "accessing 16-bit registers"  it states
"To do a 16-bit write, the high byte must be written before the low byte."
however the posted code is performing the 16-bit write in the opposite order, I.E. junk is being written to the high byte of the 16-bit register