Input Capture Atmega16

[Micha S. (e-tec)]

Hallo zusammen,

nach langer Zeit mal wieder melde ich mich zurück :)

Ich habe ein kleines Problem mit dem Input Capture.
Irgendwie will er nicht so richtig funktionieren... Ich versuche eine 
komplette PWM zu messen, die erste steigende Flanke, dann schalte ich 
den Input um, warte auf die fallende Flanke und zum Schluß warte ich auf 
die nächste steigende Flanke...
Variablen sind natürlich als volatile definiert... t1_counter8 ist der 
Überlauf Zähler vom 16Bit Timer... wenn ich was vergessen habe einfach 
fragen :)

Hier mal der Code für den Input Capture:

// Timer/Counter1 Capture Event (IPC)
ISR(TIMER1_CAPT_vect)
{  //===========================
   //capture first positive edge
   if( (!bit_is_set(IPC_ISR_flag, timer1_capt_1st_edge))
    && (!bit_is_set(IPC_ISR_flag, ipc_messure_complete)) )
   {
      IRQ_disable();            // Interrupts deaktivieren
      first_pos_edge  = ICR1;   // 16Bit Register auslesen
      IRQ_enable();             // Interrupts aktivieren

      t1_counter8     = 0;

      clrbit(TCCR1B, ICES1);    // Auf negative Flanke umschalten
      setbit(IPC_ISR_flag, timer1_capt_1st_edge);

      togbit(PORTC, PIN0);
   }
   //=====================
   // capture falling edge
   else
   if( ( bit_is_set(IPC_ISR_flag, timer1_capt_1st_edge))
    && (!bit_is_set(IPC_ISR_flag, ipc_messure_complete)) )
   {
      IRQ_disable();            // Interrupts deaktivieren
      first_neg_edge  = ICR1;   // 16Bit Register auslesen
      IRQ_enable();             // Interrupts aktivieren

      first_neg_t1cnt = t1_counter8;
      setbit(TCCR1B, ICES1);   // Wieder auf positive Flanke umschalten

      clrbit(IPC_ISR_flag, timer1_capt_1st_edge);
      setbit(IPC_ISR_flag, ipc_messure_complete);
   }
   //===========================
   // capture second rising edge
   else
   if( (!bit_is_set(IPC_ISR_flag, timer1_capt_1st_edge))
    && ( bit_is_set(IPC_ISR_flag, ipc_messure_complete)) )
   {
      IRQ_disable();            // Interrupts deaktivieren
      second_pos_edge = ICR1;   // 16Bit Register auslesen
       IRQ_enable();             // Interrupts aktivieren

      second_pos_t1cnt=t1_counter8;

    // Berechnungen
      period_time     = (t1_counter8 * 65535);
      period_time    += ((second_pos_t1cnt * 65535) + second_pos_edge);
      period_time    -= first_pos_edge;
      tastverhaeltnis = (ui32)((ui64)(100 * first_neg_edge + first_neg_t1cnt * 65535) / period_time);
      clrbit(IPC_ISR_flag, ipc_messure_complete);
   }
}

[Karl H. (kbuchegg)]

Kommt der µC überhaupt in die ISR?

Die Berechnung hat da drinn auch nichts verloren!
Lass dir halt mal die Einzelwerte ausgeben. Dich interessieren die 
Timerticks, die du für die High-Phase gemessen hast und die Timer Ticks, 
die du für die Low Phase gemessen hast. Dann sieht man auch schon mal, 
ob man sich bei den Flags vertan hat, und die Werte dauernd die Plätze 
wechseln. Wenn man ganz hinten in einer Berechnung Blödsinn rauskriegt, 
dann schaut man sich halt mal die Eingangswerte in diese Berechnung an. 
Denn wenn die schon falsch sind, dann ist klar, dass hinten nichts 
richtiges rauskommen kann. Diese Binsenweisheit scheint aber zu einfach 
zu sein, interessanterweise muss man das den Leuten immer wieder 
beibringen.

Du solltest auch bedenken, dass dir die Umschaltung der Flankenrichtung 
einen Interrupt bescheren kann. Wenn man sich die gemessenen Timerticks 
ansehen würde, könnte man das in den Zahlenwerten sehen, wenn die 
Differenzen lächerlich unrealistisch gering sind.

In einer ISR sind die Interrupts sowieso ausgeschaltet. Du brauchst da 
nichs aktivieren oder deaktivieren. Ganz im Gegenteil: in einer iSR die 
Interrupts wieder zu aktivieren, kann gefährlich sein.

Stell den ganzen Timer auch so, dass du Overflows im Zählbereich erst 
mal ignorieren kannst. Eine PWM ändert sich ja normalerweise nicht in 
der Frequenz. d.h. das kann man so einstellen, dass ein kompletter PWM 
Zyklus nicht länger als 65535 Timertakte dauert. Dann bist du das 
Problem der fast (aber doch nicht) gleichzeitigen Capture und Overflow 
Interrupts fürs erst mal los (was nicht heisst, dass man sich nicht 
später doch noch drum kümmert).

Alles in allem wieder mal Kardinalfehler Nummero Uno: zuviel auf einmal 
geschrieben ohne zwischendurch zu testen. Nichts geht und in dem ganzen 
Wust weiss man nicht wo man mit der Fehlersuche anfangen soll. Alles was 
man weiss ist, dass ganz hinten am Ende einer längeren Kette von 
Ereignissen nicht das richtige rauskommt - Hilfe!

volatile Variable 'Begin'    // Timerstand bei der ersten steigenden Flanke
volatile Variable 'EndPuls'  // Timerstand am Ende des Highpulses
volatile Variable 'Ende'     // Timerstand nach der Low-Phase (beendet durch steigende Flanke)
volatile Variable 'Wertetriplett ist komplett'

ISR( ... )
{
  if( steigende Flanke ) {
    if( ersteFlanke ) {
      if( Wertetriplet nicht komplett ) {   // Sicherung, dass die main mit
                                             // der Auswertung hinterher gekommen ist
        Wert für Begin merken
        umschalten auf fallend
        merken, dass erste Flanke durch
      }
    }
    else {
      Wert für komplett Ende merken
      nächste steigende Flanke ist wieder erste Flanke
      signalisieren, dass das Wertetriplet komplett ist
    }
  }

  else {   // muss eine fallende Flanke gewesen sein
    (sicherheitshalber könnte man überprüfen, dass die erste Flanke
     bereits gekommen sein muss. Denn 1 fallende Flanke muss ja
     ausgelassen werden)
    Wert für EndPuls merken
    umschalten auf steigend
  }
}

main
{
  ....

  while( 1 ) {

    if( Wertetriplet komplett ) {
      ausgeben ( Begin )
      ausgeben ( EndPuls )
      ausgeben ( Ende )

      Wertetriplet = nicht komplett
    }
  }
}

dann sieht man sich mal die gemessenen Timerwerte an.

Beachte auch, dass man sich die ganze Sache mit der ersten steigenden 
Flanke auch sparen könnte. Denn die steigende Flanke, die die Low-Phase 
beendet, ist ja auch gleichzeitig die steigende Flanke, die den nächsten 
Puls beginnt.