Externer Interrupt oder TimerInterrupt und Pin abfragen?

[Felix (Gast)]

Guten abend,
ich wollte mal fragen, ob ihr externe Interrupts benutzt. Z.B. Um die 
dauer eines gedrückten Tasters oder eines Signals zu ermitteln.

Normalerweise würde ich bei bei einer Flanke den Interrupt auslösen, 
einen Timer starten und bei der erneuten Flanke den Timer stoppen und 
die zeit auslesen. Jetzt habe ich aber öfters schon gehört, dass das 
nicht so gut ist, wegen Störungen. So wird z.B. ein Timer genommen, der 
jede Millisekunde eine ISR aufruft und in dieser wird der Zustand des 
Pins vom Kontroller kontrolliert. Ist dieser anders als der vorige 
Zustand, kam es zu einem Flankenwechsel.

Was sind denn sonst noch Vor-/Nachteile? Je nachdem würde ich es bei mir 
noch umbauen.

Gruß
Felix

[Nico W. (nico_w)]

Nehm doch einfach beides. Mit nem externen Interrupt einen Timer starten 
und zB die Entprell-Routine aus dem Wiki hier einbauen.

[Stefan S. (chiefeinherjar)]

https://www.mikrocontroller.net/articles/Entprellung

In diesem Artikel steht alles drin. Incl. aller Vor- und Nachteile.

[Jacko (Gast)]

Für Tasten gibt es bewährte Erfassungs-Routinen, die auch
das Entprellen von Tastern (meist lösen die beim Drücken und
beim Loslassen jeweils mehrere Pegelsprünge aus) besorgen.
Hier wird mit Hilfe eines internen Timer-Interrupts geprüft,
ob sich der jeweilige Tastenzustand über mehrere ms stabilisiert
hat.

Für Signale von außen kann auch ein externer Interrupt
günstig sein, um SOFORT zu reagieren. Wenn man weiß, wie oft
sich das Signal maximal ändern kann, kann man in der Interrupt-
Routine prüfen, ob das Ereignis genügend Zeit-Abstand zum
vorigen Ereignis hat. Wenn nicht, wird es ignoriert.

[georg (Gast)]

Felix schrieb:
> Z.B. Um die
> dauer eines gedrückten Tasters oder eines Signals zu ermitteln

Das ist eben die Frage, was - Taster prellen, werden aber von Hand 
bedient, da muss man keineswegs besonders schnell reagieren, im 
Gegenteil. Da ist ein Timer geeignet, der einen Zähler pro Taste 
auf/abwärts zählt, dafür gibt es genügend Beispielprogramme zur 
Entprellung. Normalerweise werden in diesem Timer nicht nur eine, 
sondern alle Tasten abgefragt, auch eine komplette PC-Tastatur ist kein 
Problem.

Muss man auf ein Signal schnell reagieren, so ist ein externer Interrupt 
geeignet, aber dann muss das Signal prellfrei sein. Beides, schnelle 
Reaktion und Entprellung/Entstörung, geht nicht.

Georg

[Michael F. (sharpals)]

wie schmutzig ist denn das signal und wie lange soll die taste gedrückt 
sein ?

Ich mache es meist so, unterbrechungsroutine starten. Wenn ausgelöst, 
dann ISR abschalten ,1 - 100ms ( je nach anwendung , weniger, oder 
länger ) warten, machsehen, ob taster gedrückt und dann aktion 
ausführen, und nicht vergessen, den ISR wider einzuschalten.

Gruß Michael

[Carl D. (jcw2)]

Interessant wäre zu erfahren, welche "Drückzeit" mit welcher Auflösung 
erkannt werden soll.
Wenn der Taster manuell bedient wird, dann kann man mit PeDa's Verfahren 
bei 10ms Abtastrate Drücke ab 40ms erkennen und deren Länge in 
10ms-Schritten ermitteln. Für kurz-/lang-gedrückt reicht das dicke.

[Veit D. (devil-elec)]

Hallo,

Interrupts verschwendet man wie schon gesagt wurde nicht für Taster 
abfragen. Programmiere dir einen Millisekundentimer und polle damit 
deine Tastereingänge. Alle zeitlichen Wiederholungen/Abfragen wo [ms] 
oder [s] Genauigkeit ausreichend ist kann man damit erschlagen.

Code Bsp.:

// ATtiny841
#define F_CPU 8000000UL  // Systemtakt in Hz

#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <util/atomic.h>    


volatile uint32_t millis_count;    // ISR Timer 0 Variable
volatile uint32_t second_count;    // ISR Timer 0 Variable
uint32_t last_millis;
uint32_t last_second;

// *** Funktion Deklarationen *** //
uint32_t millis();
uint32_t seconds();
ISR(TIMER0_COMPA_vect);
void set_Timer0();          // Timer 0, millis, seconds


int main(void)
{  
  set_Timer0();        
    
    while (1)  
    {   
    last_millis = millis();
    last_second = seconds();            
  }
}


/* *** Funktionen *** */
void set_Timer0 ()    // millis, seconds
{
  cli();                  
  TCNT0 = 0;                // Register Reset
  TCCR0A = 0;
  TCCR0B = 0;
  TIMSK0 = 0;
  TCCR0A = (1 << WGM01);          // CTC Modus
  OCR0A = 124;                     // TOP, (F_CPU/PRESCALER)/1000-1
  TIMSK0 |= (1 << OCIE0A);        // Compare Match einschalten
  TCCR0B |= (1 << CS01) | (1 << CS00);  // Prescaler 64, Timer starten
  sei();
}


uint32_t millis()
{
  uint32_t value = 0;
  ATOMIC_BLOCK (ATOMIC_RESTORESTATE)
  {
    value = millis_count;
  }
  return value;
}


uint32_t seconds()
{
  uint32_t value = 0;
  ATOMIC_BLOCK (ATOMIC_RESTORESTATE)
  {
    value = second_count;
  }
  return value;
}


ISR(TIMER0_COMPA_vect)
{
  static uint32_t local_millis = 0;
  
  millis_count++;        // Zähler für Millisekunden
  local_millis++;

  if (local_millis > 999) {
    second_count++;      // Zähler für Sekunden
    local_millis = 0;
  }
}