Berechnung CTC Timer

z.b. alle 2 ms soll eine Led blinken. Ich dachte ich muss den Aufrauf 
(500mal/s) selbst programmieren gemäß des Teilcodes aus dem 
AVR-GCC-Tutorial, wobei ich bis jetzt nicht ganz verstehe was in der 
Routine passiert und wozu die If-Abfragen dienen.

ISR (TIMER0_COMPA_vect)
{
  millisekunden++;
  if(millisekunden == 1000)
  {
    sekunde++;
    millisekunden = 0;
    if(sekunde == 60)
    {
      minute++;
      sekunde = 0;
    }
    if(minute == 60)
    {
      stunde++;
      minute = 0;
    }
    if(stunde == 24)
    {
      stunde = 0;
    }
  }
}

MCAnfänger schrieb:
> z.b. alle 2 ms soll eine Led blinken.

Probiers mal damit:

While(1)
{


    // Die Bedingung wird nur einmal durchlaufen. Also jede Sekunde 
einmal.
    if (  Alte_Sek != Sekunde)
    {
       // Alle 5 Sekunden Port PB3 Toggeln
       if ( ( Sekunde % 5 ) == 0 ))
       {
            // An Port PB3 Soll alle 5 Sekunden eine LED Toggeln
            PORTB ^=  ( 1 << PB3 );
      Alte_Sek = Sekunde;

       }

    }

}

Carl D. schrieb:
> Na zuerst läuft diese ISR 1000 mal per Sekunde.

sorry für diese Frage, aber wird die ISR ( der Inhalt der Routine) 1000 
mal aufgerufen und abgearbeitet. Wenn der Timer alle 2 ms= 500 1/s den 
Interrupt aufruft, bedeutet dass die LED 500 mal blinkt?

MCAnfänger schrieb:
> Wenn der Timer alle 2 ms= 500 1/s den
> Interrupt aufruft, bedeutet dass die LED 500 mal blinkt?

Wenn du die LED in der Interupt Routine Toggelst. Ja!

Wirst aber kein Blinken feststellen, weil es so schnell von statten 
geht,
das du nur ein Dauerleuchten siehst.
Vllt. auch etwas flackern.

Frag lieber in der Main ab ob eine bestimmte Zeit Vergangen ist und
und Schalte deine LED ein oder aus.

Z.B.

if ( (millisekunden % 500) == 0 )

Wobei millisekundenvom TYP uint16_t sein muss damit auch auf 1000 
Gezählt werden kann.

Danke für die wunderbaren Antworten.
So eine letzte Frage, wozu brauchen wir eigentlich die Hilfsvariable in 
der ISR Routine?


ISR(...)
{
tue was
}

wozu brauchen wir eigentlich die Hilfsvariable in
der ISR Routine?

Aus dem Tutorial hab ich folgrndes für dich.



Wird innerhalb einer ISR mehrfach auf eine mit volatile deklarierte 
Variable zugegriffen, wirkt sich dies ungünstig auf die 
Verarbeitungsgeschwindigkeit aus, da bei jedem Zugriff mit dem 
Speicherinhalt abgeglichen wird. Da bei AVR-Controllern innerhalb einer 
ISR keine Unterbrechungen zu erwarten sind, bietet es sich an, einen

Zwischenspeicher in Form einer lokalen Variable zu verwenden, deren 
Inhalt zu Beginn und am Ende mit dem der volatile Variable 
synchronisiert wird. Lokale Variable werden bei eingeschalteter 
Optimierung mit hoher Wahrscheinlichkeit in Prozessorregistern verwaltet 
und der Zugriff darauf ist daher nur mit wenigen internen Operationen 
verbunden. Die ISR aus dem vorherigen Beispiel lässt sich so optimieren:

//...
ISR(TIMER1_COMPA_vect)
{
   uint8_t tmp_kc;

   tmp_kc = gKeyCounter; // Uebernahme in lokale Arbeitsvariable

   if ( !(KEY_PIN & (1<<KEY_PINNO)) ) {
      if (tmp_kc < CNTREPEAT) {
         tmp_kc++;
      }
   }
   else {
      tmp_kc = 0;
   }

   gKeyCounter = tmp_kc; // Zurueckschreiben
}

MCAnfänger schrieb:
> Der Interrup soll dabei alle 2 ms=500 Hz
> erfolgen.

Heißt es, dass bei einer Wiederholung von 500 Takte ich eine 
Hilfsvariable mit 500 bzw. 0 initialisiere. Diese dann auf null/500 
dekrementiere/inkrementiere.

