32 Bit Timer Attiny (Zeitstempel)

[Pate (Gast)]

Hallo,

ich bin gerade dabei mir ein 32 Bit Zeitstempel zu programmieren. Das 
funktioniert auch fast perfekt. Um den Code zu testen, habe ich mir eine 
Warteschleife programmiert, die eine LED alle X Mikrosekunden 
ausschaltet und dann sofort wieder einschaltet. Das funktioniert auch 
nur soweit, nur zwischen drin, kommt es immer wieder zu einem 
Doppelpuls(Siehe Oszibild). Woher kommt der Ausreißer?



Timer Klasse: CPP-Datei

static Systemtimer* pSystemtimer;

uint32_t Systemtimer::SystemtimerGetTime()
{
  uint32_t time;
  cli();
  
    time=(uint32_t)(TCNT1)+pSystemtimer->Time;
  sei();
  return time;
}

ISR(TIMER1_OVF_vect)
{
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
  {  
    pSystemtimer->Time+=0x10000;

  }
  
}

Header Datei:

class Systemtimer
{

  uint32_t SystemtimerGetTime();
  
  //Use Time in atomic Block
  volatile uint32_t Time;


}; //Systemtimer

Main:

uint32_t nexttime,current,waiting=100;

  
  current=timestamp.SystemtimerGetTime();  

    while(1)
    {
  LED.SetLed(false);

  do
  {
    LED.SetLed(true);
    nexttime=timestamp.SystemtimerGetTime();
  } while (nexttime-current<waiting);
  current=nexttime;

    }

[Dr. Sommer (Gast)]

Pate schrieb:
> cli();
>
>     time=(uint32_t)(TCNT1)+pSystemtimer->Time;
Was wenn "zwischen" diesen beiden Zeilen der Timer überläuft, TCNT1 also 
0 zurückliefert, aber der Timerinterrupt noch nicht ausgeführt wurde, 
also pSystemtimer->Time noch nicht um 0x10000 erhöht wurde? Dann erfährt 
deine Zeit einen Sprung rückwärts...

[Peter II (Gast)]

ATOMIC_BLOCK mach in einer ISR wenig sinn.


> time=(uint32_t)(TCNT1)+pSystemtimer->Time;
wenn TCNT1 überläuft während die Berechnung läuft könnte das zu 
Problemen kommen. Da hilft auch das cli und sei nicht weil er Trotzdem 
weiterzählt.

[Pate (Gast)]

Achso, dann muss ich das Überlaufbit mit betrachten.

[Pate (Gast)]

Das Atomic war eher eine Verzweiflungstat...

[Dr. Sommer (Gast)]

Pate schrieb:
> Achso, dann muss ich das Überlaufbit mit betrachten.
Das bringt leider auch nix, was wenn der Überlauf kommt zwischen der 
Abfrage des Bits und Abfrage von TCNT1 - egal in welcher Reihenfolge 
dies stattfindet?
Eigentlich müsstest du den Timer temporär anhalten...

[Pate (Gast)]

Ich habe es mal wie folgt angepasst:

uint32_t Systemtimer::SystemtimerGetTime()
{
  uint32_t time;
  cli();
  if (TIFR1 & (1<<TOV1))
  {
    pSystemtimer->Time+=0x10000;
    TIFR1=(1<<TOV1);
  }
  time=(uint32_t)(TCNT1)+pSystemtimer->Time;
  
  sei();
  return time;
}

Und laut Oszi, gibt es keine Ausreißer mehr, nur ein Jitter durch die 
If-Abfrage.

[Pate (Gast)]

Zu früh gefreut, ich muss wohl doch den Timer anhalten.

[Pate (Gast)]

Wie könnte ich denn das Problem lösen?

[Georg G. (df2au)]

Wie wäre es mit "zweimal ablesen". Dann kannst du per Plausibilität 
entscheiden, ob und bei welcher Ablesung dein Timer übergelaufen ist.

[greg (Gast)]

Wie wäre es mit einem zweiten Timer-Register, bei dem du per 
Flag-Register die Aktualisierung stoppst, wenn du Auslesen möchtest? 
Oder lass deinen Code zum Auslesen mit dem IRQ synchronisieren. Da gibt 
es viele Möglichkeiten, Timer anhalten würde ich nie machen, wenn's denn 
genau sein soll.

PS: Mit ARM wäre das nicht passiert (SCNRT) ;)

[Klaus 2. (klaus2m5)]

Man könnte nach dem Einlesen des tcnt1 während disabled interrupts und 
wenn der tcnt <max/2 ist, das tifr überprüfen, ob ein Überlauf 
stattgefunden hat und noch nicht abgearbeitet wurde. In diesem Falle 
muss der zu speichernde timerwert entsprechend erhöht werden.

[Pate (Gast)]

Das ein Timer soo viel ärger machen kann...

