The Interrupt System

1Lab objectives

• Understanding the difference between polling and interrupts
• Configuring the external interrupts INT0 and INT1 through EICRA and EIMSK
• Correctly writing a handling routine (ISR)
• Using the volatile qualifier and understanding why
• Measuring the response latency of both approaches

2Materials needed

• 1 Arduino Uno
• 1 Breadboard
• 2 Buttons
• 2 LEDs + 220 Ω resistors
• 6 Jumper wires

3Why interrupts are needed

In a typical program, checking a button happens inside loop(). If the loop also contains other operations that take time - an LCD update, an ADC conversion, a delay() - the event can be missed entirely.

Interrupts solve the problem at the hardware level: when the event occurs, normal execution is suspended immediately, the handling routine runs, then the program resumes exactly where it left off.

4The handling mechanism

1. The event occurs (an edge on a pin, a timer overflow, an ADC conversion finishing, etc.)
2. The corresponding interrupt flag is set automatically
3. If interrupts are enabled globally (sei()) and locally, the processor finishes the current instruction
4. The return address is saved on the stack, and global interrupts are disabled
5. Execution jumps to the address in the interrupt vector table
6. The ISR runs; at reti() the context is restored and interrupts are re-enabled

5Polling vs. interrupt

Press the button (or click directly on the chart) to generate an external event. Increase the duration of the CPU load and watch how latency grows in the polling variant, while the interrupt responds instantly, regardless of load.

6Interrupt sources on the ATmega328P

7Configuring the registers

Change the bits below and watch the resulting value of the registers. The default configuration corresponds to detecting a falling edge on INT0, with the interrupt enabled.

8Why volatile is mandatory

The compiler optimizes code by assuming it knows everything that happens to a variable. An ISR, however, runs "from outside" the normal flow, and the compiler cannot anticipate this.

bool ready = false;                 // volatile is MISSING!

ISR(INT0_vect) { ready = true; }

void loop() {
  while (!ready) { }                 // the compiler sees that "ready" does not change
                                    // inside the loop, so it loads it ONCE into a
                                    // CPU register and tests the same copy forever
                                    // -> INFINITE LOOP
  ready = false;
  digitalWrite(13, HIGH);           // never reached
}

Atomic access to multi-byte variables

The ATmega328P is an 8-bit processor. Reading a 16- or 32-bit variable takes several steps. If the interrupt occurs in between, the result combines halves from different values:

volatile uint16_t counter = 0;       // 2 bytes on an 8-bit processor

ISR(INT0_vect) { counter++; }

uint16_t readSafely() {
  uint16_t v;
  uint8_t sreg = SREG;              // save the interrupt state
  cli();                            // critical section: stop interrupts
  v = counter;                      // atomic read, in 2 uninterrupted steps
  SREG = sreg;                      // restore the previous state
  return v;
}

9Simulator: the flow of an ISR

Watch what happens when the event occurs right in the middle of a delay(). Notice that the ISR runs immediately, and the main program resumes exactly where it was interrupted.

10Mandatory rules for an ISR

11Source code

The Arduino variant

const uint8_t BUTTON_PIN = 2;    // on the Uno only D2 and D3 have INT0/INT1
const uint8_t LED_PIN   = 13;

volatile uint16_t pressCount   = 0;   // volatile: modified in the ISR
volatile bool     newEvent = false;

void handlePress() {             // interrupt routine
  pressCount++;                  // short and fast
  newEvent = true;
}

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  DDRB |= 0b00001111;                // pins 8..11: the counter, in binary
  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), handlePress, FALLING);
}

void loop() {
  if (newEvent) {                    // the processing happens HERE
    newEvent = false;
    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
    // show the counter in binary on pins 8..11
    PORTB = (PORTB & 0xF0) | (pressCount & 0x0F);
  }

  delay(200);                        // a long task - the event is NOT lost
}

The direct register access variant

volatile uint16_t counter = 0;

ISR(INT0_vect) {              // the external interrupt 0 vector
  counter++;
  PORTB ^= (1 << PB5);        // toggle the LED on pin 13
}

void setup() {
  DDRB  |= (1 << PB5);        // pin 13 output
  DDRD  &= ~(1 << PD2);       // pin 2 input
  PORTD |= (1 << PD2);        // internal pull-up

  EICRA |=  (1 << ISC01);     // ISC01 = 1
  EICRA &= ~(1 << ISC00);     // ISC00 = 0  -> falling edge
  EIMSK |=  (1 << INT0);      // enable INT0

  sei();                      // enable global interrupts
}

void loop() {
  // the main program stays completely free
}

Debounce inside an interrupt

volatile unsigned long lastInterrupt = 0;
volatile uint16_t realPressCount = 0;

void handlePress() {
  unsigned long now = millis();          // millis() can be READ inside the ISR
  if (now - lastInterrupt > 50) {        // ignore anything within 50 ms
    realPressCount++;
    lastInterrupt = now;
  }
}

