IRQ – Utilities for writing Interrupt Handlers

This crate provides utilities for handling interrupts on embedded devices.

Please refer to the changelog to see what changed in the last releases.

Features

• Dynamically and atomically registered, zero-allocation interrupt handlers.
• Allows moving data into interrupt handlers, and sharing data between handlers.
• Completely platform agnostic, does not require atomic swap operations (works on eg. thumbv6 targets).

Usage

Add an entry to your Cargo.toml:

[dependencies]
irq = "0.2.3"

Check the API Documentation for how to use the crate's functionality. A small example showcasing the Scoped Interrupts API is provided below:

use irq::{scoped_interrupts, handler, scope};
use mock_pac::interrupt;

// Hook `INT0` and `INT1` using the `#[interrupt]` attribute imported above.
scoped_interrupts! {
    enum Interrupt {
        INT0,
        INT1,
    }

    use #[interrupt];
}

fn main() {
    // Define data to be used (via move or borrow) by the interrupt handlers.
    let mut i = 0;
    let shared = [0, 1, 2];

    // Define handlers using the `handler!` macro.
    handler!(int0 = || i += shared[1]);
    handler!(int1 = || println!("{}", shared[2]));

    // Create a scope and register the handlers.
    scope(|scope| {
        scope.register(Interrupt::INT0, int0);
        scope.register(Interrupt::INT1, int1);

        // The interrupts stay registered for the duration of this closure.
        // This is a good place for the application's idle loop.
    });
}

Rust version support

This crate targets stable Rust. No guarantees are made beyond that, so the minimum supported version might be bumped as needed.