Interrupts

# Interrupts

## Polling

```rust
loop {
    if button.is_low() {
        // react to button press
    }
    // CPU is busy-waiting here
}
```

</div>

</div>
<div>

The CPU constantly checks the state of a peripheral in a loop.

- Simple to implement
- Wastes CPU cycles
- Processor is busy-waiting even when nothing happens

</div>
</div>

---

## Interrupts

```rust
loop {
    // CPU can sleep or do other work
}

#[handler]
fn gpio_handler() {
    // react to the event
}
```

</div>

</div>
<div>

The hardware notifies the CPU when an event occurs.

- CPU wakes only when needed
- More efficient
- Requires additional setup

</div>
</div>

---

## Components of Interrupt Code

```rust
// 1. Global Shared Data
static SHARED: Mutex<RefCell<Option<Input>>> =
    Mutex::new(RefCell::new(None));

fn main() {
    // 2. Interrupt Setup
    button.listen(Event::FallingEdge);
    critical_section::with(|cs| {
        SHARED.borrow_ref_mut(cs)
            .replace(button);
    });
}

// 3. Interrupt Service Routine
#[handler]
fn gpio_handler() {
    critical_section::with(|cs| {
        // handle event, clear interrupt
    });
}
```

</div>

</div>
<div>

Three components:

1. **Global Shared Data** — data shared between main thread and ISR

2. **Interrupt Setup** — configure what event to listen for, enable it, move data to shared state

3. **ISR** — code that reacts to the interrupt event

</div>
</div>

---

## Setup Happens in the Configure Stage

Setup entails three steps:

1. **Configuring the interrupt** — What do we want to listen to?
    - Edge events (rising, falling, any)
    - Level events (high, low)

2. **Enabling the interrupt** — Allowing the interrupt events to go through
    - Peripheral-level enable
    - Interrupt controller enable

3. **Configuring global shared data** — Setting up shared state
    - `Mutex<RefCell<Option<T>>>` pattern
    - Moving peripherals into global statics via `critical_section`

The Embedded Rustacean · Rust Week 2026