STM32F4 Timer OVF Fehler

[Mark W. (mark_wer)]

Hallo,

ich habe grad ein Problem, bei dem ich meinen Fehler nicht finde. 
Vielleicht kann mir ja einer von euch helfen. Ich messe mit Hilfe des 
Capture Interrupts eine Zeit zwischen zwei Flanken. Geht auch fast 
alles, bis auf ganz wenige Male, bei denen der Wert zwar richtig wär, 
aber um eine ganze OVF Periode abweicht. Also irgendwie muss der Wert 
OVF gesetzt sein, obwohl er das nicht dürfte und dann wird in der 
if-Abfrage berechnet und der Wert von OVF ist 1, obwohl er eigentlich 0 
sein sollte.

Hier mein Code inkl. Init:

void InterruptInit(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  TIM_ICInitTypeDef TIM_ICInitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

  // Clock Enable
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

  // Clock enable
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);

  // Config PD13 als Digital-Ausgang
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOD, &GPIO_InitStructure);

  // Config des Pins PE11 als AF-Input
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOE, &GPIO_InitStructure);

  // Connect PE11 with TIM1 for Input Capture
  GPIO_PinAFConfig(GPIOE, GPIO_PinSource11, GPIO_AF_TIM1);

  TIM_TimeBaseStructure.TIM_Period = 0xFFFF;
  TIM_TimeBaseStructure.TIM_Prescaler = 0;            
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
  TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);

  NVIC_InitStructure.NVIC_IRQChannel = TIM1_CC_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_TIM10_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  // Channel 2
  TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
  TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
  TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStructure.TIM_ICFilter = 0x02;        //0x02 = 4 consecutive events are needed to validate a transition on the output
  TIM_ICInit(TIM1, &TIM_ICInitStructure);

  //Interrupt Enable
  TIM_ITConfig(TIM1, TIM_IT_CC2, ENABLE);
  TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);

  // Timer enable
  TIM_Cmd(TIM1, ENABLE);
}

//-----------------
// TIM1 OVF Handler
//-----------------
void TIM1_UP_TIM10_IRQHandler(void)
{
  if (TIM_GetITStatus(TIM1, TIM_IT_Update) != RESET)
  {
    // Delete Interrupt Flags
    TIM_ClearITPendingBit(TIM1, TIM_IT_Update);

    OVF_cnt++;
  }
}

//-------------------------------
// TIM1 Capture Interrupt Handler
//-------------------------------
void TIM1_CC_IRQHandler(void)
{
  if (TIM_GetITStatus(TIM1, TIM_IT_CC2) != RESET)
  {
    __disable_irq();

    // Delete Interrupt Flags
    TIM_ClearITPendingBit(TIM1, TIM_IT_CC2);

    uint16_t new = TIM_GetCapture2(TIM1);
    uint8_t OVF = OVF_cnt;

    OVF_cnt = 0;

    if(UB_USB_CDC_GetStatus()==USB_CDC_CONNECTED)
    {
        uint16_t time = 0;

        if(OVF)
        {
          if(ICRnew > ICRold)
          {
            GPIO_ToggleBits(GPIOD, GPIO_Pin_14);

            time = (new - old);
          }
          else
          {
            time = ~(old - new);
            OVF--;       // Periodextra has to be decreased by one because one OVF is already included in the calculation
          }
        }
        else
        {
          time = (new - old);
        }  
    }  
    old = new;
    __enable_irq();
  }
}

Würde mich über Hilfe freuen und schon mal Danke im Vorraus
Mark

[Mark W. (mark_wer)]

Ok, also das Problem müsste in den folgenden Zeilen liegen:

 if(OVF)
        {
          if(new > old)
          {
            GPIO_ToggleBits(GPIOD, GPIO_Pin_14);

            time = (new - old);
          }
          else
          {
            time = ~(old - new);
            OVF--;       // Periodextra has to be decreased by one because one OVF is already included in the calculation
          }
        }
        else
        {
          time = (new - old);
        }

Wenn ich es umschreibe zu:

 if(OVF)
        {
         //if(new > old)
         // {
            GPIO_ToggleBits(GPIOD, GPIO_Pin_14);

          // time = (new - old);
          //}
          //else
          //{
            time = ~(old - new);
            OVF--;       // Periodextra has to be decreased by one because one OVF is already included in the calculation
          //}
        }
        else
        {
          time = (new - old);
        }

funktioniert alles bei hohen Frequenzen, für Frequenzen, die aber über
einen OVF gehen brauche ich diese Zeilen. Aber das müsste ja heißen,
dass der Vergleich "new > old" fälschlicherweise als true bewertet wird?
Hat vielleicht jemand eine Idee, warum?

[Little B. (lil-b)]

Ich sehe hier einen systematischen Fehler, nämlich dass "time" zu klein 
deklariert ist (nur uint16). Somit wird alles, was über eine Periode 
hinausgeht, oben abgeschnitten. Probiers mal mit uint32.

Desweiteren ist diese Berechnung falsch (jedenfalls nicht konsistent mit 
den anderen berechnungen):

time = ~(old - new);

Ich würde das so schreiben (time als uint32 vorausgesetzt):

time = ((uint32_t)new + (OFV<<16)) - old;

dann brauchst du auch diese unterscheidung nicht mehr:

if(new > old)

[Nop (Gast)]

Poste mal als Anhang (!!) den GANZEN Quellcode. Da fehlt doch die 
Hälfte, beispielsweise die kompletten Variablendeklarationen mitsamt 
deren Datentypen.

[Little B. (lil-b)]

Little B. schrieb:
> dann brauchst du auch diese unterscheidung nicht mehr:
>

>if(new > old)
>

tatsächlich brauchst du dann gar keine unterscheidung mehr.
Aus diesem code von dir:

        uint16_t time = 0;

        if(OVF)
        {
          if(ICRnew > ICRold)
          {
            GPIO_ToggleBits(GPIOD, GPIO_Pin_14);

            time = (new - old);
          }
          else
          {
            time = ~(old - new);
            OVF--;       // Periodextra has to be decreased by one because one OVF is already included in the calculation
          }
        }
        else
        {
          time = (new - old);
        }

kann dieser code werden:

uint16_t time = 0;
time = ((uint32_t)new + (OFV<<16)) - old;

[Mark W. (mark_wer)]

Erstmal Dankeschön für eure Anmerkung, ist die bessere Lösung :) Aber 
der Fehler tritt trotzdem noch auf, allerdings bin ich schon einen 
kleinen Schritt weiter, der Fehler tritt nämlich nur auf, wenn new = 
0xFFFF ist. D.h. der OVF Interrupt wird schon in der Berechnung 
berücksichtigt, obwohl er erst danach auslösen sollte wegen 
Priority(zumindest war das eigentlich mein Gedanke!?). Irgendwo hab ich 
also immer noch einen Denkfehler..

Das ganze Projekt hab ich nicht angehängt, da ich dachte/denke der 
Fehler befindet sich in dem geposteten Teil, kann ich später aber ggf. 
noch hinzufügen. Die zwei Variablendefinitionen gehen oben aber noch ab:

volatile uint8_t OVF_cnt = 0;
volatile uint16_t old = 0;

[Mark W. (mark_wer)]

Hat vielleicht jemand eine Idee? Ich komm leider gar nicht weiter. 
Nochmal kurz als Beispiel für den Fehler. Der Timer läuft mit 16MHz und 
wenn ich beim Funktionsgenerator z.B. 12kHz einstelle wird mir am Pc 
über USB meistens das richtige Ergebnis "1333" angezeigt. Teilweise 
kommt am PC aber der Wert "66869" an, also genau ein OVF, der da 
eigentlich nicht sein dürfte und das passiert nur, wenn der Wert 
new=65535 ist.. Würde mich sehr über Anregungen/Lösungen freuen :)

[FloMann (Gast)]

Prüfe mal folgendes...
Capture interrupt kommt kurz vor überlauf, bevor du noch im interrupt
handler für capture an der stelle disable interrupt bist kommt der timer
Overfow int... hab jetzt nicht genau geschaut, hat dein timer ovr 
interrupt
höhere prio und kann denn capture interupt unterbrechen? So würde ovr 
cnt
hoch gezählt werden und es käme zu dem einen Überlauf Versatz.

Gruß florian

[Mark W. (mark_wer)]

Hallo Florian,

So ähnlich ist auch mein Gedanke, also irgendwie muss der OVF Interrupt 
den Capture Interrupt unterbrechen, aber eigentlich hab ich dem 
Zeitmessen die höchste Priorität gegeben, also die Priority vom 
Interrupt Capture ist niedriger. Hab jetzt noch was ausprobiert, wenn 
ich folgenden Code einfüge hinter dem Zuweisen von OVF und new

if ((ICRnew == 0xFFFF) && (periodextra > 0))
{
  periodextra--;
}

bekommt der OVF bei new=0xFFFF den Wert 0x11111111. Vielleicht hilft der 
Fehler beim erkennen des eigentlichen Problems...

Gruß
mark

[m.n. (Gast)]

Es ist mir etwas zu mühselig, Deinen Code Stück für Stück durchzugehen. 
Wie man den Überlauf bei Timern richtig erfassen kann, ist hier gezeigt: 
Beitrag "reziproker Frequenzzähler mit STM32F4Discovery"

[Peter D. (peda)]

Das Problem ist immer das gleiche, man kann einen HW-Timer und eine 
Variable nicht gleichzeitig auslesen. Daher muß man feststellen, ob der 
Interrupt zum Hochzählen der Variable schon ausgeführt wurde oder noch 
nicht:

Beitrag "AVR Timer mit 32 Bit"

[Mark W. (mark_wer)]

Vielen Dank für eure Hilfe, jetzt läuft alles gut! :)
Habe hier am Anfang zwar zwei Zeilen vertäuscht, normalerweise hatte ich 
schon die SubPriority bei Capture auf 0 und bei OVF bei 1, aber es lief 
trotzdem nicht, mit der Funktion NVIC_SetPriority() läuft es jetzt.
@peter: den OVF hatte ich schon berücksichtigt im CaptureInterrupt, also 
falls OVF Flag gesetzt ist, überprüfen ob vor oder nach CaptureInterrupt 
mit new < 0x8000. Aber dazu hätte ich noch eine Frage, warum genau 
0x8000/0x80 bei deinem Beispiel? Weil man davon ausgeht, dass der Code 
nicht so lange zum ausführen braucht, sodass man die Hälfte des Zählers 
wählt oder funktioniert das immer, auch wenn der Code theoretisch 40000 
Zählschritte zum ausführen bräuchte?

[Peter D. (peda)]

Mark W. schrieb:
> oder funktioniert das immer

Nein, diese Methode ist auf den halben Zählbereich begrenzt, in der Zeit 
muß der Overflowinterrupt behandelt worden sein.
Falls das Auslesen in einem Captureinterrupt erfolgt, sollte dieser die 
gleiche Priorität haben, d.h. die beiden dürfen sich nicht gegenseitig 
unterbrechen können. Das atomar Kapseln entfällt dann.