Arduino-interrupts: attachInterrupt, ISR-regels en debouncing
Arduino-interrupts gebruiken: attachInterrupt, pin 2 en 3 van de Uno, RISING/FALLING/CHANGE, volatile, debouncing, voorbeelden met encoder en toerental, plus ESP32 en Pico.
Een Arduino-interrupt zorgt ervoor dat de processor direct stopt met waar hij mee bezig is zodra er op een pin de verandering plaatsvindt waarop je wacht (of een timergebeurtenis afgaat), en een speciale functie uitvoert die jij hebt geschreven. Kort gezegd: in plaats van in loop() steeds te vragen "is de knop ingedrukt?", zeg je tegen de Arduino: "laat het me weten als hij wordt ingedrukt". Dat doe je met de functie attachInterrupt(); op de Arduino Uno zijn de interruptpins D2 en D3, terwijl op de ESP32 en de Raspberry Pi Pico bijna elke GPIO een interrupt kan activeren.
Interrupts zijn onmisbaar om zeer snelle pulsen te tellen zonder er een te missen (encoders, snelheidssensoren, waterstroomsensoren), om een korte gebeurtenis op te vangen midden in een lange taak en om een board uit de slaapstand te wekken. In deze gids zie je stap voor stap hoe een interrupt in de hardware werkt, welke pins je op elk board kunt gebruiken, wat het verschil is tussen de modi RISING, FALLING en CHANGE, welke regels gelden voor het schrijven van een interruptroutine (ISR), hoe je een knop debounced, en voorbeelden voor een knop, een encoder en een toerenteller. Aan het eind leer je ook over IRAM_ATTR op de ESP32 en het gebruik van irq met MicroPython op de Pico.

