mirror of
https://github.com/rtic-rs/rtic.git
synced 2024-12-01 16:04:33 +01:00
wip, gen_ok, handwritten POC
This commit is contained in:
Per
parent
06e6e9dc9d
commit
c029601b7c
1 changed files with 352 additions and 0 deletions
352
examples/gen_ok.rs
Normal file
352
examples/gen_ok.rs
Normal file
|
|
@ -0,0 +1,352 @@
|
|||
#![feature(prelude_import)]
|
||||
//! examples/idle.rs
|
||||
#![feature(generator_trait)]
|
||||
#![feature(generators)]
|
||||
#![feature(never_type)]
|
||||
#![feature(type_alias_impl_trait)]
|
||||
#![feature(const_fn)]
|
||||
#![feature(fmt_internals)]
|
||||
#![feature(compiler_builtins_lib)]
|
||||
#![no_main]
|
||||
#![no_std]
|
||||
#[rustfmt::skip]
|
||||
#[prelude_import]
|
||||
use core::prelude::v1::*;
|
||||
#[macro_use]
|
||||
extern crate core;
|
||||
#[macro_use]
|
||||
extern crate compiler_builtins;
|
||||
|
||||
use core::ops::Generator;
|
||||
use cortex_m_semihosting::{debug, hprintln};
|
||||
use lm3s6965::Interrupt;
|
||||
use panic_semihosting as _;
|
||||
use rtfm::{Exclusive, Mutex};
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
fn init(_: init::Context) {
|
||||
// #[task(binds = GPIOA, resources = [shared2])]
|
||||
// // fn foo1(ctx: &'static mut foo1::Context) -> impl Generator<Yield = (), Return = !> {
|
||||
// fn foo1(mut ctx: foo1::Context) -> impl Generator<Yield = (), Return = !> {
|
||||
// let mut local = 0;
|
||||
// //let shared_res = Exclusive(ctx.resources.shared);
|
||||
// // static shared_res : &mut u32 = ctx.resources.shared;
|
||||
// // hprintln!("init foo1: {}", ctx.resources.shared);
|
||||
// static mut X: u32 = 0;
|
||||
// // let mut e = Exclusive(unsafe { &mut X });
|
||||
// // //let mut e = Exclusive(ctx.resources.shared);
|
||||
// // hprintln!(
|
||||
// // "ex {:?}",
|
||||
// // e.lock(|v| {
|
||||
// // *v += 1;
|
||||
// // *v
|
||||
// // })
|
||||
// // )
|
||||
// // .unwrap();
|
||||
// hprintln!("{}", ctx.resources.shared2.lock(|v| *v));
|
||||
// move || loop {
|
||||
// hprintln!("foo1_1 {} {}", local, unsafe { X }).unwrap();
|
||||
// // hprintln!(
|
||||
// // "ex {}",
|
||||
// // e.lock(|v| {
|
||||
// // *v += 1;
|
||||
// // *v
|
||||
// // })
|
||||
// // )
|
||||
// // .unwrap();
|
||||
|
||||
// local += 1;
|
||||
// // shared_res.lock(|s| hprintln!("s {}", s));
|
||||
// // *shared_res += 1;
|
||||
// // *ctx.resources.shared += 1;
|
||||
// unsafe { X += 1 };
|
||||
// yield;
|
||||
// hprintln!("foo1_2 {} {}", local, unsafe { X }).unwrap();
|
||||
// local += 1;
|
||||
// // unsafe { X += 1 };
|
||||
// yield;
|
||||
// }
|
||||
// }
|
||||
|
||||
// ctx.resources.shared2.lock(|v| *v);
|
||||
// hprintln!("{}", ctx.resources.shared2.lock(|v| *v)).unwrap();
|
||||
|
||||
::cortex_m_semihosting::export::hstdout_str("init\n").unwrap();
|
||||
rtfm::pend(Interrupt::GPIOA);
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
fn idle(_: idle::Context) -> ! {
|
||||
use rtfm::Mutex as _;
|
||||
::cortex_m_semihosting::export::hstdout_str("idle\n").unwrap();
|
||||
rtfm::pend(Interrupt::GPIOA);
|
||||
::cortex_m_semihosting::export::hstdout_str("idle1\n").unwrap();
|
||||
rtfm::pend(Interrupt::GPIOA);
|
||||
debug::exit(debug::EXIT_SUCCESS);
|
||||
loop {}
|
||||
}
|
||||
#[rustfmt::skip]
|
||||
type Generatorfoo1= impl Generator<Yield = (), Return = !>;
|
||||
static mut GENERATOR_FOO1: core::mem::MaybeUninit<Generatorfoo1> =
|
||||
core::mem::MaybeUninit::uninit();
|
||||
#[allow(non_snake_case)]
|
||||
fn foo1(mut ctx: foo1::Context) -> Generatorfoo1 {
|
||||
use rtfm::Mutex as _;
|
||||
// ctx.resources.shared2.lock(|v| *v);
|
||||
move || loop {
|
||||
ctx.resources.shared2.lock(|v| {
|
||||
*v += 1;
|
||||
hprintln!("{}", v)
|
||||
});
|
||||
::cortex_m_semihosting::export::hstdout_str("foo1_1\n").unwrap();
|
||||
yield;
|
||||
ctx.resources.shared2.lock(|v| {
|
||||
*v += 1;
|
||||
hprintln!("{}", v)
|
||||
});
|
||||
::cortex_m_semihosting::export::hstdout_str("foo1_2\n").unwrap();
|
||||
yield;
|
||||
}
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
fn foo2(mut ctx: foo2::Context) {
|
||||
use rtfm::Mutex as _;
|
||||
ctx.resources.shared2.lock(|v| *v += 1);
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
fn foo3(mut ctx: foo3::Context) {
|
||||
use rtfm::Mutex as _;
|
||||
ctx.resources.shared2.lock(|v| *v += 1);
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[doc = "Initialization function"]
|
||||
pub mod init {
|
||||
fn plepps() {}
|
||||
#[doc = r" Execution context"]
|
||||
pub struct Context {
|
||||
#[doc = r" Core (Cortex-M) peripherals"]
|
||||
pub core: rtfm::export::Peripherals,
|
||||
}
|
||||
impl Context {
|
||||
#[inline(always)]
|
||||
pub unsafe fn new(core: rtfm::export::Peripherals) -> Self {
|
||||
Context { core }
|
||||
}
|
||||
}
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[doc = "Idle loop"]
|
||||
pub mod idle {
|
||||
fn plepps() {}
|
||||
#[doc = r" Execution context"]
|
||||
pub struct Context {}
|
||||
impl Context {
|
||||
#[inline(always)]
|
||||
pub unsafe fn new(priority: rtfm::export::Priority) -> Self {
|
||||
Context {}
|
||||
}
|
||||
}
|
||||
}
|
||||
mod resources {
|
||||
use rtfm::export::Priority;
|
||||
#[allow(non_camel_case_types)]
|
||||
pub struct shared2 {
|
||||
priority: Priority,
|
||||
}
|
||||
impl shared2 {
|
||||
#[inline(always)]
|
||||
pub unsafe fn new(priority: Priority) -> Self {
|
||||
shared2 { priority }
|
||||
}
|
||||
#[inline(always)]
|
||||
pub unsafe fn priority(&self) -> Priority {
|
||||
self.priority.clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[doc = "Resources `foo1` has access to"]
|
||||
pub struct foo1Resources {
|
||||
pub shared2: resources::shared2,
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[doc = "Hardware task"]
|
||||
pub mod foo1 {
|
||||
fn plepps() {}
|
||||
#[doc(inline)]
|
||||
pub use super::foo1Resources as Resources;
|
||||
#[doc = r" Execution context"]
|
||||
pub struct Context {
|
||||
#[doc = r" Resources this task has access to"]
|
||||
pub resources: Resources,
|
||||
}
|
||||
impl<'a> Context {
|
||||
#[inline(always)]
|
||||
pub unsafe fn new(priority: rtfm::export::Priority) -> Self {
|
||||
Context {
|
||||
resources: Resources::new(priority),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[doc = "Resources `foo2` has access to"]
|
||||
pub struct foo2Resources {
|
||||
pub shared2: resources::shared2,
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[doc = "Hardware task"]
|
||||
pub mod foo2 {
|
||||
fn plepps() {}
|
||||
#[doc(inline)]
|
||||
pub use super::foo2Resources as Resources;
|
||||
#[doc = r" Execution context"]
|
||||
pub struct Context {
|
||||
#[doc = r" Resources this task has access to"]
|
||||
pub resources: Resources,
|
||||
}
|
||||
impl Context {
|
||||
#[inline(always)]
|
||||
pub unsafe fn new(priority: rtfm::export::Priority) -> Self {
|
||||
Context {
|
||||
resources: Resources::new(priority),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[doc = "Resources `foo3` has access to"]
|
||||
pub struct foo3Resources {
|
||||
pub shared2: resources::shared2,
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[doc = "Hardware task"]
|
||||
pub mod foo3 {
|
||||
fn plepps() {}
|
||||
#[doc(inline)]
|
||||
pub use super::foo3Resources as Resources;
|
||||
#[doc = r" Execution context"]
|
||||
pub struct Context {
|
||||
#[doc = r" Resources this task has access to"]
|
||||
pub resources: Resources,
|
||||
}
|
||||
impl Context {
|
||||
#[inline(always)]
|
||||
pub unsafe fn new(priority: rtfm::export::Priority) -> Self {
|
||||
Context {
|
||||
resources: Resources::new(priority),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#[doc = r" Implementation details"]
|
||||
const APP: () = {
|
||||
#[doc = r" Always include the device crate which contains the vector table"]
|
||||
use lm3s6965 as _;
|
||||
#[allow(non_upper_case_globals)]
|
||||
static mut shared2: u32 = 1;
|
||||
impl<'a> rtfm::Mutex for resources::shared2 {
|
||||
type T = u32;
|
||||
#[inline(always)]
|
||||
fn lock<R>(&mut self, f: impl FnOnce(&mut u32) -> R) -> R {
|
||||
#[doc = r" Priority ceiling"]
|
||||
const CEILING: u8 = 3u8;
|
||||
unsafe {
|
||||
rtfm::export::lock(
|
||||
&mut shared2,
|
||||
&self.priority(),
|
||||
CEILING,
|
||||
lm3s6965::NVIC_PRIO_BITS,
|
||||
f,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[no_mangle]
|
||||
unsafe fn GPIOA() {
|
||||
const PRIORITY: u8 = 1u8;
|
||||
rtfm::export::run(PRIORITY, || {
|
||||
::cortex_m_semihosting::export::hstdout_str("interrupt dispatch\n")
|
||||
.unwrap();
|
||||
let mut g: &mut dyn Generator<Yield = (), Return = !> =
|
||||
&mut *GENERATOR_FOO1.as_mut_ptr();
|
||||
core::pin::Pin::new_unchecked(&mut *g).resume();
|
||||
});
|
||||
}
|
||||
impl foo1Resources {
|
||||
#[inline(always)]
|
||||
unsafe fn new(priority: rtfm::export::Priority) -> Self {
|
||||
foo1Resources {
|
||||
shared2: resources::shared2::new(priority),
|
||||
}
|
||||
}
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[no_mangle]
|
||||
unsafe fn GPIOB() {
|
||||
const PRIORITY: u8 = 2u8;
|
||||
rtfm::export::run(PRIORITY, || {
|
||||
crate::foo2(foo2::Context::new(rtfm::export::Priority::new(
|
||||
PRIORITY,
|
||||
)))
|
||||
});
|
||||
}
|
||||
impl<'a> foo2Resources {
|
||||
#[inline(always)]
|
||||
unsafe fn new(priority: rtfm::export::Priority) -> Self {
|
||||
foo2Resources {
|
||||
shared2: resources::shared2::new(priority),
|
||||
}
|
||||
}
|
||||
}
|
||||
#[allow(non_snake_case)]
|
||||
#[no_mangle]
|
||||
unsafe fn GPIOC() {
|
||||
const PRIORITY: u8 = 3u8;
|
||||
rtfm::export::run(PRIORITY, || {
|
||||
crate::foo3(foo3::Context::new(rtfm::export::Priority::new(
|
||||
PRIORITY,
|
||||
)))
|
||||
});
|
||||
}
|
||||
impl foo3Resources {
|
||||
#[inline(always)]
|
||||
unsafe fn new(priority: rtfm::export::Priority) -> Self {
|
||||
foo3Resources {
|
||||
shared2: resources::shared2::new(priority),
|
||||
}
|
||||
}
|
||||
}
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn main() -> ! {
|
||||
rtfm::export::interrupt::disable();
|
||||
let mut core: rtfm::export::Peripherals = core::mem::transmute(());
|
||||
let _ = [(); ((1 << lm3s6965::NVIC_PRIO_BITS) - 1u8 as usize)];
|
||||
core.NVIC.set_priority(
|
||||
lm3s6965::Interrupt::GPIOA,
|
||||
rtfm::export::logical2hw(1u8, lm3s6965::NVIC_PRIO_BITS),
|
||||
);
|
||||
rtfm::export::NVIC::unmask(lm3s6965::Interrupt::GPIOA);
|
||||
let _ = [(); ((1 << lm3s6965::NVIC_PRIO_BITS) - 2u8 as usize)];
|
||||
core.NVIC.set_priority(
|
||||
lm3s6965::Interrupt::GPIOB,
|
||||
rtfm::export::logical2hw(2u8, lm3s6965::NVIC_PRIO_BITS),
|
||||
);
|
||||
rtfm::export::NVIC::unmask(lm3s6965::Interrupt::GPIOB);
|
||||
let _ = [(); ((1 << lm3s6965::NVIC_PRIO_BITS) - 3u8 as usize)];
|
||||
core.NVIC.set_priority(
|
||||
lm3s6965::Interrupt::GPIOC,
|
||||
rtfm::export::logical2hw(3u8, lm3s6965::NVIC_PRIO_BITS),
|
||||
);
|
||||
rtfm::export::NVIC::unmask(lm3s6965::Interrupt::GPIOC);
|
||||
let late = init(init::Context::new(core.into()));
|
||||
const PRIORITY: u8 = 1u8;
|
||||
unsafe {
|
||||
GENERATOR_FOO1.as_mut_ptr().write(foo1(foo1::Context::new(
|
||||
rtfm::export::Priority::new(PRIORITY),
|
||||
)));
|
||||
};
|
||||
rtfm::export::interrupt::enable();
|
||||
idle(idle::Context::new(rtfm::export::Priority::new(0)))
|
||||
}
|
||||
};
|
||||
Loading…
Reference in a new issue