Interrupt for TWAI

[axoulc]

Hi everyone,
I tried to implement interrupt for TWAI (RX only). Here what I did, but it doesn't work :

#![no_std]
#![no_main]

/// INCLUDES ....

static CAN_RX_INT: Mutex<RefCell<Option<TwaiRx<TWAI0, Blocking>>>> = Mutex::new(RefCell::new(None));

fn init_heap() {
    const HEAP_SIZE: usize = 32 * 1024;
    static mut HEAP: MaybeUninit<[u8; HEAP_SIZE]> = MaybeUninit::uninit();

    unsafe {
        esp_alloc::HEAP.add_region(esp_alloc::HeapRegion::new(
            HEAP.as_mut_ptr() as *mut u8,
            HEAP_SIZE,
            esp_alloc::MemoryCapability::Internal.into(),
        ));
    }
}

#[entry]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());
    let mut delay = Delay::new();
    let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
    init_heap();

    esp_println::logger::init_logger_from_env();

    let mut can = {
        let can_rx_pin = io.pins.gpio38;
        let can_tx_pin = io.pins.gpio39;
        const TWAI_BAUDRATE: twai::BaudRate = twai::BaudRate::B250K;
        let mut twai_config = twai::TwaiConfiguration::new(
            peripherals.TWAI0,
            can_rx_pin,
            can_tx_pin,
            TWAI_BAUDRATE,
            TwaiMode::Normal,
        );
        twai_config.set_filter(
            const { SingleStandardFilter::new(b"xxxxxxxxxxx", b"x", [b"xxxxxxxx", b"xxxxxxxx"]) },
        );
        twai_config.set_interrupt_handler(can_handler);
        twai_config.start()
    };
    let (can_rx, mut can_tx) = can.split();

    
    critical_section::with(|cs| {
        CAN_RX_INT.borrow_ref_mut(cs).replace(can_rx);
    });

    // I tried with and without the next instruction
    interrupt::enable(
        peripherals::Interrupt::TWAI0,
        interrupt::Priority::Priority,
    )
    .unwrap();

    loop {}
}

#[handler(priority = Priority::Priority1)]
fn can_handler() {
    esp_println::println!("CAN Interrupt");
    critical_section::with(|cs| {
        let mut can_rx = CAN_RX_INT.borrow_ref_mut(cs);
        let can_rx = can_rx.as_mut().unwrap();
        let frame = can_rx.receive().unwrap();
        esp_println::println!("Received a frame: {:?}", frame);
    });
}

If anyone has ever wanted to implement this, I'd be interested. More importantly, is it possible?

Thanks in advance

[MabezDev]

You can use https://docs.esp-rs.org/esp-hal/esp-hal/0.21.1/esp32c3/esp_hal/twai/struct.TwaiConfiguration.html#method.set_interrupt_handler to set the interrupt handler properly.

Remove the calls interrupt::enable, set_interrupt_handler will take care of everything.

[axoulc]

@MabezDev I have already done that without success...

[MabezDev]

Do you receive frames without using interrupts? I.e just using the blocking APIs?

[axoulc]

Yeah, it works like a charm with the same code ! With of course let frame = block!(can_rx.receive()).unwrap(); in the main loop ;)