ISR wird nach einem Pinchange Interrupt 2x ausgeführt?

[H. G. (ledi)]

Hallo!

Ich verwende den ATtiny44 und über den PCINT0 wird eine ISR bei 
positiver Flanke ausgelöst und eine AD-Wandlung durchgeführt.
Wird ein Interrupt ausgelöst, springt mein Debugger nach Ausführung der 
ISR nochmals in die ISR. Erst danach wird das Programm weiter 
ausgeführt.

Hat jemand einen Tip was da sein könnte?

[Peter D. (peda)]

H. G. schrieb:
> Hat jemand einen Tip was da sein könnte?

Ja, Deine (jede) Taste prellt.
Deshalb Tasten nie mit einem externen Interrupt abfragen!
Sondern mit einem Timerinterrupt entprellen.


Peter

[Frank M. (ukw) (Moderator)]

H. G. schrieb:
> Ich verwende den ATtiny44 und über den PCINT0 wird eine ISR bei
> positiver Flanke ausgelöst und eine AD-Wandlung durchgeführt.
> Wird ein Interrupt ausgelöst, springt mein Debugger nach Ausführung der
> ISR nochmals in die ISR. Erst danach wird das Programm weiter
> ausgeführt.

Bei einem PCINT kann man nicht vorgeben, ob er bei einer steigenden oder 
fallenden Flanke aufgerufen wird. Er wird in jedem Fall bei beiden 
Flanken aufgerufen.

> Hat jemand einen Tip was da sein könnte?

Wenn obiges nicht zutrifft, muss es an der Zeile 42 in Deinem Programm 
liegen ;-)

[Dirk .. (kcc)]

Ggf. den Interupt in der ISR beim ersten Aufruf erstmal deaktivieren und 
mit einem Timer nach n ms wider aktivieren, wenn der PCINT nicht noch 
andere Pins abfragen muss die während der Deaktivierungszeit eintreffen 
könnten.

Dann hätte man auch das Tastenentprellen mit erledigt.

[H. G. (ledi)]

Peter Dannegger schrieb:
> ...Sondern mit einem Timerinterrupt entprellen.

Hallo Peter!

Ich habe mir deine Komfortroutine etwas angesehen, aber das ist 
natürlich ein overkill für eine einzige Taste welche am PCINT0 hängt.

Hast du ein Beispiel mit einem Timer Interrupt in C für eine Taste?

[Peter D. (peda)]

H. G. schrieb:
> Ich habe mir deine Komfortroutine etwas angesehen, aber das ist
> natürlich ein overkill für eine einzige Taste welche am PCINT0 hängt.

Das ist so wenig Code, das ist selbst für nur eine Taste effizient.
Den Repeat-Teil kann man ja weglassen, wenn man ihn nicht benötigt.


Peter

[Udo S. (urschmitt)]

H. G. schrieb:
> Hast du ein Beispiel mit einem Timer Interrupt in C für eine Taste?

Der nächste Software-Guttenberg.
Und was er kopieren kann ist ihm nicht einfach genug, deshalb fragt er 
nach etwas noch einfacherem...
Ohne Worte

[H. G. (ledi)]

Ich habe jetzt versucht, gleich am Anfang der ISR alle Interrupts zu 
deaktivieren und nicht wieder zu aktivieren.

Trotzdem springt der Debugger ein 2. Mal rein. ???
Kann ja normal nicht sein, oder?

Hier meine ISR:

// ***********     Pin change INT0 service routine      *************
ISR (PCINT0_vect)
{
    cli();
    ADMUX   &= !(1<<MUX0);             // Auf ADC-Kanal 0 umschalten

    ADCSRA |= (1<<ADSC);                  // Start ADC-Converter
      while (ADCSRA & (1<<ADSC));          // wait for ADC-Conversion
      x = ADC;                // Dummy read out

    ADCSRA |= (1<<ADSC);                  // Start ADC-Converter
      while (ADCSRA & (1<<ADSC));          // wait for ADC-Conversion
      switch_value2 = ADC;          // Value for endswitch
    
    ADCSRA |= (1<<ADSC);                  // Start ADC-Converter
      while (ADCSRA & (1<<ADSC));          // wait for ADC-Conversion
      switch_value3 = ADC;          // Value for endswitch
    
    switch_value = (switch_value2 + switch_value3) / 2;    // ADC Durchschnittswert berechnen

    if ( (switch_value >= 849) && (switch_value <=988) )  // 4,15V ... 4,8V
    {
      ES1 = 1;
      ES2 = 0;
    }

    if ( (switch_value >= 661) && (switch_value <=767) )  // 3,23V ... 3,75V
    {
      ES2 = 1;
      ES1 = 0;
    }

    ADMUX   |= (1<<MUX0);             // Auf ADC-Kanal 1 umschalten

    ADCSRA |= (1<<ADSC);                  // Start ADC-Converter
      while (ADCSRA & (1<<ADSC));          // wait for ADC-Conversion
      x = ADC;                // Dummy read out
    
    //sei();
}

