Deklaration von Variablen (volatile) bei Manipulation in ISR

[Frank (Gast)]

N'Abend zusammen!

Ich wollte mal eine simple Frage loswerden:

Ich habe eine .c und eine .h für das Einlesen eines ADCs geschrieben.
Die .c beeinhaltet ein struct, welches verschiedene Variablen für die 
Kommunikation und auch z.B. das ADC-Ergebnis beeinhaltet. Zugriff auf 
die Variablen erfolgt durch Funktionen, welche in der .h deklariert 
sind.

Also z.B. "ergebnis = hole_adc_regebnis();"

Die State-Machine für das holen der Daten ist ebenfalls in der .c 
enthalten und wird über die ISR des Empfangsmoduls gesteuert.

Die Frage ist jetzt, ob ich alle Variablen, die während der Ausführung 
der State-Machine durch die ISR als volatile deklarieren muss.

Falls das unklar ist, nochmal anders:

#include "adc_funktionen.h"
...
uint16_t ergebnis;
...
main
{
  ...
  ergebnis = hole_adc_ergebnis();
  ...
}

ISR
{
  statemachine();
}

Die.h-Datei:

adc_funktionen.h
...
void statemachine( void );

Die .c-Datei:

#include "adc_funkctione.h"
...
struct adc
{
  uint16_t neues_ergebis;
  ...
}

struct adc adc_daten;

...

void statemachine( void )
{
  ...
  adc_daten.neues_ergebnis = Schieberegisterinhalt;
  ...
}

Muss die Variable, welche jetzt in der Funktion statemachine(), welche 
widerum durch die ISR aufgerufen wird, als volatile deklariert werden?

Gruß & danke!

[Oliver J. (skriptkiddy)]

Interrupt: Volatile Variablen

Gruß Oliver

[Stefan F. (sfrings)]

Ja, muss sein.

Zugriff auf Variablen ist nicht Thread Safe, es se denn, sie sind als 
"volatile" deklariert.

Alle Variablen, die Du sowohl in der ISR als auch im Hauptprogramm 
verwendest, verwendest Du in zwei Threads. Wenn Du sie nicht als 
volatile deklarierst, riskierst Du, dass der Optimizer zu viel 
optimiert. Beispiel:

int i=0;

ISR {
  i++;
}

main {
  while (1) {
    if (i>12) { 
      tuwas;
    }
  }
}

Während die ISR bei irgendeinem Ereignis die Variable i um eins erhöht, 
testes das Hauptprogramm in einer Endlos-Schleife, ob i>12 ist und macht 
dann irgend etwas. Ohne volatile könnte der Optimizer folgenden Code 
generieren:

ISR {
  Kopiere Variable i in Register R1 und R2
  Erhöhe Register R1 um eins
  Erhöhe Register R2 um eins, wenn R1 übergelaufen ist
  Kopiere Register R1 und R2 in Variable i
}

main {
  Kopiere Variable i in Register R3 und R4
  :marke
  Wenn R3 > 12 oder R4 > 0, dann tuwas
  Springe zu :marke
}

Variablem werden manchmal in Register kopiert, weil der bestimmte 
Operationen in Registern schneller sind. Manche Operationen können auch 
nur mit Registern durchgeführt werden.

Lass uns mal einfach annehmen, dass bei Deinem Prozessor ein direkter 
Vergleich zwischen einer Variablen (also RAM) und einer Konstanten nicht 
geht. Aber der Prozessor kann ein Register mit einer Konstanten 
vergleichen.

Schau Dir den obigen Pseudo-Code an. Wenn die ISR zwölf mal ausgeführt 
wurde, dann hat die Variable i den Wert 12. Aber das Register R3/R4 hat 
immer noch den Wert 0, die main Funktion wird also niemals das tun, was 
sie sollte.

Der Optimizier geht von einem Single-Threaded Programm aus. Er geht 
davon aus, dass Funktionen niemals untrbrochen werden. Deswegen erzeugt 
er (wenn Du Pech hast) nicht funktionierenden Maschinen-Code. Durch die 
"volatile" Deklaration sagst Du dem Optimizer, dass er diese Variable 
ganz besonders vorsichtig behandeln muss, weil sie jederzeit verändert 
werden kann, auch an Stellen, wo der Optimizier es nicht erwartet. Mit 
"volatile" würde der Pseudo-Code so aussehen:

ISR {
  Sperre andere Interrupts
  Kopiere Variable i in Register R1 und R2
  Erhöhe Register R1 um eins
  Erhöhe Register R2 um eins, wenn R1 übergelaufen ist
  Kopiere Register R1 und R2 in Variable i
  Erlaube andere Interrupts
}

main {
  :marke
  Sperre alle Interrupts
  Kopiere Variable i in Register R3 und R4
  Erlaube alle Interrupts
  Wenn R2 > 12 oder R4 > 0, dann tuwas
  Springe zu :marke
}

Das Sperren anderer Interruptsin der ISR kann entfallen, wenn der 
Mikrocontroller konstruktions-bedingt nur einen Interrupt-Level kennt 
(also Interrupts nicht wiederum durch andere unterbrochen werden 
können).

Im Hauptprogramm dient das Sperren der Interrupts nun dazu, zu 
verhindern, dass die beiden Bytes der int Variable sich verändern, 
während sie in die Register R3 und R4 kopiert werden. Weiterhin wird die 
Variable nun bei jedem Schleifendurchlauf erneut in die Register 
kopiert, so dass R3 jetzt tatsächlich irgendwann auch mal den Wert 12 
enthalten kann.