Interrupt Handlers + Async

[zpg6]

For UART and SPI, how to set async functions as handlers for interrupts of Async versions (like Uart)? Ex: RxFifoFull

And can I manage the priorities between embassy tasks and interrupt handler functions?

[zpg6]

Or is there a more ergonomic way to await some interrupt being triggered within an embassy task (avoiding the handler)?

[zpg6]

Trying to replicate the examples/gpio_interrupt.rs example:

When I run

cargo xtask run-example esp-hal esp32 uart_interrupt

It's not available?

error[E0599]: no method named `set_interrupt_handler` found for struct `Uart` in the current scope
  --> src/bin/uart_interrupt.rs:44:10
   |
44 |     uart.set_interrupt_handler(handler);
   |          ^^^^^^^^^^^^^^^^^^^^^ method not found in `Uart<'_, Async>`

error[E0599]: no method named `listen` found for struct `Uart<'_, Async>` in the current scope
  --> src/bin/uart_interrupt.rs:47:14
   |
47 |         uart.listen(UartInterrupt::RxFifoFull);
   |              ^^^^^^ method not found in `Uart<'_, Async>`
   |
   = note: the method was found for
           - `Uart<'_, Blocking, T>`

error[E0599]: no method named `is_interrupt_set` found for mutable reference `&mut Uart<'static, Async>` in the current scope
  --> src/bin/uart_interrupt.rs:73:14
   |
69 | /         SERIAL
70 | |             .borrow_ref_mut(cs)
71 | |             .as_mut()
72 | |             .unwrap()
73 | |             .is_interrupt_set()
   | |             -^^^^^^^^^^^^^^^^ method not found in `&mut Uart<'static, Async>`
   | |_____________|
   |

error[E0599]: no method named `clear_interrupt` found for mutable reference `&mut Uart<'static, Async>` in the current scope
  --> src/bin/uart_interrupt.rs:85:14
   |
81 | /         SERIAL
82 | |             .borrow_ref_mut(cs)
83 | |             .as_mut()
84 | |             .unwrap()
85 | |             .clear_interrupt()
   | |             -^^^^^^^^^^^^^^^ method not found in `&mut Uart<'static, Async>`
   | |_____________|

View Example Code

//! Example of responding to UART interrupts.
//!
//! The following wiring is assumed:
//! - TX => GPIO17
//! - RX => GPIO16

//% CHIPS: esp32 esp32c2 esp32c3 esp32c6 esp32h2 esp32s2 esp32s3

#![no_std]
#![no_main]

use core::cell::RefCell;

use critical_section::Mutex;
use esp_backtrace as _;
use esp_hal::{
    Async,
    delay::Delay,
    entry,
    interrupt::InterruptConfigurable,
    macros::{handler, ram},
    uart::{Config as UartConfig, DataBits, StopBits, Uart, UartInterrupt},
};

static SERIAL: Mutex<RefCell<Option<Uart<Async>>>> = Mutex::new(RefCell::new(None));

#[entry]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());
    let uart_config = UartConfig::default()
        .baudrate(19200)
        .data_bits(DataBits::DataBits8)
        .parity_none()
        .stop_bits(StopBits::Stop1)
        .rx_fifo_full_threshold(11);
    let mut uart = Uart::new(
        peripherals.UART1,
        uart_config,
        peripherals.GPIO17, // TX
        peripherals.GPIO16, // RX
    ).expect("Failed to initialize UART")
    .into_async();

    uart.set_interrupt_handler(handler);

    critical_section::with(|cs| {
        uart.listen(UartInterrupt::RxFifoFull);
        SERIAL.borrow_ref_mut(cs).replace(uart);
    });

    loop {}
}

#[handler]
#[ram]
fn handler() {
    cfg_if::cfg_if! {
        if #[cfg(any(feature = "esp32", feature = "esp32s2", feature = "esp32s3"))] {
            esp_println::println!(
                "UART Interrupt with priority {}",
                esp_hal::xtensa_lx::interrupt::get_level()
            );
        } else {
            esp_println::println!("UART Interrupt");
        }
    }

    if critical_section::with(|cs| {
        SERIAL
            .borrow_ref_mut(cs)
            .as_mut()
            .unwrap()
            .is_interrupt_set()
    }) {
        esp_println::println!("SERIAL was the source of the interrupt");
    } else {
        esp_println::println!("SERIAL was not the source of the interrupt");
    }

    critical_section::with(|cs| {
        SERIAL
            .borrow_ref_mut(cs)
            .as_mut()
            .unwrap()
            .clear_interrupt()
    });
}