Wat is een interrupt en hoe werkt hij?
Denk aan een deurbel: zonder bel zou je elke minuut naar de deur moeten lopen om te kijken of er iemand is. Dat heet polling, en een pin lezen met digitalRead() in loop() is precies dat. De deurbel is een interrupt: hij rinkelt terwijl je met iets anders bezig bent, je stopt, kijkt bij de deur en gaat terug naar waar je mee bezig was. Een microcontroller werkt hetzelfde. Als de door jou gekozen verandering op de pin plaatsvindt, zet de hardware een interruptvlag; de processor maakt de huidige instructie af, bewaart zijn registers, springt via de interruptvector naar jouw ISR (Interrupt Service Routine) en gaat, zodra de ISR klaar is, in loop() verder precies waar hij gebleven was. Op de Uno duurt deze overgang slechts enkele microseconden.
| Eigenschap | Polling | Interrupt |
|---|---|---|
| Werking | loop() leest de pin steeds opnieuw | De hardware vangt de verandering op en voert de ISR uit |
| Reactietijd | Hoe trager loop() is, hoe groter de vertraging | Enkele microseconden |
| Met delay() in de code | Gebeurtenissen kunnen gemist worden | Gebeurtenissen worden nog steeds opgevangen |
| Zeer snelle pulsen | Worden gemist | Worden één voor één geteld |
| Complexiteit van de code | Eenvoudig | Vereist volatile en atomair lezen |
| Het beste voor | Knoppen, trage sensoren | Encoders, snelheids- en stroomsensoren, wakker worden uit de slaapstand |
Welke pins ondersteunen interrupts? Arduino, ESP32 en Pico
| Board | Externe interruptpins | Opmerking |
|---|---|---|
| Arduino Uno R3, Nano, Pro Mini | D2, D3 | D2 = INT0, D3 = INT1 |
| Arduino Uno R4 (Minima / WiFi) | D2, D3 | De pins uit de officiële Arduino-referentie |
| Arduino Mega 2560 | 2, 3, 18, 19, 20, 21 | 20 en 21 kun je niet voor interrupts gebruiken zolang ze voor I2C worden gebruikt |
| Arduino Leonardo, Micro | 0, 1, 2, 3, 7 | 0 en 1 zijn ook de pins van de seriële poort |
| Arduino Nano Every | Alle digitale pins | ATmega4809-processor |
| ESP32 | Alle GPIO's | GPIO 34–39 zijn alleen ingang en hebben geen interne pull-up |
| ESP8266 (NodeMCU) | Alle behalve GPIO 16 (D0) | ISR's moeten gemarkeerd zijn met IRAM_ATTR |
| Raspberry Pi Pico / Pico W | Alle pins van GP0–GP28 | De pins werken op 3,3 V, sluit nooit 5 V aan |
Geef in je code niet rechtstreeks het pinnummer door; zet het om naar een interruptnummer met digitalPinToInterrupt(pin), want het interruptnummer verschilt per board: op de Uno is D2 interrupt 0 en D3 interrupt 1, terwijl op de Leonardo interrupt 0 D3 is en interrupt 1 D2. Heb je op de Uno meer dan twee interrupts nodig, dan werken pin change interrupts (PCINT) op bijna elke pin; ze melden echter alleen dat er "iets veranderd is", en alle pins van dezelfde poort delen één ISR. De bibliotheken PinChangeInterrupt en EnableInterrupt maken ze makkelijker in gebruik. De volledige pinindeling van je board vind je in de tool Pinout en de pinfuncties van de Uno in het artikel Arduino Uno pinout.
attachInterrupt en de interruptmodi gebruiken
De syntaxis is attachInterrupt(digitalPinToInterrupt(pin), ISR, mode). De tweede parameter is de naam van de functie die wordt uitgevoerd als de interrupt afgaat; deze functie heeft geen parameters en geeft niets terug (void). De derde parameter bepaalt welke gebeurtenis de interrupt activeert. Gebruik detachInterrupt(digitalPinToInterrupt(pin)) om een interrupt uit te schakelen, noInterrupts() om alle interrupts even te pauzeren en interrupts() om ze weer in te schakelen.
| Modus | Wanneer gaat hij af? | Typisch gebruik |
|---|---|---|
| LOW | Telkens opnieuw zolang de pin LOW is | Wakker worden uit de slaapstand |
| CHANGE | Bij elke verandering (beide flanken) | Encoders, pulslengte meten, debouncing |
| RISING | Bij de overgang van LOW naar HIGH (stijgende flank) | Begin van een sensorpuls, knop met pull-down |
| FALLING | Bij de overgang van HIGH naar LOW (dalende flank) | Indrukken van een knop met pull-up, sensoren met open collector |
| HIGH | Zolang de pin HIGH is | Alleen op de Due, Zero en MKR1000; ONHIGH op de ESP32 |
Kies de modus die bij je schakeling past. Heb je de knop aangesloten met INPUT_PULLUP, dan is de pin normaal HIGH en wordt hij LOW als je drukt, dus FALLING vangt het indrukken op. Gebruik de LOW-modus voorzichtig: zolang de pin LOW blijft, draait de ISR steeds opnieuw en komt loop() nauwelijks vooruit. Daarom wordt hij meestal alleen gebruikt om het board uit de slaapstand te wekken; om de Uno uit zijn diepste slaapstand (power-down) te wekken, raadt de datasheet een LOW-niveau-interrupt of een pin change interrupt aan. Op de ESP32 werken de constanten LOW en HIGH niet zoals je zou verwachten als interruptmodus: LOW schakelt de interrupt helemaal niet in en HIGH gedraagt zich als een stijgende flank. Voor niveau-interrupts schrijf je daar ONLOW en ONHIGH.
Eerste voorbeeld: drukken op een knop tellen met een interrupt
- Sluit één pootje van de knop aan op D2 en het andere op GND. Een externe weerstand is niet nodig; we gebruiken de interne pull-up.
- Upload de onderstaande code en open de Serial Monitor op 9600 baud.
- Druk een paar keer op de knop en zie de teller oplopen. Ondanks de delay(500) in loop() wordt er geen enkele druk gemist.
- Schrik niet als het getal soms in één keer met 2 of 3 omhoog springt: dat is contactdender, en die lossen we zo op.
1const byte BUTTON_PIN = 2; // kesme pini D2 (INT0) / interrupt pin D2 (INT0)
2volatile unsigned int pressCount = 0; // ISR ile paylaşılan sayaç / counter shared with the ISR
3
4void onPress() { // ISR: kısa ve hızlı / ISR: short and fast
5 pressCount++;
6}
7
8void setup() {
9 Serial.begin(9600);
10 pinMode(BUTTON_PIN, INPUT_PULLUP); // dahili pull-up, buton GND'ye / internal pull-up, button to GND
11 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onPress, FALLING);
12}
13
14void loop() {
15 noInterrupts(); // 2 baytlık değeri güvenle kopyala / copy the 2-byte value safely
16 unsigned int count = pressCount;
17 interrupts();
18
19 Serial.print(F("Basis / Presses: "));
20 Serial.println(count);
21 delay(500); // loop yavaş olsa da basış kaçmaz / presses are not missed even if loop is slow
22}Er zijn drie belangrijke punten in deze code. Ten eerste telt onPress() alleen één op bij de teller en is meteen klaar; de taak van een ISR is de gebeurtenis te noteren, niet het werk te doen. Ten tweede is de teller als volatile gedeclareerd, zodat de compiler hem niet in een register houdt en een verouderde waarde leest, maar elke keer de actuele waarde uit het geheugen haalt. Ten derde zet loop() de interrupts even uit terwijl hij de teller leest. Een unsigned int is op de Uno 2 bytes en de 8-bitsprocessor leest hem in twee stappen. Wanneer de teller van 255 naar 256 gaat, dus van 0x00FF naar 0x0100, leest loop() eerst de lage byte (0xFF); gaat precies dan de interrupt af en verhoogt de teller, dan leest hij daarna de hoge byte (0x01) en is het resultaat 0x01FF, oftewel 511. Doordat deze bug maar zelden optreedt, is hij ook moeilijk op te sporen. Op AVR-boards geeft de macro ATOMIC_BLOCK(ATOMIC_RESTORESTATE) uit util/atomic.h dezelfde bescherming; variabelen van één byte, zoals bool en byte, hebben dit probleem niet.
ISR-regels: houd hem kort, gebruik volatile, geen delay
- Houd hem kort en snel: zolang een ISR draait, wachten andere interrupts. Op de Uno zijn ook de millis()-teller en de seriële poort van interrupts afhankelijk, dus een lange ISR verstoort de timing en kan ervoor zorgen dat je binnenkomende seriële data kwijtraakt. Een ideale ISR is in enkele microseconden klaar.
- Gebruik geen delay(): delay() meet tijd met tellers die door de Timer0-interrupt worden bijgewerkt; binnen een ISR staan de interrupts uit, dus het werkt niet. Je kunt millis() lezen, maar die loopt tijdens de ISR niet door, en micros() gaat na 1–2 ms verkeerde waarden geven. Heb je echt een heel korte wachttijd nodig, dan werkt delayMicroseconds().
- Gebruik geen Serial.print(): seriële data versturen hangt ook van interrupts af; het maakt de ISR langer en blokkeert als de buffer vol raakt. Laat het printen aan loop() over.
- Maak gedeelde variabelen volatile: elke variabele die zowel in de ISR als in loop() wordt gebruikt, moet als volatile worden gedeclareerd.
- Lees variabelen van meerdere bytes atomair: kopieer in loop() variabelen van het type int, long, float en unsigned long tussen noInterrupts() en interrupts().
- Geen parameters, geen returnwaarde: een ISR moet void zijn en mag geen parameters hebben; gegevens wissel je uit via globale variabelen.
- Houd zwaar werk uit de ISR: schrijven naar een I2C-display, opslaan op een SD-kaart of bibliotheken aanroepen die zelf interrupts nodig hebben, zoals Wire, loopt vast binnen een ISR.
Een knop met een interrupt lezen en debouncen
Als je op een mechanische knop drukt, komen de metalen contacten niet meteen tot rust; ze gaan ongeveer 0,1 tot 10 milliseconden lang meerdere keren open en dicht. loop() is misschien te traag om dat te merken, maar een interrupt vangt elke flank op, dus één druk kan 3–5 interrupts opleveren. Bovendien treedt dender niet alleen op bij het indrukken maar ook bij het loslaten, dus code die alleen FALLING met een blokkeertijd gebruikt, kan dubbel tellen als je de knop een tijdje vasthoudt en dan loslaat. De onderstaande code gebruikt de modus CHANGE en accepteert een druk alleen als de pin LOW is en de lijn minstens 50 ms daarvoor rustig was. Dat filtert zowel de dender bij indrukken als bij loslaten.
1const byte BUTTON_PIN = 2; // kesme pini / interrupt pin
2const byte LED_PIN = 13; // dahili LED / onboard LED
3const unsigned long QUIET_MS = 50; // gereken sessizlik süresi / required quiet time
4
5volatile bool ledState = false; // ISR ile paylaşılır / shared with the ISR
6
7void onButtonChange() { // iki kenarda da çalışır / runs on both edges
8 static unsigned long lastEdgeMs = 0;
9 unsigned long now = millis(); // ISR'de okunur ama artmaz / readable in an ISR but does not advance
10 bool pressed = (digitalRead(BUTTON_PIN) == LOW);
11
12 if (pressed && now - lastEdgeMs > QUIET_MS) { // hat sessizdi: gerçek basış / line was quiet: real press
13 ledState = !ledState;
14 }
15 lastEdgeMs = now; // her kenar süreyi yeniden başlatır / every edge restarts the timer
16}
17
18void setup() {
19 pinMode(LED_PIN, OUTPUT);
20 pinMode(BUTTON_PIN, INPUT_PULLUP);
21 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButtonChange, CHANGE);
22}
23
24void loop() {
25 digitalWrite(LED_PIN, ledState ? HIGH : LOW); // bool tek bayt, okuması atomik / bool is one byte, atomic read
26 // burada uzun işler olsa da basış kaçmaz / long tasks here will not make you miss a press
27}Naast software kun je dender ook in hardware onderdrukken: plaats een condensator van 100 nF over de knop en een pull-upweerstand van 10 kΩ op de pin, dan wordt de tijdconstante τ = R × C = 10 kΩ × 100 nF = 1 ms, wat korte dendering gladstrijkt; de schmitttrigger op de ingangen van de Uno maakt de flank ook schoner. Andere waarden kun je berekenen met de tool RC-tijdconstante. Eerlijk gezegd heb je voor knoppen die met de hand worden bediend vaak helemaal geen interrupt nodig; als loop() snel is, volstaat polling. Voor pull-up, pull-down en debouncing met millis() lees je Een knop aansluiten op Arduino. Bewaar interrupts voor snelle, korte signalen.
Een draaiencoder lezen met een interrupt
Als je aan een draaiencoder (zoals de KY-040) draait, geeft hij blokgolven op twee pins, CLK en DT genoemd, die ten opzichte van elkaar verschoven zijn. Draai je snel, dan worden de pulsen korter dan een milliseconde en mist polling gemakkelijk stappen. De eenvoudigste methode is CLK op een interruptpin aan te sluiten en op het moment dat CLK daalt het niveau van DT te controleren: is DT HIGH, dan is er de ene kant op gedraaid, is hij LOW, dan de andere kant. Deze versie telt één stap per klik; komt de richting omgekeerd uit, verwissel dan de regels ++ en --. Goedkope encoders dender ook, dus een condensator van 10–100 nF tussen CLK en GND en tussen DT en GND maakt een duidelijk verschil. Voor een versie die beide pins op interrupts zet en met een toestandstabel nooit een stap mist, kijk je in de gids voor de draaiencoder (KY-040).
1const byte PIN_CLK = 2; // kesme pini / interrupt pin
2const byte PIN_DT = 4; // normal dijital giriş / regular digital input
3
4volatile long position = 0; // 4 baytlık konum / 4-byte position
5
6void onClkFall() {
7 if (digitalRead(PIN_DT) == HIGH) { // yön DT seviyesinden / direction from the DT level
8 position++;
9 } else {
10 position--;
11 }
12}
13
14void setup() {
15 Serial.begin(115200);
16 pinMode(PIN_CLK, INPUT_PULLUP);
17 pinMode(PIN_DT, INPUT_PULLUP);
18 attachInterrupt(digitalPinToInterrupt(PIN_CLK), onClkFall, FALLING);
19}
20
21void loop() {
22 static long lastPos = 0;
23
24 noInterrupts(); // atomik kopya / atomic copy
25 long pos = position;
26 interrupts();
27
28 if (pos != lastPos) {
29 Serial.println(pos);
30 lastPos = pos;
31 }
32}Omwentelingen tellen: het toerental van een motor meten
De snelheid van een motor of wiel meten is het klassieke gebruik van interrupts. Als sensor gebruik je een optische sleufsensor met een LM393 en een encoderschijf met 20 sleuven, of een hallsensor zoals de A3144 met een magneet op de as. Elke sleuf of elke passage van de magneet levert één puls op. Uit het aantal pulsen dat in één seconde is geteld, volgt het toerental: RPM = pulsen per seconde × 60 / pulsen per omwenteling. Geeft een schijf met 20 sleuven bijvoorbeeld 100 pulsen per seconde, dan draait de motor met 100 × 60 / 20 = 300 RPM.
1const byte SENSOR_PIN = 3; // kesme pini D3 (INT1) / interrupt pin D3 (INT1)
2const byte PULSES_PER_REV = 20; // diskteki yarık sayısı / slots on the encoder disc
3
4volatile unsigned long pulseCount = 0;
5
6void onPulse() {
7 pulseCount++;
8}
9
10void setup() {
11 Serial.begin(9600);
12 pinMode(SENSOR_PIN, INPUT_PULLUP);
13 attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), onPulse, FALLING);
14}
15
16void loop() {
17 static unsigned long lastMs = 0;
18
19 if (millis() - lastMs >= 1000) { // her saniye hesapla / compute once per second
20 lastMs += 1000;
21
22 noInterrupts(); // kopyala ve sıfırla / copy and reset
23 unsigned long pulses = pulseCount;
24 pulseCount = 0;
25 interrupts();
26
27 float rpm = pulses * 60.0 / PULSES_PER_REV;
28 Serial.print(F("RPM: "));
29 Serial.println(rpm, 1);
30 }
31}Hier kopieert en reset loop() de teller elke seconde; beide gebeuren binnen hetzelfde noInterrupts()-blok, zodat er geen puls verloren gaat als er tussen die twee een interrupt binnenkomt. Met een schijf van 20 sleuven is de resolutie 3 RPM. Wil je bij lage snelheden nauwkeurigere resultaten, meet dan in plaats van pulsen te tellen in de ISR de tijd tussen twee pulsen met micros() en gebruik RPM = 60.000.000 / (periode_µs × pulsen per omwenteling). Dezelfde methode werkt voor de waterstroomsensor YF-S201, snelheidsmeting met een hallsensor en de wielsnelheid van een gelijkstroommotor met reductie.
Een korte opmerking over timerinterrupts
Interrupts komen niet alleen van pins. De timers in de microcontroller kunnen ook met vaste tussenpozen interrupts genereren, zodat een functie precies elke 1 ms of elke 500 ms draait, wat loop() ook doet. De Uno heeft drie timers, en een aantal ervan wordt al gebruikt door de eigen functies van Arduino:
| Timer | Grootte | Gebruikt door | PWM-pins |
|---|---|---|---|
| Timer0 | 8-bit | millis(), delay(), micros() | 5, 6 |
| Timer1 | 16-bit | Servo-bibliotheek, TimerOne | 9, 10 |
| Timer2 | 8-bit | tone(), IRremote | 3, 11 |
Op de Uno is de bibliotheek TimerOne de makkelijkste route: Timer1.initialize(500000) stelt de periode in microseconden in en Timer1.attachInterrupt(function) koppelt de ISR die elke 500 ms draait. Omdat hij Timer1 gebruikt, botst hij met de Servo-bibliotheek en met analogWrite() op pin 9 en 10. Op de ESP32 met Arduino core 3.x stel je een timerinterrupt in met timerBegin(1000000), timerAttachInterrupt() en timerAlarm(); timerAlarmWrite() en timerAlarmEnable() uit 2.x zijn verwijderd, dus oude voorbeelden geven de foutmelding "was not declared in this scope". Op de Pico stel je met Timer(period=500, mode=Timer.PERIODIC, callback=function) van MicroPython in één regel een periodieke interrupt in. Hoe timers samenhangen met PWM lees je in Wat is PWM?
Interrupts op de ESP32: IRAM_ATTR en portMUX
Op de ESP32 hoef je niet naar een speciale pin te zoeken; elke GPIO kan een interrupt activeren. Alleen GPIO 34–39 hebben geen interne pull-up, dus een knop daar heeft een externe pull-up van 10 kΩ nodig; de errata van Espressif vermelden ook dat GPIO 36 en 39 valse interrupts kunnen geven terwijl de ADC in gebruik is. Het echte verschil op de ESP32 is het attribuut IRAM_ATTR vóór de ISR. Dat plaatst de functie in snel intern RAM (IRAM) in plaats van in flash. Tijdens schrijven naar flash (Preferences, SPIFFS, OTA) staat de cache uit; afhankelijk van de configuratie kan een interrupt die op dat moment code in flash aanraakt het board resetten met "Guru Meditation Error: Core 1 panic'ed (Cache disabled but cached memory region accessed)". De ESP8266 is nog strenger: een ISR zonder IRAM_ATTR stopt het board met de melding "ISR not in IRAM!" zodra attachInterrupt wordt aangeroepen.
1const int BUTTON_PIN = 27; // her GPIO kesme verebilir / any GPIO can interrupt
2const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
3const uint32_t QUIET_MS = 50; // gereken sessizlik süresi / required quiet time
4
5volatile uint32_t pressCount = 0;
6portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED; // paylaşılan veri kilidi / lock for shared data
7
8void IRAM_ATTR onButtonChange() { // ISR IRAM'de çalışır / ISR runs from IRAM
9 static uint32_t lastEdgeMs = 0;
10 uint32_t now = millis();
11 bool pressed = (digitalRead(BUTTON_PIN) == LOW);
12
13 if (pressed && now - lastEdgeMs > QUIET_MS) {
14 portENTER_CRITICAL_ISR(&mux);
15 pressCount++;
16 portEXIT_CRITICAL_ISR(&mux);
17 }
18 lastEdgeMs = now;
19}
20
21void setup() {
22 Serial.begin(115200);
23 pinMode(LED_PIN, OUTPUT);
24 pinMode(BUTTON_PIN, INPUT_PULLUP);
25 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButtonChange, CHANGE);
26}
27
28void loop() {
29 static uint32_t lastCount = 0;
30
31 portENTER_CRITICAL(&mux); // loop tarafında kilit / lock on the loop side
32 uint32_t count = pressCount;
33 portEXIT_CRITICAL(&mux);
34
35 if (count != lastCount) {
36 lastCount = count;
37 digitalWrite(LED_PIN, (count % 2) ? HIGH : LOW); // her basışta LED değişir / LED toggles on every press
38 Serial.printf("Basis / Press: %lu\n", (unsigned long)count);
39 }
40}Omdat de ESP32 FreeRTOS draait en twee kernen heeft, bescherm je gedeelde variabelen met een portMUX_TYPE-slot in plaats van noInterrupts() zoals op de Uno: gebruik portENTER_CRITICAL_ISR() in de ISR en portENTER_CRITICAL() in loop(). Een variabele van 32 bits lezen is op de ESP32 al één stap, maar het slot is onmisbaar voor dingen als een waarde lezen en resetten of meerdere variabelen samen bijwerken. Wil je dezelfde functie aan meerdere pins koppelen, dan kun je met attachInterruptArg() een parameter, zoals het pinnummer, aan de ISR meegeven. Voor de basis van de ESP32 zie Wat is de ESP32?, en voor taken en kernen ESP32 FreeRTOS en dual core.
Interrupts op de Raspberry Pi Pico: MicroPython irq
Op de Raspberry Pi Pico kan elke pin van GP0 tot GP28 een interrupt activeren. In MicroPython stel je er een in met de methode irq() van het pinobject: voor trigger geef je Pin.IRQ_FALLING, Pin.IRQ_RISING of beide gecombineerd op, en handler is de functie die wordt uitgevoerd als de interrupt afgaat; die krijgt de pin die de trigger veroorzaakte als parameter. Python heeft geen volatile; het volstaat de variabelen die je in de ISR wijzigt als global te declareren. Gebruik voor tijdmeting time.ticks_ms() en het overloopveilige time.ticks_diff(). De onderstaande code brengt de rusttijdlogica uit het Arduino-voorbeeld naar de Pico:
1from machine import Pin
2import time
3
4led = Pin("LED", Pin.OUT) # dahili LED (Pico ve Pico W) / onboard LED (Pico and Pico W)
5button = Pin(14, Pin.IN, Pin.PULL_UP) # buton GP14 ile GND arasında / button between GP14 and GND
6
7QUIET_MS = 50 # gereken sessizlik süresi / required quiet time
8presses = 0
9last_edge = time.ticks_ms()
10
11def on_change(pin): # handler tetikleyen pini alır / handler receives the pin
12 global presses, last_edge
13 now = time.ticks_ms()
14 if pin.value() == 0 and time.ticks_diff(now, last_edge) > QUIET_MS:
15 presses += 1
16 led.toggle()
17 last_edge = now
18
19button.irq(trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING, handler=on_change)
20
21while True:
22 print("Basis / Presses:", presses) # ana döngü uyurken bile basışlar sayılır / presses are counted while the loop sleeps
23 time.sleep(1)Op de Pico draait irq standaard als soft interrupt: MicroPython zet de functie in een wachtrij en voert hem zo snel mogelijk uit, dus print gebruiken of een lijst maken erin geeft geen problemen, maar de latentie loopt iets op. Geef je hard=True mee, dan daalt de latentie tot microseconden; in ruil daarvoor kun je binnen de ISR geen geheugen alloceren, dus een nieuwe lijst, een string en zelfs een float-berekening kunnen een "MemoryError" veroorzaken. Programmeer je de Pico vanuit de Arduino IDE (Earle Philhower-core), dan werkt attachInterrupt() op elke GPIO hetzelfde. Voor de installatie zie Wat is de Raspberry Pi Pico?, en voor de basiscommando's De basis van MicroPython.
Projectideeën met interrupts
- Reactietimer: meet hoe lang je erover doet om op de knop te drukken nadat een LED oplicht, met micros() in de ISR voor een nauwkeurigheid onder de milliseconde.
- Fietssnelheidsmeter: zet een magneet op het wiel en een hallsensor op het frame; bereken snelheid en afstand uit de tijd per omwenteling.
- Watermeter: tel de pulsen van een stroomsensor YF-S201 en toon de gebruikte liters.
- Robotauto die rechtdoor rijdt: meet de snelheid van beide motoren met wielencoders en stem ze op elkaar af.
- Menubediening: blader door een menu op het scherm en wijzig instellingen met een draaiencoder.
- Alarm op batterijen: laat de uitgang van een PIR-sensor het board wekken terwijl het slaapt; voor de ESP32 zie het artikel over deep sleep.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| De interrupt gaat nooit af | attachInterrupt(2, ...) kreeg een pinnummer, of er is een pin zonder interruptondersteuning gekozen | Gebruik digitalPinToInterrupt(pin); sluit op de Uno aan op D2 of D3 |
| Eén druk verhoogt de teller met 2–5 | Contactdender | Debounce in software en/of voeg een condensator van 100 nF toe |
| De variabele verandert nooit in loop() | volatile is vergeten | Declareer de gedeelde variabele als volatile |
| Af en toe absurd grote waarden | Een variabele van meerdere bytes is niet atomair gelezen | Kopieer hem tussen noInterrupts() en interrupts() |
| Het programma loopt vast of millis() loopt uit de pas | delay(), Serial of een lange taak binnen de ISR | Werk in de ISR alleen een vlag of teller bij |
| Interrupts gaan af zonder dat je de knop aanraakt | De pin zweeft, geen pull-up | Gebruik INPUT_PULLUP of een externe weerstand van 10 kΩ |
| De ISR draait één keer direct na opnieuw koppelen | Er kwam een flank binnen terwijl de interrupt uit stond en de vlag werd gezet (AVR) | Schrijf op de Uno EIFR = bit(INTF0); vóór attachInterrupt (INTF1 voor D3) |
| De ESP32 reset willekeurig | De ISR staat niet in IRAM of doet zwaar werk | Voeg IRAM_ATTR toe en maak de ISR korter |
Interrupts zijn een krachtig hulpmiddel waarmee je elke gebeurtenis opvangt, ook als loop() met ander werk bezig is; je hoeft maar drie regels te onthouden: houd de ISR kort, maak gedeelde variabelen volatile en lees ze atomair in loop(). In de BlueGrays-app vind je knoptellers, een reactietest, ESP32-knopprojecten en een Pico-project dat debouncing met een interrupt (IRQ) en met software-polling vergelijkt, elk met een schakelschema en code stap voor stap.
Veelgestelde vragen
Welke pins ondersteunen interrupts op de Arduino Uno?
De Arduino Uno R3, Nano en Pro Mini hebben slechts twee externe interruptpins: D2 (INT0) en D3 (INT1). Op de Mega 2560 kun je 2, 3, 18, 19, 20 en 21 gebruiken, en op de Leonardo 0, 1, 2, 3 en 7. Op de andere pins kun je alleen pin change interrupts (PCINT) gebruiken, die alleen melden dat een pin veranderd is.
Waarom werkt delay() niet binnen een interrupt (ISR)?
delay() meet tijd met tellers die door de Timer0-interrupt worden bijgewerkt. Terwijl een ISR draait, wachten andere interrupts, dus die tellers lopen niet door en delay() kan niet goed werken. Moet er ergens op gewacht worden, zet dan in de ISR gewoon een vlag en doe het wachten in loop() met millis().
Wat doet volatile en wanneer moet ik het gebruiken?
volatile zegt tegen de compiler dat de variabele op elk moment buiten de normale programmastroom kan veranderen, bijvoorbeeld in een ISR, zodat de waarde niet in een register wordt bewaard maar elke keer uit het geheugen wordt gelezen. Elke variabele die zowel in een ISR als in loop() wordt gebruikt, moet volatile zijn. Volatile maakt het lezen van meerdere bytes echter niet atomair; daarvoor gebruik je noInterrupts().
Kan ik meer dan 2 interrupts gebruiken op een Arduino Uno?
Ja. Dankzij pin change interrupts (PCINT) kan bijna elke pin van de Uno een interrupt activeren. Ze melden alleen een verandering, en de pins van dezelfde poort (D0–D7, D8–D13, A0–A5) delen één ISR. Met de bibliotheken PinChangeInterrupt of EnableInterrupt voelt het gebruik ervan heel gelijk aan attachInterrupt.
Moet ik interrupts of polling gebruiken?
Voor knoppen die met de hand worden bediend en langzaam veranderende sensoren is polling in loop() meestal genoeg en eenvoudiger. Gebruik interrupts voor snelle, korte pulsen zoals encoders, snelheids- en stroomsensoren, of om het board uit de slaapstand te wekken. Zit loop() vol lange delay()-aanroepen, dan lost het vervangen door millis() ook de meeste problemen op.
Wat gebeurt er als ik IRAM_ATTR op de ESP32 weglaat?
De code compileert meestal en lijkt te werken, maar de ISR blijft in flash staan, start trager en kan, afhankelijk van de configuratie, crashen met "Cache disabled but cached memory region accessed" terwijl er naar flash wordt geschreven. Op de ESP8266 stopt het board zonder IRAM_ATTR meteen met "ISR not in IRAM!". Zet op ESP-boards dus IRAM_ATTR voor elke ISR.
Projecten om hierna te bouwen
Alle projecten bekijken
LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

