Structs in ISR

[micro1 (Gast)]

Hallo,

wenn man eine Variable hat die in einr ISR und im Hauptprogramm
geändert wird muss diese ja volataile sein.
Nun habe ich aber noch structuren die sowohl in der ISR und im
Hauptprogramm geändert werden. Diese kann ich aber gar nicht volataile
machen sondern nur static.
In der ISR greif ich dann natürlich mit dem Punktoperator darauf zu.
Kann das Probleme geben, wenn ich in einer ISR auf die structur
zugreife da diese ja nicht volataile ist?

[Rufus Τ. F. (rufus)]

.
   Diese kann ich aber gar nicht volataile
   machen sondern nur static.

Warum?

[micro1 (Gast)]

Wenn ich die structur mit volatile anlegen will bekomme ich compiler
fehler.

[Rufus Τ. F. (rufus)]

Ach?














Was hältst Du davon, einen Quelltextschnipsel und die betreffende
Compilerfehlermeldung hier zu veröffentlichen?

[micro1 (Gast)]

static struct structname

SIGNAL (SIG_OVERFLOW1)
{
structname.xyz=1;
}

void main(void)
{
structname.xyz=2;
....
}

So sieht der code jetzt aus.
Das hat bis jetzt auch immer funktioniert.
Nur habe ich jetzt gelesen das variablen die in ISRs und
imHauptprogramm genutzt werden volatile sein müssen.

[Rufus Τ. F. (rufus)]

Ich sehe keine Fehlermeldung.

Weißt Du, was im von Dir zitierten Codeschnipsel das Schlüsselwort
"static" bewirkt?

[micro1 (Gast)]

Ja. Das heist diese Variable ist nur in diesem Modul zu sehen.
Das modul von dem der Schnipsel stammt heist main.c.
In meinem main.c gibt es halt die funktion
void main(void)
und sämtliche ISR sind dort programmiert.
Jetzt meine Frage.
Im AVR GCC Tutorial steht das variablen die in einer ISR benutzt werden
und im Hauptprogramm müssen volatile sein.
Nun ist meine Strukutr aber static.
Ich nutze die Struktur in mehrern ISR´s und im Hauptprogramm.
Ist dies schlimm. Bis jetzt funktioniert es nämlich.

[Rufus Τ. F. (rufus)]

Ich sehe immer noch keine Fehlermeldung.

[Dirk D. (dirkd)]

Wie definierst Du eigentlich Deine Struktur?

Versuch mal

typedef struct
{
   int xyz;
   int abc;
} mystruct;

volatile mystruct astruct;

Das gibt bei mir keine Fehlermeldung.

> Wenn ich die structur mit volatile anlegen will bekomme ich
> compiler fehler.

Bei so einer Aussage solltest Du eigentlich mal den Code + den Wortlaut
der Fehlermeldung posten. Welchen Compiler Du verwendest könntest Du
auch mal erwähnen.

[micro1 (Gast)]

Also ok

