Electronic – Race condition in AVR timers

In general, interrupts are disabled when the processor enters an interrupt handler, and automatically re-enabled when the interrupt handler returns. (See CLI, SEI, and RETI instructions in the manual for more info).

When the external interrupt is fired, the interrupt flag INTF0 in the EIFR is set to 1. When interrupts are enabled and this bit is 1, the processor enters the interrupt handler. Inside the interrupt handler, this bit could again be set to 1, but the interrupt won't re-occur until after interrupts get re-enabled. You can also explicitly clear this bit to 0 by writing a 1 to the register. If you were inside the interrupt handler, an external event sets the bit, and you clear the bit before returning from the interrupt handler, than the interrupt will not be triggered again.

However, note that you can't actually set or clear INTF0 if you're using level-triggered interrupts -- it just matches the state of the pin at all times. If the pin is low, and interrupts are enabled, it will trigger the interrupt again. The only way to stop that is to disable interrupts (either globally, or by masking off the particular INT0 bit in EIMSK).

Others have already pointed out the original problem in the comments above, namely that you need to reserve space for the character array.

I have made a few other changes to your original code, including:

• Allocate space for the character array
• Move code out of the interrupt service routine and back into main()
• Using a global flag to communicate between the ISR and main()
• Initialising all array elements to zero
• Initialising global variables in main()

You should avoid doing any processing in the ISR, moving code out to main() accomplishes this. Using a global flag is one way of communicating from the ISR but you should be careful of race conditions between the two. Depending on your application there are a number of ways to ensure this doesn't happen.

Initialising global variables in main() means that they should be reset if your processor resets (your architecture might have special reset vectors for this).

Note that the code is untested but something along these lines might help you out.

volatile int overflow_count;
volatile char overflow_flag;

int main(void)
{
  char time[20] = { 0 };

  // Initialise global variables in case of reset
  overflow_count = 0;
  overflow_flag = 0;
  // You could memset time to NULs here also

  while(1)
  {
    if (overflow_flag) {
      // Depending on the application you may need to
      // implement some kind of mutex here, or disable
      // interrupts until you have finished.  Resetting
      // the flag as the first instruction offers the 
      // least chance you'll miss interrupts.
      overflow_flag = 0;

      sprintf(time, "overflow-%u", overflow_count);
      uart_send(time);

      if(overflow_count==2)
      {
        overflow_count=0;
        uart_array("Alarm code execution");
      }
    }
  }
}

ISR(TIMER1_OVF_vect)
{
  overflow_count++;
  overflow_flag = 1;
}