ATOMIC_BLOCK innerhalb ISR

[Karsten K. (karsten42)]

Moin Moin,

Ist der Aufruf vom Macro ATOMIC_BLOCK(ATOMIC_RESTORESTATE) transparent, 
also ohne Auswirkung wenn dieser innerhalb einer ISR aufgerufen wird?
Abgesehen davon bin ich natürlich großer Hoffnung, das die volatile 
definition innerhalb der typedef struct {} txbuf_t auch wirklich 
funktioniert :-)
Hintergrund ist der, dass die Funktion _send_message() aus auserhalb 
einer ISR aufgrufen wird.

Folgender Beispiel Code dazu:

typedef struct  {

  volatile uint8_t active;// Flag set if transmission is in progress
  can_buffer_t buffer;  // Control structure 
  can_t list[CAN_TX_BUFFER_SIZE];  // Array of can_t buffer

} txbuf_t;


ISR(INT0_vect)  {
...
// check if there are any another messages waiting 
if (buf != NULL) {

  sja_add = SJA1;
  _send_message(buf);
  can_buffer_dequeue(&txbuf[0].buffer);
    
} else {
  // buffer underflow => no more messages to send
  txbuf[0].active = 0;
}
...

uint8_t
_send_message(const can_t *msg)  {

...
   ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
     txbuf[sja_add].active = 1;
   }
...
}

Vielen Dank für konstruktive Hilfe

Beste Grüße
Karsten

[Oliver S. (oliverso)]

Da wird nichts weiter gemacht als:

uint8_t sreg = SREG;
cli();
//<Code im Block>
SREG = sreg;

Oliver

[Sascha W. (sascha-w)]

@ Karsten K.

du schreibst zwar nicht was du für einen Controller verwendest, aber bei 
den AVRs kann während der Ausführung einer ISR keine andere ISR 
ausgeführt werden, da die Interrups mit Aufruf der ISR gesperrt werden.
Ausnahme: du erlaubst die Interrupts innerhalb der ISR mit sei()

Insofern kannst du dir deinen ATOMIC_BLOCK innerhalb der ISR sparen!

Sascha

[Falk B. (falk)]

@ Sascha Weber (sascha-w)

>Insofern kannst du dir deinen ATOMIC_BLOCK innerhalb der ISR sparen!

Der Block ist in einer Funktion, nicht in einer ISR. Die Funktion kann 
sowohl vom Hauptprogram als auch aus der ISR aufgerufen werden. Was die 
Sache nochmals gefährlicher macht!