[AVR] Structs innerhalb von ISR auch ohne volatile?

[Markus (Gast)]

Hi, ich bastle gerade an der AVR134 AppNote rum (Software RTC). Mir ist 
da gerade aufgefallen, dass die Struct für DateTime nicht volatile ist, 
aber sowohl innerhalb als auch außerhalb verwendet wird.

typedef struct{ 
unsigned char second;   //enter the current time, date, month, and year
unsigned char minute;
unsigned char hour;                                     
unsigned char date;       
unsigned char month;
unsigned int year;      
            }time;

 time t;

Trotzdem funktioniert der Code. Ist das jetzt eher Zufall oder ist das 
so beabsichtigt?

[Uwe S. (de0508)]

Hi Markus,

Aber ohne weiteren Programmcode kann dir keiner Helfen !

Ich gehe mal von der angehängten Datei aus oder ?

t wird nicht in der Main gelesen, also ist das auch kein Problem mit der 
ISR.

[Markus (Gast)]

Doch, t wird sowohl in Main als auch in der ISR verwendet. Hier ein 
Ausschnitt aus der ISR

ISR(TIMER2_OVF_vect) //overflow interrupt vector
{ 
    
    if (++t.second==60)        //keep track of time, date, month, and year
    {
        t.second=0;
        if (++t.minute==60) 
        {
            t.minute=0;
            if (++t.hour==24)

Und ein Ausschnitt aus main()

void init_rtc(void)
{
  t.second=0;
  t.minute=0;
  t.hour=21;
  t.date=11;
  t.month=7;
  t.year=2011;
}
                                       
int main(void)
{                        
  //char rtc_time[8];  
    char temp[4];
    init_rtc();

In main() wird sowohl gelesen als auch geschrieben (geschrieben aber nur 
bei deaktiviertem IRQ)

[Ralf (Gast)]

Markus schrieb:
> Ist das jetzt eher Zufall oder ist das so beabsichtigt?
Wenn es nur diese beiden Varianten gäbe, dann eher Zufall. Dass eine 
Struktur in Registern gehalten wird, ist eher unwahrscheinlich. Also 
muss die irgendwo im Speicher stehen, wo sie auch bleibt. Zur 
einheitlichen und übersichtlichen Deklaration würde ich allerdings das 
'volatile' dazu machen.

[Markus (Gast)]

also so wäre es richtig?

volatile time t;

[Peter II (Gast)]

wenn du die Struktor volatile machst, dann wird der zugriff auf die 
Variabeln in der ISR langsamer. Wenn das ganze zeitkritisch ist könnten 
damit neue Probleme entstehen.

[Rolf Magnus (Gast)]

Peter II schrieb:
> wenn du die Struktor volatile machst, dann wird der zugriff auf die
> Variabeln in der ISR langsamer.

Aber nur wenn man in der ISR mehrfach auf die selbe Variable zugreift. 
In diesem Fall bietet es sich an, sie anfangs in eine lokale Variable zu 
kopieren und/oder (je nach Fall) am Ende wieder zurück. Dann die 
eigentlichen Zugriffe auf die lokale Variable machen.

[Ralf (Gast)]

Peter II schrieb:
> dann wird der zugriff auf die Variabeln in der ISR langsamer
In der ISR kann ich mir das nicht vorstellen. Höchstens in der main(), 
denn die Werte müssen ja immer aktuell sein, falls ein Interrupt 
zuschlägt.
Aber: Wenn die Struktur in der main() und in ISRs verwendet wird, dann 
muss ein ordentlicher Zugriff immer gewährleistet sein. Da darf sich der 
Code in diesem Fall nicht unterscheiden. Ob nun mit oder ohne 
'volatile'. Sonst würde es ja nicht funktionieren.

Markus schrieb:
> also so wäre es richtig?
> volatile time t;
Richtig? Falsch? ... Ich würde es so machen.

[Ralf (Gast)]

Rolf Magnus schrieb:
> Aber nur wenn man in der ISR mehrfach auf die selbe Variable zugreift.
Hm, hab' ich nicht beachtet.
Rechnet der Compiler damit, dass die ISR unterbrochen werden kann?

[(prx) A. K. (prx)]

Auch innerhalb der ISR muss der Compiler die Struktur als volatile 
behandeln und jeden Zugriff so ausführen wie hingeschrieben. Der weiss 
nämlich nicht, ob die ISR selbst wiederum unterbrechbar ist oder ob die 
betreffenden Daten irgendwie von der Hardware verändert werden (DMA, 
I/O-Register, ...).

[Peter II (Gast)]

Ralf schrieb:
> In der ISR kann ich mir das nicht vorstellen.

ist aber so.

jeder Zugriff auf die Variabel finden im Ram statt im Register statt. 
Das heist für jeden Zugriff wird die Variable in ein Register gelesen, 
dann das Register geändert und dann sofort das Register zurück in den 
Ram kopiert.

[Ralf (Gast)]

Nach neuem Erkenntnisstand :-)
So:
Ralf schrieb:
> Markus schrieb:
>> also so wäre es richtig?
>> volatile time t;
> Richtig? Falsch? ... Ich würde es so machen.
Und das beachten:
Rolf Magnus schrieb:
> Aber nur wenn man in der ISR mehrfach auf die selbe Variable zugreift.
> In diesem Fall bietet es sich an, sie anfangs in eine lokale Variable zu
> kopieren und/oder (je nach Fall) am Ende wieder zurück. Dann die
> eigentlichen Zugriffe auf die lokale Variable machen.

[Rolf Magnus (Gast)]

Ralf schrieb:
> Rolf Magnus schrieb:
>> Aber nur wenn man in der ISR mehrfach auf die selbe Variable zugreift.
> Hm, hab' ich nicht beachtet.
> Rechnet der Compiler damit, dass die ISR unterbrochen werden kann?

Der Compiler weiß nichts von ISRs. Für ihn sind das ganz normale 
Funktionen. Auch volatile steht erstmal in keinem direkten Zusammenhang 
mit ISRs. Also behandelt der Compiler die Variable in der ISR ganz genau 
so, wie er sie auch außerhalb behandeln würde.

[Markus (Gast)]

Rolf Magnus schrieb:
> Also behandelt der Compiler die Variable in der ISR ganz genau
> so, wie er sie auch außerhalb behandeln würde.

Hm, eine andere (normale) Variable hat er aber anscheinend wegoptimiert. 
Zumindest hat es erst funktioniert, nachdem ich sie volatile gemacht 
habe

[Rolf Magnus (Gast)]

Markus schrieb:
> Rolf Magnus schrieb:
>> Also behandelt der Compiler die Variable in der ISR ganz genau
>> so, wie er sie auch außerhalb behandeln würde.
>
> Hm, eine andere (normale) Variable hat er aber anscheinend wegoptimiert.

Ja, also eben so, wie er es in einer normalen Funktion auch getan hätte.