Help with ISRs in Zephyr 😅 - Part One

[alexpaschoaletto]

I'm trying to understand how to use the dynamic ISR API in Zephr and have developed the following code snippet based on the interrupt test suite (mostly from this file), which just checks if the interrupt has been triggered.

#include <zephyr/kernel.h>

/* for trigger_irq below */
#include <zephyr/subsys/testsuite/include/zephyr/interrupt_util.h>


int interrupt_counter;

void interrupt_callback(const void *arg){
    ARG_UNUSED(arg);
    interrupt_counter++;
}

int main()
{
    uint irq = 25;
    int irq_priority = 10;
    int fails = 0;
    int expected_fails = 0;

    int vectorNumber = irq_connect_dynamic(irq, irq_priority, interrupt_callback, NULL, 0);
    printk("TEST: triggering IRQ %u with line enabled. Expected fails: 0.\n", irq);

    interrupt_counter = 0;

    irq_enable(irq);

    printk("TEST: vector number is %d.\n\n", vectorNumber);

    for(int i = 0; i < 3; i++){
        int expected = (i+1);

        trigger_irq(vectorNumber);
        k_sleep(K_MSEC(1000));

        if(interrupt_counter != expected){
            fails++;
        }
        printk("TEST: trigger: %d, ISR count: %d.\n", expected, interrupt_counter);
    }

    irq_disable(irq);

    printk("\nTEST: expected: %d errors; got: %d.", expected_fails, fails);
    return 0;
}

However, it seems like the ISR never runs in the first place:

TEST: triggering IRQ 25 with line enabled. Expected fails: 0.
TEST: vector number is 25.

TEST: trigger: 1, ISR count: 0.
TEST: trigger: 2, ISR count: 0.
TEST: trigger: 3, ISR count: 0.

TEST: expected: 0 errors; got: 3.

Can anyone help me understand why is that? Have I made something wrong?

Here's the .conf:

	CONFIG_SHARED_INTERRUPTS=y
	CONFIG_DYNAMIC_INTERRUPTS=y

[ldomaigne]

Hi,

what are you trying to achieve, exactly?

In Zephyr, most common subsystems have an interrupt-driven API that can be used directly. Here, you just register your callback and configure how to the interrupt should be triggered (failing/rising edge, or on level). For instance, to implement a push button, you would typically use leverage the GPIO subsystem. See basic button example.

Next, ISRs are special beast. ISR overtakes everything in the system. It runs on its own stack. You are restricted in what you can do. Only the API marked "ISR-ok" are OK to be used in ISR (some API might be ISR-ok but not documented as such). If your ISR takes 500ms to complete, you block your system for 500ms (busy processing your ISR). You can't block or wait. So if a function takes a timeout, it should be always uses K_NO_WAIT ...

That being said, you should declare the interrupt counter variable as volatile. Otherwise the compiler might optimize out the load operation, because it sees no one is calling the ISR. Indeed, this function is called by the Interrupt Controller/CPU when the IRQ line is asserted.

volatile int interrupt_counter; // you need volatile