Interrupts

Learn to write interrupt handlers.

Interrupt

An interrupt is hardware notifying the CPU of an event. The CPU drops the current instruction, saves registers and jumps to the interrupt service routine (ISR). When the ISR ends, the CPU returns to its previous work.

ISRs must be very short: other interrupts may be delayed, the system may lock up. They do not throw exceptions (usually compiled with -fno-exceptions), do not use the heap, have no long loops. The hardware flag is cleared, a flag is set on a shared variable, the main loop does the work.

Shared variable is volatile

A variable shared between the ISR and the main loop must be volatile. Otherwise the compiler may read the variable once in the main loop and cache it; it will not see the new value written by the ISR.

Example: volatile bool flag = false;. The ISR sets flag = true;; the main loop waits with while (!flag) { }. Without volatile the compiler reads flag once and loops forever. So every variable shared with an ISR must be volatile.

Exercise Use ISR-style volatile variables

Define global volatile bool flag = false; and volatile int counter = 0;. In main write flag = true;, counter = 5; and std::cout << counter;.

Show example solution

#include <iostream>

volatile bool flag = false;
volatile int counter = 0;

int main() {
    flag = true;
    counter = 5;
    std::cout << counter;
    return 0;
}

Test yourself

What does an ISR usually NOT do?
```
__attribute__((interrupt)) void isr() { /* ... */ }
```
- Return quickly
- Throw an exception
- Clear the flag
- Write to hardware
Show answer

Throw an exception — ISRs do not throw exceptions; exception tables are expensive and return is complex.

Complete the ISR name

__attribute__((interrupt)) void ____() { /* ISR body */ }

Show answer

__attribute__((interrupt)) void isr() { /* ISR body */ }

Match each concept to its role

ISR

Interrupt service routine
volatile

Shared variable
noexcept

No exception
flag

Interrupt flag

Next lesson: Real-time

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies