Arduino Interrupts verstehen: attachInterrupt, ISR & Entprellen – nie wieder verpasste Signale

Warum Polling nicht reicht – und Interrupts die Rettung sind

Der klassische Anfänger-Ansatz prüft Eingänge im loop(): if (digitalRead(PIN) == HIGH) ... – das nennt man Polling. Das funktioniert, solange dein loop() schnell durchläuft. Sobald aber ein delay(1000), eine langsame Sensor-Abfrage oder eine Display-Aktualisierung dazwischenfunkt, ist dein Programm für diese Zeit blind: Ein kurzer Impuls von 50 Millisekunden geht schlicht verloren.

Ein Interrupt dreht das Prinzip um: Die Hardware selbst überwacht den Pin. Ändert sich der Pegel, unterbricht der Controller sofort das laufende Programm, springt in deine ISR (Interrupt Service Routine), arbeitet sie ab und kehrt exakt an die unterbrochene Stelle zurück. Das Ganze dauert nur wenige Mikrosekunden.

• Nichts geht verloren: Auch kürzeste Impulse werden erfasst – egal was der loop() gerade treibt
• Sofortige Reaktion: Reaktionszeit im Mikrosekunden-Bereich statt „irgendwann im nächsten loop-Durchlauf“
• Sauberer Code: Ereignis-Logik wandert aus dem loop() in eine eigene kleine Funktion
• Strom sparen: Interrupts können den Controller sogar aus Schlafmodi aufwecken – die Basis von ESP32 Deep Sleep

Das brauchst du

Welche Pins können Interrupts?

Nicht jeder Pin eignet sich auf jedem Board für externe Interrupts – das ist der häufigste Stolperstein überhaupt:

Damit dein Sketch auf allen Boards läuft, übersetzt du die Pin-Nummer immer mit digitalPinToInterrupt(pin) – niemals die rohe Interrupt-Nummer eintragen. Als Modus stehen zur Wahl:

• RISING – löst bei steigender Flanke aus (LOW → HIGH)
• FALLING – löst bei fallender Flanke aus (HIGH → LOW)
• CHANGE – löst bei jeder Pegeländerung aus
• LOW – löst dauerhaft aus, solange der Pin LOW ist (selten sinnvoll)

1Dein erster Interrupt: Touch-Zähler mit dem TTP223

Der TTP223 Touch-Sensor ist der perfekte Einstieg, weil er ein digital sauberes Signal liefert – kein Prellen, kein Rauschen. Verkabelung: VCC an 5V, GND an GND, Signal (I/O) an D2. Der Sketch zählt Berührungen, während der loop() demonstrativ mit einem trägen delay() beschäftigt ist:

const int TOUCH_PIN = 2;          // D2 = interrupt-faehig am UNO

volatile unsigned int beruehrungen = 0;   // volatile ist PFLICHT!

void beruehrungErkannt() {
  beruehrungen++;                 // ISR: so kurz wie moeglich
}

void setup() {
  Serial.begin(115200);
  pinMode(TOUCH_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(TOUCH_PIN),
                  beruehrungErkannt, RISING);
  Serial.println("Touch-Zaehler bereit - beruehre den Sensor!");
}

void loop() {
  delay(2000);                    // absichtlich traege - Interrupt kommt trotzdem durch
  Serial.print("Beruehrungen bisher: ");
  Serial.println(beruehrungen);
}

Obwohl der loop() zwei Sekunden schläft, wird keine einzige Berührung verpasst – genau das ist die Magie der Interrupts.

2Die goldenen Regeln für ISRs

Eine ISR unterbricht dein Programm mitten im Befehl. Damit dabei nichts schiefgeht, gelten eiserne Regeln:

1. Kurz halten: Nur Flags setzen, Zähler erhöhen, Zeitstempel merken. Die eigentliche Arbeit (Display, Berechnungen) erledigt der loop()
2. Kein Serial.print() in der ISR: Serial nutzt selbst Interrupts – im schlimmsten Fall friert dein Sketch ein
3. Kein delay() und kein millis()-Warten: delay() steht in der ISR komplett still; millis() zählt während einer ISR nicht weiter
4. Geteilte Variablen als volatile deklarieren – und bei Variablen größer als 1 Byte (int, long, float) den Zugriff im loop() mit noInterrupts()/interrupts() schützen

So sieht der sichere Zugriff auf einen mehrbyteigen Zähler aus:

volatile unsigned long impulse = 0;

void loop() {
  unsigned long kopie;

  noInterrupts();          // Interrupts ganz kurz anhalten ...
  kopie = impulse;         // ... Wert atomar kopieren ...
  interrupts();            // ... und sofort wieder freigeben

  Serial.println(kopie);   // mit der Kopie arbeiten
  delay(1000);
}

