AVR Freaks

Regarding the posted code alexru wrote:

so it will almost never read 0.

this body may be bigger than that.

I think approximately the opposite happens:

With the 1,2MHz clock, the prescaler of 8 and OCRA0 = 150, the interrupt frequency is 1,2MHz/8/151 = 993Hz.

The complete while loop will only take a few clock cycles. Let's assume 11. Then there are 90 times, where timer_counter is read 0, but 499*90 times where a different value is read.

I *guess* it is is an even number, that timer_counter is read as 0. So the LED toggles 90times and stays off. But in relation to the 499*90 times you will not see it (0,1% brightness).

Another problem with the original code is uint16_t variable, which is accessed non-atomically from the main context and ISR. The interrupts should be disabled temporarily when reading timer_counter.

Thanks for your effort. I thought the while loop would be shorter. But only half of the second if/else must be executed.

However, it still can be an even number, that timer_counter was read 0 in a row.

@Aleksey_ua:

What is your target device?

Interesting thread, but I bet EVERYONE that reads 'multitasking' in the title thinks this has something to do with a real time operating system that switches tasks at a periodic rate to 'simulate' two or more tasks running simultaneously. Most microcontroller programs use the 'main loop with interrupts' model. If a task is a program executing with return addresses on a stack, then this model is just one task. A multitasker has a stack for each task.

I'm assuming this is just an example and the actual application must do more than simple LED blinking.

Instead of using a (boolean) flag, I used once an 8 bit counter each in the ISR and main context:

#include <avr/io.h>
#include <avr/interrupt.h>

#define TIM0_COMPA_DIVIDER 500

volatile int8_t SignalCounterISR;

ISR(TIM0_COMPA_vect) {

  static uint16_t timer_counter;
  timer_counter++;
  
  if (timer_counter >= TIM0_COMPA_DIVIDER)
  {
    timer_counter=0;
    SignalCounterISR++;
  }
  
}

void init() {
  ...  
  sei();
}

int main(void)
{
  int8_t SignalCounterMain = 0;
  init();
  
  while(1)
  {
    
    if (SignalCounterMain!=SignalCounterISR)
    {
      SignalCounterMain++;
      /* do a special task (for example clock) */
    }
  
    /* do other tasks, which may vary in execution time */	
  
  }
  
}

Only SignalCounterISR is shared by ISR and main context, so it must be "volatile". The read access of SignalCounterISR in the main context is an atomically operation, because it's is only 8 bit.

With this I have a kind of buffering, which keeps the timing better, if a certain task must exactly serviced a certain number of times in a given period.

If one other "task" / function needs longer than the period between two "signals" from the ISR, the signals get lost much later (after 256 times) regarding to a simple flag.

With this the task can catch up, if again more CPU time is available. (Depends on the task, if this behaviour is wanted.)