[H. G. (ledi)]

Udo Schmitt schrieb:
> H. G. schrieb:
>> Hast du ein Beispiel mit einem Timer Interrupt in C für eine Taste?
>
> Der nächste Software-Guttenberg.
> Und was er kopieren kann ist ihm nicht einfach genug, deshalb fragt er
> nach etwas noch einfacherem...
> Ohne Worte

Ich fragte nach einem Beispiel und nicht nach einem fertig angepassten 
Code! Ist dir langweilig oder warum müllst du das Forum mit solch 
unqualifizierten Ansagen voll? Oder darf man hier im Forum nicht fragen? 
Ist das ein Forum nur für Profis? Anfänger raus?

[Karl H. (kbuchegg)]

H. G. schrieb:

> Hier meine ISR:

Un du machst dir Sorgen um die 20 (Assembler-)Instruktionen (auf die der 
C-Code hinausläuft) in der PeDa Entprell-Lösung?

[Stefan E. (sternst)]

H. G. schrieb:
> Kann ja normal nicht sein, oder?

Doch, denn das Sperren der Interrupts (und gesperrt sind sie in der ISR 
sowieso, dein cli() macht also in Wirklichkeit gar nichts) hat keinen 
Einfluss darauf, dass beim Eintreffen eines Ereignisses das 
entsprechende Interrupt-Flag gesetzt wird.

[H. G. (ledi)]

20?

Da hab ich dann wohl ein anderes Beispiel angesehen!
Hast du einen Link?

[Peter D. (peda)]

H. G. schrieb:
> Kann ja normal nicht sein, oder?

Doch, siehe Abschnitt:
4.8 Reset and Interrupt Handling

Es gäbe da einen dirty Hack: direkt vor dem Enable das Interruptflag 
setzen.


Peter

[Thomas E. (thomase)]

H. G. schrieb:
> Hast du einen Link?
Kriegst du auch irgendwas alleine hin?

mfg.

[Karl H. (kbuchegg)]

H. G. schrieb:
> 20?
>
> Da hab ich dann wohl ein anderes Beispiel angesehen!
> Hast du einen Link?

Auf wieviele Assembler Instruktionen läuft das wohl im Compiler raus.

ISR( TIMER0_OVF_vect )                            // every 10ms
{
  static uint8_t ct0, ct1, rpt;
  uint8_t i;
 
  i = key_state ^ ~KEY_PIN;                       // key changed ?
  ct0 = ~( ct0 & i );                             // reset or count ct0
  ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
  i &= ct0 & ct1;                                 // count until roll over ?
  key_state ^= i;                                 // then toggle debounced state
  key_press |= key_state & i;                     // 0->1: key press detect
 
  if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
     rpt = REPEAT_START;                          // start delay
  if( --rpt == 0 ){
    rpt = REPEAT_NEXT;                            // repeat delay
    key_rpt |= key_state & REPEAT_MASK;
  }
}

Den Aufwand in der ISR kannst du vernachlässigen, das kostet deinen µC 
weniger als 1% Rechenzeit. Und das geile ist: Das funktioniert von 1 bis 
8 Tasten ohne Codeänderung. Selbst bei 1 Taste lohnt sich der Code 
schon, weil die Entprellung zuverlässig funktioniert und du keinen 
Tastendruck deines Benutzers verpasst. Und einen Auto-Repeat der bei 
gedrückter Taste dem Programm weitere Tastendrücke vorgaukelt, kriegst 
du automatisch mit dazu (besonders cool bei Zahleneingaben mittels 
Up-Down einzusetzen)

Oft genug bewährt, oft genug eingesetzt. Es lohnt ganz einfach nicht, 
sich da auch nur den geringsten Gedanken über eine andere Lösung zu 
machen. Dieses Ding ist in 10 Minuten in einen Code integriert und 
funktioniert bullet-proof.

[H. G. (ledi)]

DANKE! Das hilft mir weiter!

[Karl H. (kbuchegg)]

stammt von
Entprellung

Lass dich nicht von der Anzahl der C Zeilen blenden. Entscheidend ist, 
was nach dem Compilieren übrig bleibt. Und das ist nicht viel.