Crates.io | embedded-runtime |
lib.rs | embedded-runtime |
version | 0.3.0 |
source | src |
created_at | 2023-07-15 01:43:55.949078 |
updated_at | 2024-05-24 22:28:15.431141 |
description | A tiny async runtime for embedded devices |
homepage | |
repository | https://github.com/KizzyCode/embedded-runtime-rust |
max_upload_size | |
id | 916918 |
size | 22,349 |
embedded-runtime
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 is hardware-independent, and needs some dependency-injection to perform signal/wait on your target hardware.
To provide these dependencies, you need to define the following two extern "Rust"
functions:
_runtime_waitforevent_TBFzxdKN
: Blocks until an event occurs (may wake spuriously). Important: Events must not be
lost. If an event has occurred between the last invocation and this invocation, this function must not block._runtime_sendevent_3YSaPmB7
: Raises an event. Important: Events must not be lost. If an event is sent, but the
receiver is not currently waiting, it must be retained until the receiver tries to wait again.For an example on how to inject your implementation, see also embedded-runtime-rp2040
, which is basically this crate
with wfe
/sev
-based runtime functions for rp2040
boards.
# 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");