main.c:13: warning: passing arg 1 of `going' discards qualifiers from
pointer target type
Das war die Fehlermeldung.
#include <avr\io.h>
#include "struct.h"
#include "test.h"


volatile port hallo;

int main(void)
{
hallo.abc=0;
going(&hallo);
do
{
}
while(1);
return 0;
}
Das war der Code.

Jetzt aber noch mal zurück zur anderen Frage.
Kann die structur static bleiben  wenn ich in ISR darauf zugreife und
im Hauptprogramm?

[Cri Gri (Gast)]

Hi leute....

hmm...hab mal so ne frage nebenbei!Also,was bringt mir so ne STRUCT
eigentlich? wofür verwendet ihr den die beim µC progn??
sorry wegen der Frage aber ich will halt noch lernen ;)

mfg Cri

[A.K. (Gast)]

Wetten das going() den Parameter nicht als "pointer to violatile ..."
deklariert hat?

[Dirk D. (dirkd)]

@micro1:
So jetzt haben wir eine Fehlermeldung.

Aber wieder keine Definition der Struktur. Und um zu verstehen was bei
Dir falsch läuft bräuchte man auch noch die Definition der Funktion
going. Die ISR wäre auch nicht schlecht.

Der Punkt ist volatile kannst und sollst Du verwenden.

@Cri Gri:
> wofür verwendet ihr den die beim µC progn??
Aus dem gleichen Grund wie jeder sonst struct verwendet. Strukturieren
;-) Zusammenfassen von einzelnen Variablen zu einem neuen Datentyp. Das
hat nix mit µC zu tun.

[micro1 (Gast)]

hier die structur
ist nur ein Beispiel mein Orginal quellcode ist zu lang aber vom selben
typ
#ifndef struct_h
typedef struct
{
unsigned int abc:1;
}port;

#define struct_h 1
#endif

nun kommt die funktion going plus header
#include "struct.h"

void going(port *hallo);

#include "test.h"
#include "struct.h"

void going(port *hallo)
{
int x;

}

und nun die isr

SIGNAL(SIG_OVERFLOW0)
{
hallo.abc=1;
}

[micro1 (Gast)]

Achja wenn ich in der main
static port hallo schreibe kommt keine Fehlermeldung

[A.K. (Gast)]

"void going(port *hallo);"

Sach ich doch. Schreib da
  void going(volatile port *hallo);
und schon sieht's besser aus.

Mit "static" gibt es deshalb keinen Fehler, weil "static" kein
Bestandteil vom Datentyp ist, "volatile" jedoch schon.

[micro1 (Gast)]

Ah jetzt funktionierts. Danke.
Aber ich verstehe immer noch nicht das es mit static trozt zugriff in
einer ISR immer funktioniert.
Weis da jemand genau bescheit drüber. Ich habe mir nämlich den
Assembler code angeschaut.
Meine volatile varibalen werden in der ISR mit "LDI" geladen.
Mein static variablen aber auch?

[Dirk D. (dirkd)]

@A. K.
Genau. Das selbe Problem hätte der OP  bei Verwendung von const.

Beides sind "type qualifier" die auf jeden Datentyp angewendet werden
können. Damit natürlich auf selbst definierte, sprich structs.

Normalerweise sollte es aber "nur"  eine Warnung sein. (Ich denke
auch, daß jede Warnung eigentlich ein Fehler ist)

[Dirk D. (dirkd)]

> [...] Mein static variablen aber auch?

Verwendest Du überhaupt Compiler-Optimierungen?

Wenn nicht, sollte ein volatile eigentlich nicht notwendig sein. Aber
Du machst die Funktionalität Deines Programms von den Compiler-Optionen
(und der Implementierung des Compilers) abhängig.

[micro1 (Gast)]

Ich habe volle OPtimierung eingeschaltet

[Dirk D. (dirkd)]

static und volatile schließen sich nicht gegenseitig aus. Sie sind haben
unterschiedliche Funktionen

static gehört in die gleiche Gruppe wie extern, auto oder register (und
mutable in c++)

Sie bestimmen die Art und Weise in der die Variablen und/oder
Funktionen gespeichert werden.

Dagegen gehört volatile zu den qualifier genau wie const. Volatile
bestimmt, daß der Compiler nicht versuchen soll einen Zugriff auf diese
Variablen (weg zu)-optimieren.

Du kannst z. B. eine Variable auch als

static volatile int x;

deklarieren.

Selbst ein

static volatile const int x;

ist syntaktisch in Ordnung.

Beispiel für eine mögliche Optimierung (Etwas stark konstruiert)

Du hast die Variable

unsigned long * RTC = 0xFFFE200;
unsigned long secs;
Später hast Du im Hauptprogramm die Zeilen

ms=*RTC;
printf("%d",ms);
ms=*RTC;
printf("%d",ms);

Ein Optimierer könnte auf die Idee kommen die zweite Zuweisen
wegzulassen, da sich an dem Inhalt an der Adresse 0xFFE200 nichts
geändert hat, da nicht auf RTC zugegriffen wurde.

In Wirklichkeit steht z. B. an dieser Adresse eine Uhrzeit in ms die
sich zwischen den Zuweisungen durch einen Interrupt geändert hat.

Um so eine Optimierung zu verhindern würde man ein volatile als
qualifier hinzufügen. also:

volatile unsigned long * RTC = 0xFFFE200;

Ich hoffe das habe ich zu später Stunde noch fehlerfrei hinbekommen ;-)