CTC bei ATTINY2313 8 Bit Timer0

Otto wrote:
> Hallo Thomas,
>
> das "volatile" für "Teiler" fehlt z.B.
>
> Gruss Otto

Hallo Otto,
habe jetzt "volatile int Teiler;" eingefügt aber es möchte noch immer 
nicht funktionieren.

Gruss Thomas

Axel Rühl wrote:
> kannnicht
>
>>  TIMSK |= (1<<TOIE0);        // Aktiviere Overflow Interrupt für
>
> Du musst den Comparematch Interrupt aktivieren
>
> Gruß
> /XlR.


Upps, danke das wars. Hatte davor den Timer mit Overflow versucht und 
das total übersehen. Mir fehlt aber auch noch ein bisschen die 
Erfahrung. Sind momentan meine ersten Versuche.

Ab wann muss man den seine Variablen mit "volatile" deklarieren ?

Gruss  Thomas

> Ab wann muss man den seine Variablen mit "volatile" deklarieren ?

volatile musst du dann nehmen, wenn Gefahr besteht, dass
der Compiler einen Zugriff auf die Variable wegoptimieren
könnte. Grob gesagt: Immer dann, wenn es für den Compiler
nicht ersichtlich ist, dass eine Variable auf anderen
Wegen als die die dem Compiler bekannt sind einen neuen
Wert kriegt.

volatile macht nichts anderes, als einfach nur mögliche
Optimierungen auf dieser Variablen abzuschalten.

Bsp:

du hast folgende Schleife

unsigned char i;
unsigned char a;

void foo()
{
   i = 0;

   while( i == 5 ) {
      a = 8;
   }
}

Wenn der Compiler diese Funktion übersetzt, dann findet die
Datenflussanalyse heraus, dass i zu Beginn der Schleife
den Wert 0 hat. Weiters findet die Analyse heraus, dass
es innerhalb der Schleife keine Möglichkeit für i gibt,
je verändert zu werden. Da i daher immer den Wert 0 hat,
kann die Schleife niemals betreten werden und kann damit
komplett wegfallen.

Nur: Jetzt kommt dein Programmund installiert einen Interrupt-
handler, welcher - Überraschung - sehr wohl i irgendwann mal
auf 5 setzt.

Nur: Das weis der Compiler nicht, wenn er foo() übersetzt.

Also muss man ihm mitteilen: Spar dir Optimierungen, die über
i laufen. i ändert seinen Wert auf Wegen die für dich nicht
einsehbar sind.

Und genau das macht das volatile

volatile unsigned char i;

Jetzt trifft der Compiler keinerlei Annahmen mehr über i.
Er speichert den Wert der Variablen auch nicht in einem
CPU Register zwischen, wie zb hier:

    j = i + i;

sondern liest bei jeder Erwähnung von i den Wert tatsächlich
aus dem Speicher aus. (Im obigen wäre das ja eigentlich unsinnig.
Speicher auslesen kostet Zeit. Wenn der Compiler i einmal holt
und dann verdoppelt kommt das gleiche raus)

Leider verkommt volatile bei vielen Programmierern zu:
Wenn du in einem ISR eine Variable benutzt, muss diese
volatile sein.
Unsinn. Jetzt weist du was wirklich dahinter steckt.

In deinem Pgm hast du den Fall aber nicht, selbst wenn
der ISR-Vektor richtig gestellt ist. Da Teiler eine globale
Variable ist, wird die vom Compiler sowieso mit 0 initialisiert.
Die Zuweisung von 0 in main() bewirkt also im Grunde genommen
gar nichts. Damit kommt Teiler aber nur noch in der ISR vor
und damit besteht die Gefahr gar nicht.