[](https://opensource.org/licenses/BSD-2-Clause)
[](https://opensource.org/licenses/MIT)
[](https://ci.appveyor.com/project/KizzyCode/embedded-runtime-rust)
[](https://docs.rs/embedded-runtime)
[](https://crates.io/crates/embedded-runtime)
[](https://crates.io/crates/embedded-runtime)
[](https://deps.rs/crate/embedded-runtime)
# `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
```rust
# use core::{
# future::Future,
# pin::Pin,
# task::{Poll, Context}
# };
#
# /// Blocks until an event occurs (may wake spuriously)
# #[no_mangle]
# #[allow(non_snake_case)]
# pub fn _runtime_waitforevent_TBFzxdKN() {
# // No-op
# }
#
# /// Raises an event
# #[no_mangle]
# #[allow(non_snake_case)]
# pub fn _runtime_sendevent_3YSaPmB7() {
# // No-op
# }
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");
```