Raspberry Pi Pico-knop ontdenderen: IRQ vs software-polling
Als één druk op een knop je code 3-4 keer liet tellen, is contactdender de boosdoener: de metalen contacten van de knop gaan binnen microseconden vele malen open en dicht als ze elkaar raken! In dit project tellen we dezelfde knop op 2 manieren en vergelijken we ze naast elkaar in Serial: RAW-polling (vangt de dender op en telt fout) en IRQ + software-ontdendering (telt goed).

ESP32-ledbesturing met drukknop (Toggle)
Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

Raspberry Pi Pico: led aan/uit met een knop (toggle)
Knop + led, een niveau hoger! Je hoeft de knop niet ingedrukt te houden. Indrukken en loslaten → led aan. Nog een keer → led uit (toggle). Dezelfde schakeling (led GP14, knop GP2), maar andere code. Je leert edge detection (het moment van 1→0 vastleggen), toestand bijhouden en debounce (filter tegen contactdender). led.toggle() van MicroPython wisselt de toestand in één regel. De basis van interactieve knopprojecten.

Teller met 7-segmentdisplay en knoppen
Een eenvoudige teller met drie knoppen: met de ene knop gaat het cijfer op het display er één omhoog, met de andere één omlaag en de derde zet het terug op nul.

Arduino-reactietest met geluidssignaal: meet je reflexen in milliseconden (LCD + buzzer + 3 leds)
Hoe snel zijn je reflexen? Druk op de knop: rood zegt maak je klaar, geel zegt wacht, en er begint een willekeurige wachttijd van 1,5 tot 3,5 seconden. Gaat de groene led aan en piept de buzzer, druk dan opnieuw; je reactietijd verschijnt in milliseconden op de I2C-LCD, met je beste en gemiddelde tijd. Druk je vóór groen, dan toont het scherm TOO EARLY! (te vroeg) met een verliesgeluid. Houd de knop ingedrukt voor een nieuwe speler.

ESP32 WebSocket-teller (2 knoppen + lcd + realtime web)
In dit project verandert een teller met twee knoppen op de ESP32 (GPIO 5 telt op, GPIO 4 telt af). De waarde wordt direct bijgewerkt op een 16x2 I2C-lcd en, via de WebSocket-ondersteuning van ESPAsyncWebServer, in elke verbonden browser zonder de pagina te herladen. In plaats van HTTP-polling wordt één blijvende verbinding gebruikt en de ESP32 stuurt de nieuwe waarde met ws.textAll() naar iedereen.

Arduino-geheugenspel (4 leds + 4 knoppen + buzzer)
Vertrouw je op je geheugen? Vier gekleurde leds lichten na elkaar op en spelen elk hun eigen toon; jij herhaalt dezelfde volgorde door op de knoppen te drukken.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

