Struct embassy_executor::InterruptExecutor
source · pub struct InterruptExecutor { /* private fields */ }
Expand description
Interrupt mode executor.
This executor runs tasks in interrupt mode. The interrupt handler is set up to poll tasks, and when a task is woken the interrupt is pended from software.
This allows running async tasks at a priority higher than thread mode. One use case is to leave thread mode free for non-async tasks. Another use case is to run multiple executors: one in thread mode for low priority tasks and another in interrupt mode for higher priority tasks. Higher priority tasks will preempt lower priority ones.
It is even possible to run multiple interrupt mode executors at different priorities, by assigning different priorities to the interrupts. For an example on how to do this, See the ‘multiprio’ example for ‘embassy-nrf’.
To use it, you have to pick an interrupt that won’t be used by the hardware. Some chips reserve some interrupts for this purpose, sometimes named “software interrupts” (SWI). If this is not the case, you may use an interrupt from any unused peripheral.
It is somewhat more complex to use, it’s recommended to use the thread-mode
[Executor
] instead, if it works for your use case.
Implementations§
source§impl InterruptExecutor
impl InterruptExecutor
sourcepub unsafe fn on_interrupt(&'static self)
pub unsafe fn on_interrupt(&'static self)
Executor interrupt callback.
§Safety
- You MUST call this from the interrupt handler, and from nowhere else.
- You must not call this before calling
start()
.
sourcepub fn start(&'static self, irq: impl InterruptNumber) -> SendSpawner
pub fn start(&'static self, irq: impl InterruptNumber) -> SendSpawner
Start the executor.
This initializes the executor, enables the interrupt, and returns. The executor keeps running in the background through the interrupt.
This returns a [SendSpawner
] you can use to spawn tasks on it. A [SendSpawner
]
is returned instead of a Spawner
because the executor effectively runs in a
different “thread” (the interrupt), so spawning tasks on it is effectively
sending them.
To obtain a Spawner
for this executor, use Spawner::for_current_executor()
from
a task running in it.
§Interrupt requirements
You must write the interrupt handler yourself, and make it call on_interrupt()
.
This method already enables (unmasks) the interrupt, you must NOT do it yourself.
You must set the interrupt priority before calling this method. You MUST NOT do it after.
sourcepub fn spawner(&'static self) -> SendSpawner
pub fn spawner(&'static self) -> SendSpawner
Get a SendSpawner for this executor
This returns a [SendSpawner
] you can use to spawn tasks on this
executor.
This MUST only be called on an executor that has already been started. The function will panic otherwise.