Das mit der Synchronisierung versuche ich derzeit. Ich habe mir in der 
Klasse eine Funktion gebaut, die Reibungslos funktioniert. Nur wenn ich 
mir eine Warte FUnktion in der Main baue, gehts daneben...

void Systemtimer::SystemtimerWait(uint32_t Wait_us)
{  
  uint32_t nexttime=this->SystemtimerGetTime()+Wait_us;
  
  while(this->SystemtimerGetTime()<nexttime)
  {
  }

}

[m.n. (Gast)]

greg schrieb:
> PS: Mit ARM wäre das nicht passiert (SCNRT) ;)

Wie, ARM baut auch Timer? Du meinst 'systick'?

Die Überlaufe eines Timers sind doch kein Problem, man muß sie nur 
beachten!

In der Routine "ISR(TIM1_CAPT_vect)" kann man sehen, wie es geht:
http://www.mino-elektronik.de/fmeter/fm_software.htm#bsp11

Georg G. schrieb:
> Wie wäre es mit "zweimal ablesen". Dann kannst du per Plausibilität
> entscheiden, ob und bei welcher Ablesung dein Timer übergelaufen ist.

Auch das kann man machen, wenn es nicht zeitkritisch ist.

[Nils Friess (Gast)]

Und wenn du den Timer stoppst und anschließend zu TCNT1 x addierst, 
wobei x die Anzahl der Takte ist, die es von Stoppen bis nach der 
Berechnung braucht (x könnte man aus dem Assemblerlisting berechnen)?

[Peter D. (peda)]

Beitrag "AVR Timer mit 32 Bit"

[Pate (Gast)]

WIe soll ich denn das Capture Event auslösen?

[Pate (Gast)]

So jetzt gehts stabil, habe nochmal die Timer32.c übernommen und auf 
meine Sourcen angepasst.

uint32_t Systemtimer::SystemtimerGetTime()
{

    uint32_t val;
    uint8_t tifr;

    cli();
    val = pSystemtimer->Time + TCNT1;
    tifr = TIFR1;          // read interrupt flags
    sei();
    if( (tifr & 1<<TOV1) && !(val & 0x8000) )
    val += 32768;         

}

[Pate (Gast)]

Thread kann geschlossen werden :)

[Pate (Gast)]

Die Timer32, produziert den gleichen Fehler... Schon wieder zu früh 
gefreut...


uint32_t Systemtimer::SystemtimerGetTime()
{

    uint32_t val;
    uint8_t tifr;

    cli();
    val = pSystemtimer->Time + TCNT1;
    tifr = TIFR1;          // read interrupt flags
    sei();
    if( (tifr & 1<<TOV1) && !(val & 0x8000) )
    val += 32768;
  return val;

}

[Peter D. (peda)]

Pate schrieb:
> val += 32768;

???

[Ulrich H. (lurchi)]

Im Prinzip ist die Idee mit dem Interruptflag und der Größe schon 
richtig. Nur eine Timerüberlauf bringt nicht 32768 Schritte, sondern das 
doppelte.

[Pate (Gast)]

Egal was ist da Eintrage, jedesmal kommt der Fehler...

uint32_t Systemtimer::SystemtimerGetTime()
{

    uint32_t val;
    uint8_t tifr;

    cli();
    val = pSystemtimer->Time + TCNT1;
    tifr = TIFR1;
    sei();

    if( (tifr & 1<<TOV1) && !(val & 0x80) )
    val += 256;    
          bzw.
          if( (tifr & 1<<TOV1) && !(val & 0x8000) )
    val += 32768;    
          bzw.
          if( (tifr & 1<<TOV1) && !(val & 0x80) )
    val += 32768;   
   
  return val;
}

[Pate (Gast)]

Pate schrieb:
> Egal was ist da Eintrage, jedesmal kommt der Fehler...
> uint32_t Systemtimer::SystemtimerGetTime()
> {
>
>     uint32_t val;
>     uint8_t tifr;
>
>     cli();
>     val = pSystemtimer->Time + TCNT1;
>     tifr = TIFR1;
>     sei();
>
>     if( (tifr & 1<<TOV1) && !(val & 0x80) )
>     val += 256;
>           bzw.
>           if( (tifr & 1<<TOV1) && !(val & 0x8000) )
>     val += 32768;
>           bzw.
>           if( (tifr & 1<<TOV1) && !(val & 0x80) )
>     val += 32768;
>
>   return val;
> }

Habe es jetzt mit dem doppelten getestet:

uint32_t Systemtimer::SystemtimerGetTime()
{

    uint32_t val;
    uint8_t tifr;

    cli();
    val = pSystemtimer->Time + TCNT1;
    tifr = TIFR1;
    sei();
    if( (tifr & 1<<TOV1) && !(val & 0x8000) )
    val += 65536;       
  return val;
}

Jetzt taucht kein Fehler mehr auf. 15000 Passes keine Fails :)