Eigener prescaler funktioniert nicht

[Sherlock´s Tone (Gast)]

Hallo Leute,

ich setze mich momentan mit Timern auseinander und bin auf folgendes 
Problem gestoßen:

Ich habe einen CTC Timer Programmiert und OCR0 auf 50-1 gesetzt.
Da ich einen Quarz von 7,3728MHz verbaut hatte und lediglich eine LED im 
1Hz Takt als Test blinken lassen wollte, habe ich mir einfach selber 
einen prescaler programmiert:

uint32_t prescale = 0;

.
.
.
.

if (prescale >=73728)
{
  PORTB ^= (1<<LED);
  prescale = 0;
}

prescale wird bei jedem compare match um 1 erhöht.


Als ich das Programm testete, habe ich jedoch festgestellt, das die LED 
nicht im exakten Takt zu blinken scheint und ich durch ändern des OCR0 
Wertes keine korrekte Frequenzänderung habe...

Nach langen versuchen und ausprobieren entschied ich mich dafür einfach 
mal einen "richtigen" prescaler zu verwenden.
Folglich setzte ich das CS02 Bit, um den prescaler von 1024 zu 
verwenden.

So sieht der angepasste Code aus:

if (prescale >=73728/1024)
{
  PORTB ^= (1<<LED);
  prescale = 0;
}

Nach diesem eingriff funktioniert das Programm komischer weise 
einwandfrei und exakt.
Nun frage ich mich trotzdem woran das liegt? Im Grunde ist dies doch das 
selbe oder?

[Jürgen S. (jurs)]

Sherlock´s Tone schrieb:
> Ich habe einen CTC Timer Programmiert und OCR0 auf 50-1 gesetzt.
> ...
> uint32_t prescale = 0;
> ...
> if (prescale >=73728)
> ...
> prescale wird bei jedem compare match um 1 erhöht.
>
>
> Als ich das Programm testete, habe ich jedoch festgestellt, das die LED
> nicht im exakten Takt zu blinken scheint und ich durch ändern des OCR0
> Wertes keine korrekte Frequenzänderung habe...

Dein Programm enthält mindestens zwei Anfängerfehler im Zusammenhang mit 
Interruptprogrammierung.

Variablen, auf die Du sowohl von einer Interruptbehandlungsroutine als 
auch von normalem Code aus zugreifst, müssen "volatile" deklariert sein.

Und wenn die Variable mehr als 8 Bit groß ist, mußt Du die Interrupts 
sperren, wenn Du sie außerhalb einer Interruptroutine ausliest.

[Sherlock´s Tone (Gast)]

Danke für deine Antwort,

ich habe volatile nur vergessen mit reinzuschreiben und das wegen cli(); 
und sei(); habe ich getestet, jedoch bleibt dieses Problem bestehen.

Hier mein ganzer Quellcode:

//Quarz = 7.372.800 Hz



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



#define LED PB0

volatile uint32_t prescale = 0;


void Timer1 (void)
{

  
  
  TIMSK |= (1<<OCIE0); //Interupt bei compare match
  TCCR0 |= (1<<WGM01) | (1<<CS00); //CTC Modus, (TCNT0 start)
  OCR0 = 50-1;
  TCNT0 = 0;
}

int main(void)
{
  Timer1();
  DDRB |= (1<<LED);

  
  
  sei();

    while(1)
    {
    cli();
    if (prescale >=73728)
    {
      PORTB ^= (1<<LED);
      prescale = 0;
    }
    sei();
    }
}

ISR (TIMER0_COMP_vect)
{
  prescale++;
}

[Stefan E. (sternst)]

Vermutlich wird deine ISR mehr als 50 Takte zur Ausführung benötigen.

[Sherlock´s Tone (Gast)]

Hmm naja dann muss ich wohl damit leben und hoffen das ich diesen Fehler 
beim nächsten mal schnell finde...

Danke für eure Antworten!

MfG Alex

[Verwirrter (Gast)]

>Variablen, auf die Du sowohl von einer Interruptbehandlungsroutine als
>auch von normalem Code aus zugreifst, müssen "volatile" deklariert sein.
Warum denn das ?

[Jürgen S. (jurs)]

Verwirrter schrieb:
>>Variablen, auf die Du sowohl von einer Interruptbehandlungsroutine als
>>auch von normalem Code aus zugreifst, müssen "volatile" deklariert sein.
> Warum denn das ?

Die kurze Antwort:
http://www.mikrocontroller.net/articles/Interrupt#Volatile_Variablen

Die lange Antwort:
http://www.mikrocontroller.net/articles/FAQ#Was_hat_es_mit_volatile_auf_sich

[Uwe (de0508)]

Hallo  Sherlock

was ich nicht verstehe ist, dass Du den Timer ohne Vorleiter laufen 
lässt.

Dann muss die Timer-ISR die ganze Arbeit machen.

Üblicherweise wählt man einen ISR Frequenz von 1000Hz (1ms) - 100Hz 
(10ms).

[Peter D. (peda)]

Stefan Ernst schrieb:
> Vermutlich wird deine ISR mehr als 50 Takte zur Ausführung benötigen.

  4 * Push
+ 4 * LDS
+ 4 * SUBI/SBCI
+ 4 * STS
+ 4 * POP
+ Prolog, Epilog
= 61 Zyklen.