3Entprellen: Wenn ein Tastendruck zehnmal zählt

Mechanische Taster und Schalter prellen: Beim Schließen federn die Kontakte einige Millisekunden lang, und aus einem Druck werden fünf bis zwanzig Flanken – dein Interrupt-Zähler explodiert. Die Lösung ist eine Zeitsperre direkt in der ISR: Auslösungen, die weniger als ~200 ms nach der letzten kommen, werden ignoriert:

const int TASTER_PIN = 3;                  // zweiter Interrupt-Pin am UNO
const unsigned long PRELL_SPERRE = 200;    // ms - je nach Taster 50-250

volatile unsigned int druecke = 0;
volatile unsigned long letzteAusloesung = 0;

void tasterGedrueckt() {
  unsigned long jetzt = millis();          // millis LESEN ist in ISR ok
  if (jetzt - letzteAusloesung > PRELL_SPERRE) {
    druecke++;
    letzteAusloesung = jetzt;
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(TASTER_PIN, INPUT_PULLUP);       // interner Pull-up: Taster gegen GND
  attachInterrupt(digitalPinToInterrupt(TASTER_PIN),
                  tasterGedrueckt, FALLING);
}

void loop() {
  static unsigned int letzterStand = 0;
  unsigned int kopie;

  noInterrupts();
  kopie = druecke;
  interrupts();

  if (kopie != letzterStand) {
    letzterStand = kopie;
    Serial.print("Tastendruck Nr. ");
    Serial.println(kopie);
  }
}

Dank INPUT_PULLUP brauchst du keinen externen Widerstand: Der Pin liegt in Ruhe auf HIGH, der Taster zieht ihn beim Drücken auf GND – deshalb lauscht der Interrupt auf FALLING.

4Praxis: PIR-Alarm und Rotary Encoder per Interrupt

Bewegungsmelder ohne Polling

Der HC-SR501 hält seinen Ausgang bei Bewegung für einige Sekunden auf HIGH – perfekt für RISING. Die ISR setzt nur ein Flag, der loop() erledigt die Reaktion:

const int PIR_PIN = 2;
const int LED_PIN = 13;

volatile bool bewegungErkannt = false;

void pirAusgeloest() {
  bewegungErkannt = true;          // nur das Flag setzen - mehr nicht!
}

void setup() {
  Serial.begin(115200);
  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(PIR_PIN), pirAusgeloest, RISING);
  Serial.println("PIR-Waechter aktiv (60 s Aufwaermzeit beachten)");
}

void loop() {
  if (bewegungErkannt) {
    bewegungErkannt = false;       // Flag zuruecksetzen
    digitalWrite(LED_PIN, HIGH);
    Serial.println("Bewegung erkannt!");
    // hier: Buzzer, Nachricht, Foto ausloesen ...
  }

  if (digitalRead(PIR_PIN) == LOW) {
    digitalWrite(LED_PIN, LOW);    // PIR wieder in Ruhe -> LED aus
  }
}

Wie du daraus eine komplette Alarmanlage mit ESP32 baust, zeigt das PIR-Alarmanlagen-Tutorial.

Rotary Encoder: das Interrupt-Paradebeispiel

Beim schnellen Drehen eines Rotary Encoders feuern die Impulse im Millisekunden-Takt – mit Polling verlierst du Schritte, die Drehrichtung springt. Mit einem Interrupt auf CLK sitzt jeder Schritt (CLK an D2, DT an D3, VCC an 5V, GND an GND):

const int CLK_PIN = 2;   // Interrupt-Pin
const int DT_PIN  = 3;

volatile int position = 0;

void encoderDreht() {
  // Drehrichtung: Zustand von DT im Moment der CLK-Flanke
  if (digitalRead(DT_PIN) != digitalRead(CLK_PIN)) {
    position++;          // im Uhrzeigersinn
  } else {
    position--;          // gegen den Uhrzeigersinn
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(CLK_PIN, INPUT_PULLUP);
  pinMode(DT_PIN,  INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(CLK_PIN), encoderDreht, CHANGE);
}

void loop() {
  static int letztePosition = 0;
  int kopie;

  noInterrupts();
  kopie = position;
  interrupts();

  if (kopie != letztePosition) {
    letztePosition = kopie;
    Serial.print("Position: ");
    Serial.println(kopie);
  }
}

Auf dieser Basis baust du komfortable Bedienoberflächen – etwa das OLED-Menüsystem mit Rotary Encoder. Alle Details zum Encoder selbst stehen im KY-040 Grundlagen-Tutorial.

Troubleshooting