Crate embedded_runtime_nrf52840

embedded-runtime-nrf52840

This crate provides a tiny async runtime, targeted at embedded devices. Therefore, it provides a single-threaded executor as well as a stack-allocated box to box futures. This crate injects a hardware implementation for the nrf52840, based upon wfe/sev.

Example

use embedded_runtime::run;

/// A countdown future that resolves to pending until the poll-countdown becomes zero
struct CountdownFuture {
    /// The current countdown value
    countdown: usize
}
impl CountdownFuture {
    /// Creates a new countdown future
    pub const fn new(countdown: usize) -> Self {
        Self { countdown }
    }
}
impl Future for CountdownFuture {
    type Output = ();

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
        // Decrement the value if we are still pending
        if self.countdown > 0 {
            // Print the countdown
            println!("{}!", self.countdown);

            // Decrement the future, wake the executor and return pending
            *self = Self::new(self.countdown - 1);
            cx.waker().wake_by_ref();
            return Poll::Pending;
        }

        // Return ready
        println!("Liftoff 🚀");
        Poll::Ready(())
    }
}

// This creates a new runtime and executes the given futures in an async context
run!(async {
    CountdownFuture::new(3).await;
    CountdownFuture::new(7).await;
}).expect("failed to perform countdowns");

Modules

• error
  A runtime related error type
• executor
  The executor for this runtime
• spin
  A future to spin once to give up a timeslice

Macros

• err
  Creates a new error
• run
  Creates an executor and executes the given futures

Structs

• Executor
  A tiny stack-based, single-threaded async executor suitable for embedded runtimes

Functions

• spin_once
  A function that can be awaited once before it returns; useful to cooperatively give up a timeslice to the runtime/other pending futures