bsp.:
volatile unsigned int zähl;

ISR(...)
{
zähl++;

if(zähl>500)
{
....
}

@MCAnfänger
Hab auch mal ne Frage.
Hast du überhaubt die Grundlagen in c erlernt bzw. bist absoluter 
Anfänger?

Wie wäre es, wenn du,  ein bischen von deinem bis jetzt selbst 
geschriebenen C-Code hier zu Posten würdest.

Klaus schrieb:
> @MCAnfänger
> Hab auch mal ne Frage.
> Hast du überhaubt die Grundlagen in c erlernt bzw. bist absoluter
> Anfänger?

Also in C habe ich selbst kleine Programme(Funktionen, Felder usw) 
geschrieben. Auf dem Themengebiet MC bin ich ein Neuling (MCAnfänger:)) 
und wie es üblicherweise ist, habe ich als erstes LEDs blinken lassen. 
Der Unterschied zwischen lokalen und globalen Varible sowie volatile 
Variable ist mit bekannt. Nur ich verstehe nicht warum wir in die ISR 
eine Variable einfügen, wenn wir die LED nur blinken haben wollen. Was 
passiert durch die zusätzliche Variable? Wie die If-Abfrage 
funktioniert, weiss ich auch. Vielleicht ist meine Frage überflüssig.

-----------------------------mit Variable------------------------

#include <avr/io.h>
#include <avr/interrupt.h>

int extraTime = 0;

.......


ISR(TIMER0_COMPA_vect)
{
    extraTime++;

    if(extraTime > 100)
    {
        extraTime = 0;
        PORTB ^= (1 << PORTB0);
    }
}
--------------------------ohne Variable----------------------------
#include <avr/io.h>
#include <avr/interrupt.h>

int extraTime = 0;

.......


ISR(TIMER0_COMPA_vect)
{
      PORTB ^= (1 << PORTB0);
}

Carl D. schrieb:
> MCAnfänger schrieb:
>> extraTime++;
>>
>>     if(extraTime > 100)
>>     {
>>         extraTime = 0;
>
> was genau verstehst du an diesen 5 Zeilen Code nicht?
>
> An der Programmiersprache kann das kaum liegen, denn außer "++"->"erhöhe
> um eins", steht da doch nur Klartext.


//f_CPU:20 MHZ
//Prescaler: 1024
//OCR: 195
//toverflow= (1024/20Mhz)*196=10ms
//10 ms = 100 Mal/sekunde

ISR(TIMER0_COMPA_vect)
{
    extraTime++;           //--->extraTime=0 bis 100 ist dann 1 sec rum

    if(extraTime > 100)    //Wenn eine sec vorbei ist, wird die variable
    {
        extraTime = 0;     // auf Null zurück gesetzt
        PORTB ^= (1 << PORTB0);    //LED toggeln lassen
    }
}

Frage: Warum wird bis 100 gezählt (eine Sekunde vorbei ist) und dann 
erst LED "an" und "aus" geschaltet? Warum wird diese extra Zeit 
eingefügt?

MCAnfänger schrieb:


> int extraTime = 0;
Also wenn ich mich nicht irre sollte volatile vor int extraTime = 0; 
stehen.



>
> ISR(TIMER0_COMPA_vect)
> {
>       PORTB ^= (1 << PORTB0);
> }

Der Unterschied zu deiner mit if abfrage ist,
dass die LED, vor sich hin flackert.
Also du wirst nichts vom Blinken sehen.

Und warum willst du Unbedingt Variabeln in der ISR haben
und auch noch eine Menge Code Ausführen lassen?

Du kannst auch folgendes in der ISR machen:


//Globale Variable
volatile uint16_t counter1 = 0;


ISR(TIMER0_COMPA_vect)
{
     if(counter1 > 0) counter1--;
}

Und in der main machst du folgendes:

main()
{
  while(1)
  {

      if (( counter1 )   == 0)
      {
         PORTB ^=  ( 1 << PB3 ); // LED Toggeln
         // Startwert der Angepasst werden kann.
         counter1 = 50;
      }

  }

}

Damit Hast du dann eine schönes Blinki Programm.


PS; Du scheinst auch Lesefaul zu sein.
So habe ich den Eindruck jedenfalls.
Sieh dir mal die obigen Posts näher an.

Klaus schrieb:
> PS; Du scheinst auch Lesefaul zu sein.
> So habe ich den Eindruck jedenfalls.
> Sieh dir mal die obigen Posts näher an.

Danke, werde ich machen.