void setup() {
  pinMode(2, INPUT_PULLUP);
  DDRB |= 0b00001111;                     // pins 8..11: the counter, in binary
  attachInterrupt(digitalPinToInterrupt(2), handlePress, FALLING);
}

void loop() {
  static uint16_t shown = 0;

  // protected read of the 16-bit variable
  uint8_t sreg = SREG;
  cli();
  uint16_t v = realPressCount;
  SREG = sreg;

  if (v != shown) {                       // it changed: refresh the bar
    shown = v;
    PORTB = (PORTB & 0xF0) | (v & 0x0F);
  }
}

Measuring latency

// Connect pin 7 to pin 2 with a short wire.
// Pin 7 generates the pulse, pin 2 detects it through an interrupt.
// Latency is MEASURED WITH THE OSCILLOSCOPE, on channels 7 and 4:
// the distance between the falling edge on 7 and the rising edge on 4.

void onEdge() {
  PORTD |= (1 << PD4);         // first instruction in the ISR: raise the marker
}

void setup() {
  pinMode(7, OUTPUT);
  digitalWrite(7, HIGH);
  pinMode(4, OUTPUT);          // marker for entering the ISR
  pinMode(2, INPUT);
  attachInterrupt(digitalPinToInterrupt(2), onEdge, FALLING);
  delay(100);
}

void loop() {
  PORTD &= ~(1 << PD4);        // lower the marker before the measurement
  digitalWrite(7, HIGH);
  delay(50);

  digitalWrite(7, LOW);        // generate the falling edge = time zero

  delay(500);
}

12Interactive circuit

The difference between polling and interrupts is best understood when you see a press get lost. The circuit below has two counters shown in binary on LEDs: one updated by polling in a loop with long pauses, the other from an interrupt routine. Press the button rapidly and watch which one falls behind.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

/* Each counter is shown in binary on 4 LEDs:
   pins  8..11 = presses caught by INTERRUPT
   pins  3..6  = presses caught by POLLING      */

volatile unsigned char byInterrupt = 0;
unsigned char byPolling = 0;

ISR(INT0_vect)                  // runs at any time, immediately
{
    byInterrupt++;
    PORTB = (PORTB & 0xF0) | (byInterrupt & 0x0F);
}

int main(void)
{
    DDRB  |= 0x0F;                       // pins 8..11, outputs
    DDRD  |= (1 << PD3) | (1 << PD4) | (1 << PD5) | (1 << PD6);
    DDRD  &= ~(1 << PD2);                // pin 2, input
    PORTD |=  (1 << PD2);                // internal pull-up

    EICRA |= (1 << ISC01);      // falling edge
    EIMSK |= (1 << INT0);
    sei();

    while (1) {
        /* the main loop is busy for 400 ms with "something else" */
        _delay_ms(400);

        if (!(PIND & (1 << PD2))) {      // polling: only catches what it happens upon
            byPolling++;
            /* bits 3..6 of PORTD, without disturbing the pull-up on PD2 */
            PORTD = (PORTD & 0x87) | ((byPolling & 0x0F) << 3);
        }
    }
}

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

volatile unsigned char presses = 0;

ISR(INT0_vect)
{
    /* Rule: an ISR must be very short.
       Here we only count - the rest happens in the main loop. */
    presses++;
}

int main(void)
{
    DDRB  |= (1 << PB5) | 0x0F;   // the threshold LED + the 4-LED bar
    DDRD  &= ~(1 << PD2);
    PORTD |=  (1 << PD2);

    EICRA |= (1 << ISC01);
    EIMSK |= (1 << INT0);
    sei();

    while (1) {
        /* Complete this:
           1. Safely read the variable "presses" into a local copy.
              To do this, stop interrupts with cli(), copy, then sei().
           2. Show the copy in binary on the bar:
                 PORTB = (PORTB & 0xF0) | (copy & 0x0F);
           3. If 5 presses have accumulated, light the LED on pin 13.
           4. At 10 presses, bring the counter back to 0 and turn off the LED. */

        _delay_ms(100);
    }
}

13Work tasks

• Build the circuit with a button on pin 2 and an LED on pin 13.
• Implement counting presses by polling, with delay(200) in the loop. Press rapidly and observe how many presses are lost.
• Rewrite the program using interrupts and repeat the test - compare the results.
• Remove the word volatile and compile with optimizations; observe whether the program hangs.
• Add bounce filtering inside the ISR and check that each physical press produces exactly one increment.
• Configure the second button on INT1 (pin 3) so that it resets the counter.
• Change the trigger type from FALLING to CHANGE and explain why the counter increases twice as fast.
• Measure the interrupt latency with the program above and compare it with the polling latency.

14Extended application

15Review questions

16Resources

• This lab's handout (PDF)
• The complete lab handout
• The course page - all materials