[Dominaezzz]

You're not allowed to touch the interrupts when the driver is in async mode. Remove into_async().

[zpg6]

Can you explain why not allowed in async mode?

I did get it in Blocking but the API is a bit different I see:

//! Example of responding to UART interrupts.
//!
//! The following wiring is assumed:
//! - TX => GPIO17
//! - RX => GPIO16

//% CHIPS: esp32 esp32c2 esp32c3 esp32c6 esp32h2 esp32s2 esp32s3

#![no_std]
#![no_main]

use core::cell::RefCell;

use critical_section::Mutex;
use esp_backtrace as _;
use esp_hal::{
    Blocking,
    delay::Delay,
    entry,
    interrupt::InterruptConfigurable,
    macros::{handler, ram},
    uart::{Config as UartConfig, DataBits, StopBits, Uart, UartInterrupt},
};

static SERIAL: Mutex<RefCell<Option<Uart<Blocking>>>> = Mutex::new(RefCell::new(None));

#[entry]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());
    let uart_config = UartConfig::default()
        .baudrate(19200)
        .data_bits(DataBits::DataBits8)
        .parity_none()
        .stop_bits(StopBits::Stop1)
        .rx_fifo_full_threshold(11);
    let mut uart = Uart::new(
        peripherals.UART1,
        uart_config,
        peripherals.GPIO17, // TX
        peripherals.GPIO16, // RX
    ).expect("Failed to initialize UART");

    uart.set_interrupt_handler(handler);

    critical_section::with(|cs| {
        uart.listen(UartInterrupt::RxFifoFull);
        SERIAL.borrow_ref_mut(cs).replace(uart);
    });

    loop {}
}

#[handler]
#[ram]
fn handler() {
    cfg_if::cfg_if! {
        if #[cfg(any(feature = "esp32", feature = "esp32s2", feature = "esp32s3"))] {
            esp_println::println!(
                "UART Interrupt with priority {}",
                esp_hal::xtensa_lx::interrupt::get_level()
            );
        } else {
            esp_println::println!("UART Interrupt");
        }
    }

    if critical_section::with(|cs| {
        SERIAL
            .borrow_ref_mut(cs)
            .as_mut()
            .unwrap()
            .interrupts()
            .contains(UartInterrupt::RxFifoFull)
    }) {
        esp_println::println!("SERIAL was the source of the interrupt");
    } else {
        esp_println::println!("SERIAL was not the source of the interrupt");
    }

    critical_section::with(|cs| {
        SERIAL
            .borrow_ref_mut(cs)
            .as_mut()
            .unwrap()
            .clear_interrupts(UartInterrupt::RxFifoFull.into());
    });
}

[Dominaezzz]

Can you explain why not allowed in async mode?

Because the interrupts are being used to provide the async features. If you mess with the interrupts, the async APIs may not work correctly.

[zpg6]

Okay yes, I suppose the answer is - it's an API decision that any use cases for interrupts while in Async mode need to be formally added to the HAL or use the PAC directly.

In #2858 I want to add ability to respond to a UART break interrupt. Well, I thought a handler on that added interrupt would be best but didn't realize it's not exposed if I otherwise want to do async reading and writing.

What do you recommend?

[Dominaezzz]

Probably add a uart.wait_for_break().await method. I don't use UART enough to be sure

[Dominaezzz]

Oh, looks like you did that already

[zpg6]

In my mind the best way to do LIN RX is using a state machine and inputs to it of detecting Break and detecting RxFifoFull on (1 byte threshold for interrupt each byte).

But wait_for_break_async().await doesn't give me that option. On the other hand, uart.set_interrupt_handler(handler); would allow for uart.listen(UartInterrupt::RxFifoFull | UartInterrupt::RxBreakDetected); -- it can handle both interrupt events!

I'll try with the blocking version since those operations are quick if I use interrupts otherwise. We'll see.