29. Interrupts on the Uno

What an interrupt does

So far your sketches have checked things for themselves: loop() runs digitalRead, looks at the answer and moves on. That is called polling.

An interrupt works the other way round. The chip's hardware watches a pin for you. When the event you asked for happens - say, the button on D2 is pressed - the chip pauses loop() right where it is, runs one small function of yours, then carries on from exactly the same spot. That small function is called an ISR, short for interrupt service routine.

Think of a doorbell. You get on with cooking and don't keep walking to the door to check. When the bell rings, you answer it quickly, then go back to the pot you were stirring.

Why not just use digitalRead?

digitalRead only sees the button at the moment that line runs. If loop() is busy - a delay(1000), a slow display update, a long calculation - a quick tap can start and finish between two checks, and the sketch never knows it happened.

An interrupt can't miss it like that, because the hardware watches the pin all the time, even during delay(). You will see this for yourself in the Step 1 test sketch below.

Use an interrupt when an event is short or must not be missed: a quick tap, the pulses from a spinning knob (an encoder), or a sensor that sends a brief pulse. For an ordinary button in a fast loop() with no delay(), the digitalRead method from Lesson 10 is still fine.

D2 and D3: the interrupt pins

On the Uno only two pins can use attachInterrupt: D2 (its hardware name is INT0) and D3 (INT1). That is why the button for this lesson goes on D2. Other pins can use a different kind, pin-change interrupts, which are in the optional appendix.

You switch the interrupt on once, in setup(), with attachInterrupt. It needs three things: which pin, which function to run, and when to run it. Always wrap the pin number in digitalPinToInterrupt() - it turns pin 2 into the number the chip uses, so you never have to remember it.

Here is the smallest working example. Wire a button from D2 to GND, upload it, open Serial Monitor at 9600 baud and press the button. You should see Pressed! for each press - sometimes twice, which is bounce, explained further down.

const byte buttonPin = 2;          // D2 = interrupt pin INT0

volatile bool eventPending = false;  // volatile: see the rules below

// The ISR: runs by itself when the button is pressed
void onButtonEdge() {
  eventPending = true;               // just raise the flag
}

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);  // pressed reads LOW
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(buttonPin), onButtonEdge, FALLING);
}

void loop() {
  if (eventPending) {                // did the ISR raise the flag?
    eventPending = false;            // lower it again
    Serial.println("Pressed!");      // slow job: done here, not in the ISR
  }
}

Trigger modes: when the ISR runs

The last word in attachInterrupt says which change on the pin runs your ISR. With the course wiring (button to GND, INPUT_PULLUP) the pin reads HIGH while the button is up and LOW while you hold it down. So FALLING - the moment the pin drops from HIGH to LOW - is the moment you press.

To try another mode, change only that last word and upload again.

// Same sketch, but run the ISR on press AND release:
attachInterrupt(digitalPinToInterrupt(buttonPin), onButtonEdge, CHANGE);

Three rules for every ISR

An ISR interrupts everything else, so it has to follow three rules.

1. Keep it tiny. Set a flag or add 1 to a count, then return. While the ISR runs, the rest of the sketch waits - even millis() stops counting - so never put delay(), Serial.print(), the LCD or other slow jobs inside it.

2. Mark shared variables volatile. A variable that the ISR changes and loop() reads needs the word volatile in front of it. To save time, the compiler sometimes keeps its own quick copy of a variable. volatile tells it: this one can change at any moment, so always read the real value.

3. Copy bigger numbers safely. The Uno works one byte at a time, and an int is two bytes. If the ISR changes the count while loop() is halfway through reading it, loop() gets a mix of the old and new value - for example 511 when the count was going from 255 to 256. So pause interrupts for a moment while you copy the value, then use the copy. A bool flag is a single byte, so it doesn't need this.

volatile unsigned int eventCount = 0;  // 2 bytes, changed by the ISR

void loop() {
  noInterrupts();                       // pause interrupts...
  unsigned int countCopy = eventCount;  // ...copy both bytes...
  interrupts();                         // ...and switch them back on
  // from here on, use countCopy
}

The flag pattern

The worked sketch puts these rules together. The ISR does two tiny jobs: it sets eventPending to true (it raises the flag) and adds 1 to eventCount. That's all.

loop() goes past if (eventPending) thousands of times a second. When it finds the flag raised, it lowers it again, takes a safe copy of the count, then does the slow jobs: it toggles the LED, starts a short beep and prints the count. The beep is stopped 80 ms later with millis(), never with delay().

Why one press can count more than once

Inside a push-button, two metal contacts snap together. For a few thousandths of a second they bounce - touching, springing apart and touching again - before they settle. You met this in Lesson 10.

An interrupt is fast enough to catch every one of those bounces, and each one is a new HIGH-to-LOW edge, so one press can run the ISR two or three times. The LED may then toggle twice and look as if nothing happened.

The fix is to ignore new edges for a short time after you accept one. 200 ms is far longer than any bounce, but shorter than a quick second press. That is this lesson's challenge.

Build and test in three steps

Add one part at a time and check it before you move on:

1. Button only, from D2 to GND. Run the Step 1 test sketch below and open Serial Monitor at 9600 baud. Pass: tap quickly, once every second or two - the interrupt count goes up for (almost) every tap, while the digitalRead count misses most of them.

2. Add the LED on D8 (through the 330 ohm resistor) and the passive buzzer on D7. Run the worked sketch. Pass: each press toggles the LED, gives a short chirp and prints a bigger count.

3. Press slowly ten times and look at the count. Pass: it says 10. More than 10? That is bounce - fix it with the challenge.

Wiring and safe build sequence

1. Button: one leg to D2, the other leg to GND (no resistor needed - the sketch uses INPUT_PULLUP)
2. LED: D8 -> 330 ohm resistor -> LED long leg; LED short leg -> GND
3. Passive buzzer: + to D7, - to GND
4. Appendix templates: use the pin named in each section (D8 for pin-change, LED_BUILTIN for timer and USART, D6/D7 for the comparator)
5. Sleep template: the same D2 button; hold it down to wake the Uno

What this sketch is for: Counts quick taps two ways while loop() is stuck in delay(1000): once with digitalRead, once with an interrupt. Button from D2 to GND only. Open Serial Monitor at 9600 baud, tap quickly once, wait for the next line, and repeat. Now and then the interrupt count may jump by 2 - that is bounce, explained above.

const byte buttonPin = 2;           // D2 = interrupt pin INT0

volatile bool tapSeen = false;       // raised by the ISR, read by loop()

int pollCount = 0;                   // taps digitalRead() caught
int interruptCount = 0;              // taps the interrupt caught

void onButtonEdge() {
  tapSeen = true;                    // tiny ISR: just raise the flag
}

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);  // pressed reads LOW
  Serial.begin(9600);
  attachInterrupt(digitalPinToInterrupt(buttonPin), onButtonEdge, FALLING);
  Serial.println("Tap the button quickly, once every second or two.");
}

void loop() {
  // Polling: look at the pin once, right now
  if (digitalRead(buttonPin) == LOW) {
    pollCount++;
  }

  // Interrupt: did the ISR raise the flag since the last pass?
  if (tapSeen) {
    tapSeen = false;
    interruptCount++;
  }

  Serial.print("digitalRead saw: ");
  Serial.print(pollCount);
  Serial.print("   interrupt saw: ");
  Serial.println(interruptCount);

  delay(1000);                       // busy for a second, not looking at D2
}