AVRFreaks.net

...
  uint8_t sreg_save = SREG;
  cli();
  ...
  SREG = sreg_save;

   // Other General Macros:
   #define ATOMIC_BLOCK(exitmode)   { exitmode cli();
   #define END_ATOMIC_BLOCK         }
   
   #define ATOMIC_RESTORESTATE      inline void __irestore(const uint8_t *s) { SREG = *s; }         \
                                    const uint8_t __isave __attribute__((__cleanup__(__irestore))) = SREG;
   #define ATOMIC_ASSUMEON          inline void __irestore(const uint8_t *s) { sei(); (void)s; }     \
                                    const uint8_t __isave __attribute__((__cleanup__(__irestore))) = 0;

   ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
   {
       // Code here
   }   
   END_ATOMIC_BLOCK

{
ATOMIC_BLOCK;

// Code here
}

while (SomeFlag)
{
   portENTER_CRITICAL();
   SomeAtomicCriticalAction();
   if (SomeOtherFlag)
     break;
   portEXIT_CRITICAL();
}

#define CRITICAL_BLOCK(x) do \
{ \
   unsigned char _tmp_sreg = SREG; \
   cli(); \
   { \
      x \
   } \
   SREG = _tmp_sreg; \
}while(0);

CRITICAL_BLOCK(
   //insert code here
)

while (SomeFlag)
{
   CRITICAL_BLOCK(
      SomeAtomicCriticalAction();
      if (SomeOtherFlag)
        break; // This line will break things!  (no pun intended)
   )
}

void
some_function(void)
{
  // Interrupts in original state
 
  CLI_BLOCK
  {
     // Ints disabled

     SEI_BLOCK
     {
        // Enabled
     }

     // Disabled again
  }

  // Original state
}

static inline uint8_t global_int_disable( void ){ cli(); return 1; }
static inline uint8_t global_int_enable( void ){ sei(); return 1; }
static inline void sreg_restore(uint8_t *sreg_save) { SREG = *sreg_save; }

#define CLI_BLOCK \
for ( uint8_t sreg_save __attribute__((__cleanup__(sreg_restore))) = SREG, \
      ints_off = global_int_disable() ; ints_off ; ints_off = 0 )

#define SEI_BLOCK \
for ( uint8_t sreg_save __attribute__((__cleanup__(sreg_restore))) = SREG, \
      ints_on = global_int_enable() ; ints_on ; ints_on = 0 )

void
some_function(void)
{
  CLI_BLOCK
  {
    // ...
  }
  sei();
  // ...
  cli();
  // ...
}

struct message
{
  struct message * next;
  struct message * prev;

  void (* func)( struct message * );
};
typedef struct message message_t;

struct timer_message
{
  message_t  node;       // base message with callback function
  uint32_t   delay;      // time to wait in milliseconds
};
typedef struct timer_message timer_message_t;


// Timer queue anchor. Also used as a sentinel when walking the list.
static
timer_message_t timer_queue = { .node  = { .next = &timer_queue.node,
                                           .prev = &timer_queue.node,
                                           .func = NULL },
                                .delay = TIMER_MAX_VALUE
};



static
void
timer_queue_insert( timer_message_t * tm )   // Single message only!
{
   // Atomically check if new delay should precede the head.
  CLI_BLOCK
    {       
      // Queue walk pointer.
      timer_message_t * next = (timer_message_t *) timer_queue.node.next;
     
      if ( tm->delay > next->delay )
        {
          tm->delay -= next->delay;
          next = (timer_message_t *) next->node.next;

          SEI_BLOCK
            {
              // Continue searching an insertion place for the new delay.
              while ( tm->delay > next->delay )
                {
                  tm->delay -= next->delay;
                  next = (timer_message_t *) next->node.next;
                }
            }
        }

      // Insert new delay before next.
      queue_insert( &tm->node, &next->node );

      // Adjust the delay following new timer, except if it's the sentinel.
      if ( next != &timer_queue )
        next->delay -= tm->delay;
    }
}

static
void
timer_queue_insert( timer_message_t * tm )   // Single message only!
{
  // Queue walk pointer.
  timer_message_t * next;

  // Atomically check if new delay should precede the head.
  CLI_BLOCK
    {       
      next = (timer_message_t *) timer_queue.node.next;
     
      if ( tm->delay > next->delay )
        {
          tm->delay -= next->delay;
          next = (timer_message_t *) next->node.next;
        }
    }

  // Continue searching an insertion place for the new delay.
  while ( tm->delay > next->delay )
    {
      tm->delay -= next->delay;
      next = (timer_message_t *) next->node.next;
    }

  // Atomically update the queue
  CLI_BLOCK
    {       
      // Insert new delay before next.
      queue_insert( &tm->node, &next->node );

      // Adjust the delay following new timer, except if it's the sentinel.
      if ( next != &timer_queue )
        next->delay -= tm->delay;
    }
}

while (SomeFlag)
{
   portENTER_CRITICAL();
   SomeAtomicCriticalAction();
   if (SomeOtherFlag)
     break;
   portEXIT_CRITICAL();
}

while (SomeFlag)
{
   portENTER_CRITICAL();
   {
      SomeAtomicCriticalAction();
   }
   portEXIT_CRITICAL();
   if (SomeOtherFlag)
     break;
}

portENTER_CRITICAL();
{   
   while (SomeFlag)
   {
      SomeAtomicCriticalAction();
      if (SomeOtherFlag)
         break;
   }
}
portEXIT_CRITICAL();

   #define ATOMIC_BLOCK(exitmode)   do { exitmode cli();
   #define END_ATOMIC_BLOCK         } while (0);

#ifndef READ_ATOMIC_DOCS
  #error Please read the atomic section of the AVRLIBC documentation before using this header file.
#endif