mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Volatile in ISR und main() geht nicht


Autor: Karsten K. (karsten42)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Moin Moin liebe Forumsmitglieder.

Mein erster Beitrag und damit schon mal sorry für eine vielleicht 
einfache Frage und herzlichsten Dank an diejenigen die unermüdlich Hilfe 
leisten ( Hut ab! ).

Ich möchte unter anderem ein paar multiplexer ( SN74595 ) ansteuern 
deren daten über ein globales array im Zugriff liegen. Die Multiplexer 
werden mit einem Timer (Timer 0) alle 4ms auf Stand gebracht indem eine 
funktion aufgerufen wird die auf das evtl. aktualisierte array 
zugegreift.
Die Idee ist, irgendwo im code das array zu ändern und das dann durch 
die ISR des Timers abarbeiten zu lassen.

Jetzt möchte ich aber auch das array innerhalb einer anderen ISR ( Timer 
1 ) verändern. Dazu ist dann das globale array auf volatile zu 
definieren da es innerhalb einer ISR und im main() geändert wird.

Mit
unsigned char mux[MUX_SIZE];
 global funktioniert das updaten in ISR TM1 tadellos jedoch eine 
änderung im main() bleibt unbeachtet.

Mit
volatile unsigned char mux[MUX_SIZE;
 und folgerichtig in mux_out()
volatile unsigned char *muxp = mux + MUX_SIZE;
 funktioniert das automatische updaten in main() via TM0, aber nicht 
mehr über ISR TIM1.

Ich bin da echt ratlos....
Hat jemand von euch eine Idee was hier falsch ist??

1000000000000 * 10 ^ 12 Dank für konstruktive Hilfe

Karsten
// Defines
#define MUX_SIZE   2  // Number of installed MUX ( 74LS595 )

#define REED1     2  // Multiplexer # for reed relais
#define MX_RPAON   1  // Mux OUT for reed PA on
#define MX_LPAON   4  // Mux OUT for 

#define INIT    1  // State for Power max
#define PWRMAX    2  // State for Power max

// Prototypes
void init(void);
void mux_out(void);

// Global vars
unsigned char mux[MUX_SIZE];
int8_t state = INIT;


int
main(void)  {

  init(); // initialize timer / mux ....
  sei();

  while(1)  {

     if(state == PWRON)  {

    ....
    state = PWRMAX;  // initiate blink of MX_LPAON via TIM1
    // at ISR TM1 the changed  state will update the mux array
    // at ISR TM0 the mux_out() function is calle to update the
    // multiplexer outputs.
    ....

    cli();
    mux[2] |= (1 << MX_LPAON);
    state = RUN;
    sei();
    // try atomic. Switch LPAON to off and update state. On next cycle of
    // TM1 the blink modeof MX_LPAON is off. With next TM0 the mux_out()
      // function will update the multiplexer outputs.
      }

  ....
    if(key_press_short(1 << KEY_PAON))  {
  ....
    mux[REED1] |= (1 << MX_RPAON);
    // This update should be active with next TH0 cycle.
     }
  }

}

// ISR called every 4ms
ISR(TIM0_COMPA_vect)  {

  ....
  mux_out();
}


// ISR called every 100ms
ISR(TIM1_COMPA_vect)  {

  ...
  if(state == PWRMAX)
    mux[REED1] ^= (1 << MX_LPAON);
}


// write mux array bytes bit per bit to multiplexer
void
mux_out(void)  {

  unsigned char* muxp = mux + MUX_SIZE;

  .....
}

Autor: Oliver (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
volatile ist bei Feldern nicht erforderlich, die optimiert der Compiler 
(noch?) nicht weg.

Das Problem könnte aber daran liegen, daß du regelmässig auf mux[2] 
ausserhalb des Feldes liest und schreibst. Sowas kommt nie gut ;-)

In C beginnt der Feldindex nunmal bei 0.

Oliver

Autor: Stefan B. (stefan) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> #define MUX_SIZE   2  // Number of installed MUX ( 74LS595 )
> unsigned char mux[MUX_SIZE];

> volatile unsigned char *muxp = mux + MUX_SIZE;

Gibt einen Bufferoverflow beim Zugriff auf *muxp.
muxp zeigt auf das unsigned char hinter dem Array mux.

>    mux[2] |= (1 << MX_LPAON);

dito Bufferoverflow.

Autor: Karsten K. (karsten42)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Whaaaa! DOPPEL SCHÄM!!!!

Ich hab das aus dem original code falsch übertragen.... Es heisst 
natürlich:
#define MUX_SIZE 3

Somit ist das array auch richtig definiert und werte werden richtig 
zugewiesen.
Volatile ist also nicht bei array's notwendig? Gut, dann begreife ich 
aber nicht, warum eine Zuweisung im scope von main() auf das array in 
form von
mux[2] = 0xf;
 nicht zu einem update via ISR TM0 call auf mux_out() führt... :-(

Daaaanke für die überaus schnelle und aufmerksamen Antworten!

Karsten

Autor: Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ist es nicht wichtiger state als volatil zu kennzeichen?

Autor: Joachim (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo

Bitte alles zeigen, was mux_out macht!
Bis jetzt wird nur ein Zeiger auf das Ende von mux gesetzt.

Gruß
Joachim

Autor: Karsten K. (karsten42)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,

Die Variable <state> wird in der ISR aber nur gelesen und nicht 
zugewiesen. Daher war ich davon ausgegangen das diese nicht als volatile 
zu definieren ist. Aber du hast recht glaube ich: Denn im AVR-GCC 
tutorial steht, dass auch beim lesen von variablen in einer ISR die im 
main() scope verändert werden diese mit volatile zu definieren sind.

Daaanke für diesen überaus guten Tipp! Ich werde das heute abend gleich 
ausprobieren und das Ergebnis mitteilen.

Gruß
Karsten

Autor: Falk Brunner (falk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@  Karsten Kankowski (karsten42)

>Volatile ist also nicht bei array's notwendig?

DOCH!!! Auch wenn es OFT ohne geht, ist es NICHT sicher!
Hab ich auf dem GCC schon erlebt, dass erst das volatile das korrekte 
Ergebnis liefert (UART TX Interrupt).

MfG
Falk

Autor: Karsten K. (karsten42)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hey Falk,

Du hast Recht!! nach langem ausprobieren ( was mir absolut widerstrebt ) 
habe ich nun eine Lösung meines Problems gefunden.
Das globale array muss wie folgt definiert werden:
volatile unsigned char mux[MUX_SIZE];
In der funktion mux_out() muss der char pointerebenfalls volatile 
definiert werden ( sonst beschwert sich der Compiler ):
volatile unsigned char* muxp = mux + MUX_SIZE;

Damit aber nun ein update von mux[] im scope von main() und ISR TIM1 
auch funktioniert, musste ich den Funktionsaufruf aus der ISR TM0 in die 
ISR TM1 legen.
ISR(TIM1_COMPA_vect)  {

  ...
  if(state == PWRMAX)
    mux[REED1] ^= (1 << MX_LPAON);
  ...

  mux_out();
}


Mir ist aber absolut nicht klar warum! Und ich bin darüber ziemlich 
unerfreut, funktioniert doch etwas im Code von dem ich ausgehen kann das 
es noch diverse Seiteneffekte hat. Ich hab dazu ein ungutes Gefühl ( wie 
auf Sand gebaut ).

Vielleicht hat ja jemand aus dem Forum eine plausible Erklärung dazu...


Vielen herzlichen Dank aber schon mal an alle die sich beteildigt haben!

Gruß
Karsten

Autor: A. K. (prx)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich bin auf die Schnelle nicht bis ins Detail rein, aber wenn muxp 
sowohl in ISR als auch im Hauptprogramm verwendet wird, dann kann es gut 
sein, dass diese Variable nicht nur auf "volatile" zeigen muss, sondern 
auch selbst "volatile" sein muss, also
  volatile unsigned char *volatile muxp = mux + MUX_SIZE;

Apropos: Direkt hinter das letzte Element zu zeigen ist solange legal, 
wie nur damit verglichen nicht aber darüber zugegriffen wird.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
A. K. schrieb:
> Ich bin auf die Schnelle nicht bis ins Detail rein, aber wenn muxp
> sowohl in ISR als auch im Hauptprogramm verwendet wird, dann kann es gut
> sein, dass diese Variable nicht nur auf "volatile" zeigen muss, sondern
> auch selbst "volatile" sein muss, also
>   volatile unsigned char *volatile muxp = mux + MUX_SIZE;

in diesem konkreten Fall nicht.
Da mux seine Adresslage nicht ändert und auch MUX_SIZE eine Konstante 
ist, könnte man höchstens argumentieren, dass
   volatile unsigned char *const muxp = mux + MUX_SIZE;

korrekt wäre.

Die Sache mit dem Array.
Auch wenn es unwahrscheinlich ist, so sollte man natürlich das Array als 
ganzes volatile machen. Die Tatsache, dass es sich hier um ein Array 
handelt, darf doch keine Rolle spielen! volatile bedeutet ja 
schliesslich: keinerlei Annahmen über den Inhalt einer Speicherzelle 
machen und lokale Optimierungen auf dieser Speicherzelle aussen vor 
lassen. Natürlich ist es unwahrscheinlich, dass der Compiler es schafft 
ein komplettes Array in CPU-Registern zu halten und damit eine 
Optimierung aufzubauen. Aber unwahrscheinlich bedeutet nicht, dass es 
unmöglich ist. Wird in einer Schleife ein einzelnes Element aus dem 
Array benutzt, dann kann der Optimizer sehr wohl zuschlagen und dieses 
Element in einem Register halten.

Das fiese ist ja: ohne volatile kann etwas funktionieren, aber es muss 
nicht. Ob und wie hängt immer von den Details des Optimizers ab. Und dem 
möchte man sich ganz sicher nicht auslieferern.

Autor: Karsten K. (karsten42)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Moin Moin,

Ich habe *muxp als volatile definiert weil der compiler korrekter weise 
die Zuweisung von
*muxp auf volatile unsignbed char mux[]
bemängelte.

Mir ist soweit klar, dass variablen die in ISR gelesen/beschrieben 
werden auf volatile zu setzen sind. Folgerichtig habe ich das array 
mux[] entsprechend definiert.

Mein Unverständnis liegt darin, dass der scope für Änderungen in mux[] 
nur in main() und in der ISR TIM1 liegt.
Oder klarer:
Rufe ich die funktion mux_out() in der ISR TIM0 auf, so sind Änderungen 
am array mux[] nur im scope main() sichtbar, aber eben nicht in der ISR 
TIM1!

Gruß
Karsten

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.