mirror/rtic
1
0
Fork 0
mirror of https://github.com/rtic-rs/rtic.git synced 2025-01-24 01:59:03 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge #494

Browse source 
494: Resoures take 2 r=korken89 a=korken89



Co-authored-by: Emil Fresk <emil.fresk@gmail.com>
This commit is contained in:
bors[bot] 2021-07-09 11:00:11 +00:00 committed by GitHub
commit e1a4d001f8
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
85 changed files with 1094 additions and 1779 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
.github/workflows/build.yml vendored
View file

@ -138,7 +138,7 @@ jobs:
with:
use-cross: false
command: check
args: --examples --target=${{ matrix.target }} --features __min_r1_43,${{ env.V7 }}
args: --examples --target=${{ matrix.target }} --features ${{ env.V7 }}
# Verify the example output with run-pass tests
testexamples:
@ -244,18 +244,15 @@ jobs:
resource
lock
multilock
late
only-shared-access
task
message
capacity
types
not-sync
generics
cfg
pool
ramfunc

6
CHANGELOG.md
View file

@ -5,6 +5,12 @@ This project adheres to [Semantic Versioning](http://semver.org/).
## [Unreleased]
## [v0.6.0-alpha.5] - 2021-07-09
### Changed
- The new resources syntax is implemented.
## [v0.6.0-alpha.4] - 2021-05-27
### Fixed

19
Cargo.toml
View file

@ -14,7 +14,7 @@ name = "cortex-m-rtic"
readme = "README.md"
repository = "https://github.com/rtic-rs/cortex-m-rtic"
version = "0.6.0-alpha.4"
version = "0.6.0-alpha.5"
[lib]
name = "rtic"
@ -31,22 +31,10 @@ required-features = ["__v7"]
name = "schedule"
required-features = ["__v7"]
[[example]]
name = "t-cfg"
required-features = ["__v7"]
[[example]]
name = "t-cfg-resources"
required-features = ["__min_r1_43"]
[[example]]
name = "t-schedule"
required-features = ["__v7"]
[[example]]
name = "types"
required-features = ["__v7"]
[[example]]
name = "double_schedule"
required-features = ["__v7"]
@ -54,14 +42,14 @@ required-features = ["__v7"]
[dependencies]
cortex-m = "0.7.0"
cortex-m-rtic-macros = { path = "macros", version = "0.6.0-alpha.4" }
rtic-monotonic = "0.1.0-alpha.1"
rtic-monotonic = "0.1.0-alpha.2"
rtic-core = "0.3.1"
heapless = "0.6.1"
bare-metal = "1.0.0"
generic-array = "0.14"
[dependencies.dwt-systick-monotonic]
version = "0.1.0-alpha.2"
version = "0.1.0-alpha.3"
optional = true
[build-dependencies]
@ -81,7 +69,6 @@ trybuild = "1"
[features]
# used for testing this crate; do not use in applications
__v7 = ["dwt-systick-monotonic"]
__min_r1_43 = []
[profile.release]
codegen-units = 1

23
examples/big-struct-opt.rs
View file

@ -25,27 +25,32 @@ mod app {
use super::BigStruct;
use core::mem::MaybeUninit;
#[resources]
struct Resources {
#[shared]
struct Shared {
big_struct: &'static mut BigStruct,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
let big_struct = unsafe {
static mut BIG_STRUCT: MaybeUninit<BigStruct> = MaybeUninit::uninit();
#[local]
struct Local {}
#[init(local = [bs: MaybeUninit<BigStruct> = MaybeUninit::uninit()])]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
let big_struct = unsafe {
// write directly into the static storage
BIG_STRUCT.as_mut_ptr().write(BigStruct::new());
&mut *BIG_STRUCT.as_mut_ptr()
cx.local.bs.as_mut_ptr().write(BigStruct::new());
&mut *cx.local.bs.as_mut_ptr()
};
(
init::LateResources {
Shared {
// assign the reference so we can use the resource
big_struct,
},
Local {},
init::Monotonics(),
)
}
#[task(binds = UART0, shared = [big_struct])]
fn task(_: task::Context) {}
}

22
examples/binds.rs
View file

@ -13,13 +13,19 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::UART0);
hprintln!("init").unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[idle]
@ -35,16 +41,14 @@ mod app {
}
}
#[task(binds = UART0)]
fn foo(_: foo::Context) {
static mut TIMES: u32 = 0;
*TIMES += 1;
#[task(binds = UART0, local = [times: u32 = 0])]
fn foo(cx: foo::Context) {
*cx.local.times += 1;
hprintln!(
"foo called {} time{}",
*TIMES,
if *TIMES > 1 { "s" } else { "" }
*cx.local.times,
if *cx.local.times > 1 { "s" } else { "" }
)
.unwrap();
}

10
examples/capacity.rs
View file

@ -12,11 +12,17 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::UART0);
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[task(binds = UART0)]

38
examples/cfg-whole-task.rs
View file

@ -13,22 +13,32 @@ mod app {
#[cfg(debug_assertions)]
use cortex_m_semihosting::hprintln;
#[resources]
struct Resources {
#[shared]
struct Shared {
#[cfg(debug_assertions)] // <- `true` when using the `dev` profile
#[init(0)]
count: u32,
#[cfg(never)]
#[init(0)]
unused: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn().unwrap();
foo::spawn().unwrap();
(init::LateResources {}, init::Monotonics())
(
Shared {
#[cfg(debug_assertions)]
count: 0,
#[cfg(never)]
unused: 1,
},
Local {},
init::Monotonics(),
)
}
#[idle]
@ -40,17 +50,17 @@ mod app {
}
}
#[task(capacity = 2, resources = [count])]
#[task(capacity = 2, shared = [count])]
fn foo(mut _cx: foo::Context) {
#[cfg(debug_assertions)]
{
_cx.resources.count.lock(|count| *count += 1);
_cx.shared.count.lock(|count| *count += 1);
log::spawn(_cx.resources.count.lock(|count| *count)).unwrap();
log::spawn(_cx.shared.count.lock(|count| *count)).unwrap();
}
// this wouldn't compile in `release` mode
// *_cx.resources.count += 1;
// *_cx.shared.count += 1;
// ..
}
@ -58,17 +68,17 @@ mod app {
// The whole task should disappear,
// currently still present in the Tasks enum
#[cfg(never)]
#[task(capacity = 2, resources = [count])]
#[task(capacity = 2, shared = [count])]
fn foo2(mut _cx: foo2::Context) {
#[cfg(debug_assertions)]
{
_cx.resources.count.lock(|count| *count += 10);
_cx.shared.count.lock(|count| *count += 10);
log::spawn(_cx.resources.count.lock(|count| *count)).unwrap();
log::spawn(_cx.shared.count.lock(|count| *count)).unwrap();
}
// this wouldn't compile in `release` mode
// *_cx.resources.count += 1;
// *_cx.shared.count += 1;
// ..
}

65
examples/cfg.rs
View file

@ -1,65 +0,0 @@
//! examples/cfg.rs
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [SSI0, QEI0])]
mod app {
use cortex_m_semihosting::debug;
#[cfg(debug_assertions)]
use cortex_m_semihosting::hprintln;
#[resources]
struct Resources {
#[cfg(debug_assertions)] // <- `true` when using the `dev` profile
#[init(0)]
count: u32,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
foo::spawn().unwrap();
foo::spawn().unwrap();
(init::LateResources {}, init::Monotonics())
}
#[idle]
fn idle(_: idle::Context) -> ! {
debug::exit(debug::EXIT_SUCCESS);
loop {
cortex_m::asm::nop();
}
}
#[task(capacity = 2, resources = [count])]
fn foo(mut _cx: foo::Context) {
#[cfg(debug_assertions)]
{
_cx.resources.count.lock(|count| *count += 1);
log::spawn(_cx.resources.count.lock(|count| *count)).unwrap();
}
// this wouldn't compile in `release` mode
// *_cx.resources.count += 1;
// ..
}
#[cfg(debug_assertions)]
#[task(capacity = 2)]
fn log(_: log::Context, n: u32) {
hprintln!(
"foo has been called {} time{}",
n,
if n == 1 { "" } else { "s" }
)
.ok();
}
}

26
examples/destructure.rs
View file

@ -12,39 +12,39 @@ mod app {
use cortex_m_semihosting::hprintln;
use lm3s6965::Interrupt;
#[resources]
struct Resources {
#[shared]
struct Shared {
// Some resources to work with
#[init(0)]
a: u32,
#[init(0)]
b: u32,
#[init(0)]
c: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::UART0);
rtic::pend(Interrupt::UART1);
(init::LateResources {}, init::Monotonics())
(Shared { a: 0, b: 0, c: 0 }, Local {}, init::Monotonics())
}
// Direct destructure
#[task(binds = UART0, resources = [&a, &b, &c])]
#[task(binds = UART0, shared = [&a, &b, &c])]
fn uart0(cx: uart0::Context) {
let a = cx.resources.a;
let b = cx.resources.b;
let c = cx.resources.c;
let a = cx.shared.a;
let b = cx.shared.b;
let c = cx.shared.c;
hprintln!("UART0: a = {}, b = {}, c = {}", a, b, c).unwrap();
}
// De-structure-ing syntax
#[task(binds = UART1, resources = [&a, &b, &c])]
#[task(binds = UART1, shared = [&a, &b, &c])]
fn uart1(cx: uart1::Context) {
let uart1::Resources { a, b, c } = cx.resources;
let uart1::SharedResources { a, b, c } = cx.shared;
hprintln!("UART0: a = {}, b = {}, c = {}", a, b, c).unwrap();
}

10
examples/double_schedule.rs
View file

@ -15,8 +15,14 @@ mod app {
#[monotonic(binds = SysTick, default = true)]
type MyMono = DwtSystick<8_000_000>; // 8 MHz
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
task1::spawn().ok();
let mut dcb = cx.core.DCB;
@ -25,7 +31,7 @@ mod app {
let mono = DwtSystick::new(&mut dcb, dwt, systick, 8_000_000);
(init::LateResources {}, init::Monotonics(mono))
(Shared {}, Local {}, init::Monotonics(mono))
}
#[task]

10
examples/extern_binds.rs
View file

@ -19,13 +19,19 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::UART0);
hprintln!("init").unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[idle]

10
examples/extern_spawn.rs
View file

@ -21,11 +21,17 @@ fn foo(_c: app::foo::Context, x: i32, y: u32) {
mod app {
use crate::foo;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_c: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn(1, 2).unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
extern "Rust" {

32
examples/generics.rs
View file

@ -14,42 +14,40 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[resources]
struct Resources {
#[init(0)]
#[shared]
struct Shared {
shared: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::UART0);
rtic::pend(Interrupt::UART1);
(init::LateResources {}, init::Monotonics())
(Shared { shared: 0 }, Local {}, init::Monotonics())
}
#[task(binds = UART0, resources = [shared])]
#[task(binds = UART0, shared = [shared], local = [state: u32 = 0])]
fn uart0(c: uart0::Context) {
static mut STATE: u32 = 0;
hprintln!("UART0(STATE = {})", *c.local.state).unwrap();
hprintln!("UART0(STATE = {})", *STATE).unwrap();
// second argument has type `resources::shared`
super::advance(STATE, c.resources.shared);
// second argument has type `shared::shared`
super::advance(c.local.state, c.shared.shared);
rtic::pend(Interrupt::UART1);
debug::exit(debug::EXIT_SUCCESS);
}
#[task(binds = UART1, priority = 2, resources = [shared])]
#[task(binds = UART1, priority = 2, shared = [shared], local = [state: u32 = 0])]
fn uart1(c: uart1::Context) {
static mut STATE: u32 = 0;
hprintln!("UART1(STATE = {})", *c.local.state).unwrap();
hprintln!("UART1(STATE = {})", *STATE).unwrap();
// second argument has type `resources::shared`
super::advance(STATE, c.resources.shared);
// second argument has type `shared::shared`
super::advance(c.local.state, c.shared.shared);
}
}

22
examples/hardware.rs
View file

@ -12,15 +12,21 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
// Pends the UART0 interrupt but its handler won't run until *after*
// `init` returns because interrupts are disabled
rtic::pend(Interrupt::UART0); // equivalent to NVIC::pend
hprintln!("init").unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[idle]
@ -38,17 +44,15 @@ mod app {
}
}
#[task(binds = UART0)]
fn uart0(_: uart0::Context) {
static mut TIMES: u32 = 0;
#[task(binds = UART0, local = [times: u32 = 0])]
fn uart0(cx: uart0::Context) {
// Safe access to local `static mut` variable
*TIMES += 1;
*cx.local.times += 1;
hprintln!(
"UART0 called {} time{}",
*TIMES,
if *TIMES > 1 { "s" } else { "" }
*cx.local.times,
if *cx.local.times > 1 { "s" } else { "" }
)
.unwrap();
}

20
examples/idle.rs
View file

@ -11,19 +11,23 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
hprintln!("init").unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[idle]
fn idle(_: idle::Context) -> ! {
static mut X: u32 = 0;
// Safe access to local `static mut` variable
let _x: &'static mut u32 = X;
#[idle(local = [x: u32 = 0])]
fn idle(cx: idle::Context) -> ! {
// Locals in idle have lifetime 'static
let _x: &'static mut u32 = cx.local.x;
hprintln!("idle").unwrap();

16
examples/init.rs
View file

@ -11,18 +11,22 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[init]
fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) {
static mut X: u32 = 0;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init(local = [x: u32 = 0])]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
// Cortex-M peripherals
let _core: cortex_m::Peripherals = cx.core;
// Device specific peripherals
let _device: lm3s6965::Peripherals = cx.device;
// Safe access to local `static mut` variable
let _x: &'static mut u32 = X;
// Locals in `init` have 'static lifetime
let _x: &'static mut u32 = cx.local.x;
// Access to the critical section token,
// to indicate that this is a critical seciton
@ -32,6 +36,6 @@ mod app {
debug::exit(debug::EXIT_SUCCESS);
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
}

20
examples/lock.rs
View file

@ -12,26 +12,28 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[resources]
struct Resources {
#[init(0)]
#[shared]
struct Shared {
shared: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::GPIOA);
(init::LateResources {}, init::Monotonics())
(Shared { shared: 0 }, Local {}, init::Monotonics())
}
// when omitted priority is assumed to be `1`
#[task(binds = GPIOA, resources = [shared])]
#[task(binds = GPIOA, shared = [shared])]
fn gpioa(mut c: gpioa::Context) {
hprintln!("A").unwrap();
// the lower priority task requires a critical section to access the data
c.resources.shared.lock(|shared| {
c.shared.shared.lock(|shared| {
// data can only be modified within this critical section (closure)
*shared += 1;
@ -51,10 +53,10 @@ mod app {
debug::exit(debug::EXIT_SUCCESS);
}
#[task(binds = GPIOB, priority = 2, resources = [shared])]
#[task(binds = GPIOB, priority = 2, shared = [shared])]
fn gpiob(mut c: gpiob::Context) {
// the higher priority task does still need a critical section
let shared = c.resources.shared.lock(|shared| {
let shared = c.shared.shared.lock(|shared| {
*shared += 1;
*shared

20
examples/message.rs
View file

@ -11,21 +11,25 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn(/* no message */).unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[task]
fn foo(_: foo::Context) {
static mut COUNT: u32 = 0;
#[task(local = [count: u32 = 0])]
fn foo(cx: foo::Context) {
hprintln!("foo").unwrap();
bar::spawn(*COUNT).unwrap();
*COUNT += 1;
bar::spawn(*cx.local.count).unwrap();
*cx.local.count += 1;
}
#[task]

30
examples/multilock.rs
View file

@ -14,29 +14,37 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[resources]
struct Resources {
#[init(0)]
#[shared]
struct Shared {
shared1: u32,
#[init(0)]
shared2: u32,
#[init(0)]
shared3: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::GPIOA);
(init::LateResources {}, init::Monotonics())
(
Shared {
shared1: 0,
shared2: 0,
shared3: 0,
},
Local {},
init::Monotonics(),
)
}
// when omitted priority is assumed to be `1`
#[task(binds = GPIOA, resources = [shared1, shared2, shared3])]
#[task(binds = GPIOA, shared = [shared1, shared2, shared3])]
fn locks(c: locks::Context) {
let mut s1 = c.resources.shared1;
let mut s2 = c.resources.shared2;
let mut s3 = c.resources.shared3;
let mut s1 = c.shared.shared1;
let mut s2 = c.shared.shared2;
let mut s3 = c.shared.shared3;
hprintln!("Multiple single locks").unwrap();
s1.lock(|s1| {

30
examples/not-sync.rs
View file

@ -1,6 +1,6 @@
//! `examples/not-sync.rs`
#![deny(unsafe_code)]
// #![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
@ -12,32 +12,42 @@ pub struct NotSync {
_0: PhantomData<*const ()>,
}
unsafe impl Send for NotSync {}
#[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
mod app {
use super::NotSync;
use core::marker::PhantomData;
use cortex_m_semihosting::debug;
#[resources]
struct Resources {
#[init(NotSync { _0: PhantomData })]
#[shared]
struct Shared {
shared: NotSync,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
debug::exit(debug::EXIT_SUCCESS);
(init::LateResources {}, init::Monotonics())
(
Shared {
shared: NotSync { _0: PhantomData },
},
Local {},
init::Monotonics(),
)
}
#[task(resources = [&shared])]
#[task(shared = [&shared])]
fn foo(c: foo::Context) {
let _: &NotSync = c.resources.shared;
let _: &NotSync = c.shared.shared;
}
#[task(resources = [&shared])]
#[task(shared = [&shared])]
fn bar(c: bar::Context) {
let _: &NotSync = c.resources.shared;
let _: &NotSync = c.shared.shared;
}
}

19
examples/only-shared-access.rs
View file

@ -12,29 +12,32 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[resources]
struct Resources {
#[shared]
struct Shared {
key: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::UART0);
rtic::pend(Interrupt::UART1);
(init::LateResources { key: 0xdeadbeef }, init::Monotonics())
(Shared { key: 0xdeadbeef }, Local {}, init::Monotonics())
}
#[task(binds = UART0, resources = [&key])]
#[task(binds = UART0, shared = [&key])]
fn uart0(cx: uart0::Context) {
let key: &u32 = cx.resources.key;
let key: &u32 = cx.shared.key;
hprintln!("UART0(key = {:#x})", key).unwrap();
debug::exit(debug::EXIT_SUCCESS);
}
#[task(binds = UART1, priority = 2, resources = [&key])]
#[task(binds = UART1, priority = 2, shared = [&key])]
fn uart1(cx: uart1::Context) {
hprintln!("UART1(key = {:#x})", cx.resources.key).unwrap();
hprintln!("UART1(key = {:#x})", cx.shared.key).unwrap();
}
}

10
examples/periodic.rs
View file

@ -16,8 +16,14 @@ mod app {
#[monotonic(binds = SysTick, default = true)]
type MyMono = DwtSystick<8_000_000>; // 8 MHz
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
let mut dcb = cx.core.DCB;
let dwt = cx.core.DWT;
let systick = cx.core.SYST;
@ -26,7 +32,7 @@ mod app {
foo::spawn_after(Seconds(1_u32)).unwrap();
(init::LateResources {}, init::Monotonics(mono))
(Shared {}, Local {}, init::Monotonics(mono))
}
#[task]

10
examples/peripherals-taken.rs
View file

@ -9,11 +9,17 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::debug;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
assert!(cortex_m::Peripherals::take().is_none());
debug::exit(debug::EXIT_SUCCESS);
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
}

14
examples/pool.rs
View file

@ -24,16 +24,20 @@ mod app {
// Import the memory pool into scope
use super::P;
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
static mut MEMORY: [u8; 512] = [0; 512];
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init(local = [memory: [u8; 512] = [0; 512]])]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
// Increase the capacity of the memory pool by ~4
P::grow(MEMORY);
P::grow(cx.local.memory);
rtic::pend(Interrupt::I2C0);
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[task(binds = I2C0, priority = 2)]

10
examples/preempt.rs
View file

@ -11,11 +11,17 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::GPIOA);
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[task(binds = GPIOA, priority = 1)]

10
examples/ramfunc.rs
View file

@ -18,11 +18,17 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn().unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[inline(never)]

26
examples/resource-user-struct.rs
View file

@ -12,26 +12,28 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[resources]
struct Resources {
#[shared]
struct Shared {
// A resource
#[init(0)]
shared: u32,
}
// Should not collide with the struct above
#[allow(dead_code)]
struct Resources2 {
struct Shared2 {
// A resource
shared: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::UART0);
rtic::pend(Interrupt::UART1);
(init::LateResources {}, init::Monotonics())
(Shared { shared: 0 }, Local {}, init::Monotonics())
}
// `shared` cannot be accessed from this context
@ -39,16 +41,16 @@ mod app {
fn idle(_cx: idle::Context) -> ! {
debug::exit(debug::EXIT_SUCCESS);
// error: no `resources` field in `idle::Context`
// _cx.resources.shared += 1;
// error: no `shared` field in `idle::Context`
// _cx.shared.shared += 1;
loop {}
}
// `shared` can be accessed from this context
#[task(binds = UART0, resources = [shared])]
#[task(binds = UART0, shared = [shared])]
fn uart0(mut cx: uart0::Context) {
let shared = cx.resources.shared.lock(|shared| {
let shared = cx.shared.shared.lock(|shared| {
*shared += 1;
*shared
});
@ -57,9 +59,9 @@ mod app {
}
// `shared` can be accessed from this context
#[task(binds = UART1, resources = [shared])]
#[task(binds = UART1, shared = [shared])]
fn uart1(mut cx: uart1::Context) {
let shared = cx.resources.shared.lock(|shared| {
let shared = cx.shared.shared.lock(|shared| {
*shared += 1;
*shared
});

25
examples/resource.rs
View file

@ -12,19 +12,20 @@ mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[resources]
struct Resources {
// A resource
#[init(0)]
#[shared]
struct Shared {
shared: u32,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(Interrupt::UART0);
rtic::pend(Interrupt::UART1);
(init::LateResources {}, init::Monotonics())
(Shared { shared: 0 }, Local {}, init::Monotonics())
}
// `shared` cannot be accessed from this context
@ -32,8 +33,8 @@ mod app {
fn idle(_cx: idle::Context) -> ! {
debug::exit(debug::EXIT_SUCCESS);
// error: no `resources` field in `idle::Context`
// _cx.resources.shared += 1;
// error: no `shared` field in `idle::Context`
// _cx.shared.shared += 1;
loop {
cortex_m::asm::nop();
@ -42,9 +43,9 @@ mod app {
// `shared` can be accessed from this context
// defaults to priority 1
#[task(binds = UART0, resources = [shared])]
#[task(binds = UART0, shared = [shared])]
fn uart0(mut cx: uart0::Context) {
let shared = cx.resources.shared.lock(|shared| {
let shared = cx.shared.shared.lock(|shared| {
*shared += 1;
*shared
});
@ -54,9 +55,9 @@ mod app {
// `shared` can be accessed from this context
// explicitly set to priority 2
#[task(binds = UART1, resources = [shared], priority = 2)]
#[task(binds = UART1, shared = [shared], priority = 2)]
fn uart1(mut cx: uart1::Context) {
let shared = cx.resources.shared.lock(|shared| {
let shared = cx.shared.shared.lock(|shared| {
*shared += 1;
*shared
});

12
examples/schedule.rs
View file

@ -19,8 +19,14 @@ mod app {
#[monotonic(binds = SysTick, default = true)]
type MyMono = DwtSystick<MONO_HZ>;
#[init()]
fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
let mut dcb = cx.core.DCB;
let dwt = cx.core.DWT;
let systick = cx.core.SYST;
@ -35,7 +41,7 @@ mod app {
// Schedule `bar` to run 2 seconds in the future
bar::spawn_after(Seconds(2_u32)).ok();
(init::LateResources {}, init::Monotonics(mono))
(Shared {}, Local {}, init::Monotonics(mono))
}
#[task]

26
examples/late.rs → examples/shared.rs
View file

@ -17,27 +17,27 @@ mod app {
};
use lm3s6965::Interrupt;
// Late resources
#[resources]
struct Resources {
#[shared]
struct Shared {
p: Producer<'static, u32, U4>,
c: Consumer<'static, u32, U4>,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
static mut Q: Queue<u32, U4> = Queue(i::Queue::new());
#[local]
struct Local {}
let (p, c) = Q.split();
#[init(local = [q: Queue<u32, U4> = Queue(i::Queue::new())])]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
let (p, c) = cx.local.q.split();
// Initialization of late resources
(init::LateResources { p, c }, init::Monotonics())
// Initialization of shared resources
(Shared { p, c }, Local {}, init::Monotonics())
}
#[idle(resources = [c])]
#[idle(shared = [c])]
fn idle(mut c: idle::Context) -> ! {
loop {
if let Some(byte) = c.resources.c.lock(|c| c.dequeue()) {
if let Some(byte) = c.shared.c.lock(|c| c.dequeue()) {
hprintln!("received message: {}", byte).unwrap();
debug::exit(debug::EXIT_SUCCESS);
@ -47,8 +47,8 @@ mod app {
}
}
#[task(binds = UART0, resources = [p])]
#[task(binds = UART0, shared = [p])]
fn uart0(mut c: uart0::Context) {
c.resources.p.lock(|p| p.enqueue(42).unwrap());
c.shared.p.lock(|p| p.enqueue(42).unwrap());
}
}

13
examples/smallest.rs
View file

@ -7,4 +7,15 @@ use panic_semihosting as _; // panic handler
use rtic::app;
#[app(device = lm3s6965)]
mod app {}
mod app {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
(Shared {}, Local {}, init::Monotonics {})
}
}

10
examples/spawn.rs
View file

@ -11,11 +11,17 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_c: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn(1, 2).unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics {})
}
#[task()]

10
examples/spawn2.rs
View file

@ -11,11 +11,17 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_c: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn(1, 2).unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics {})
}
#[task]

28
examples/static.rs
View file

@ -18,27 +18,26 @@ mod app {
};
use lm3s6965::Interrupt;
// Late resources
#[resources]
struct Resources {
#[shared]
struct Shared {
p: Producer<'static, u32, U4>,
c: Consumer<'static, u32, U4>,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
static mut Q: Queue<u32, U4> = Queue(i::Queue::new());
#[local]
struct Local {}
let (p, c) = Q.split();
#[init(local = [q: Queue<u32, U4> = Queue(i::Queue::new())])]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
let (p, c) = cx.local.q.split();
// Initialization of late resources
(init::LateResources { p, c }, init::Monotonics())
(Shared { p, c }, Local {}, init::Monotonics())
}
#[idle(resources = [c])]
#[idle(shared = [c])]
fn idle(mut c: idle::Context) -> ! {
loop {
if let Some(byte) = c.resources.c.lock(|c| c.dequeue()) {
if let Some(byte) = c.shared.c.lock(|c| c.dequeue()) {
hprintln!("received message: {}", byte).unwrap();
debug::exit(debug::EXIT_SUCCESS);
@ -48,10 +47,9 @@ mod app {
}
}
#[task(binds = UART0, resources = [p])]
#[task(binds = UART0, shared = [p], local = [kalle: u32 = 0])]
fn uart0(mut c: uart0::Context) {
static mut KALLE: u32 = 0;
*KALLE += 1;
c.resources.p.lock(|p| p.enqueue(42).unwrap());
*c.local.kalle += 1;
c.shared.p.lock(|p| p.enqueue(42).unwrap());
}
}

10
examples/t-binds.rs
View file

@ -9,9 +9,15 @@ use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
(init::LateResources {}, init::Monotonics())
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
(Shared {}, Local {}, init::Monotonics())
}
// Cortex-M exception

19
examples/t-cfg-resources.rs
View file

@ -7,25 +7,24 @@ use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
#[resources]
struct Resources {
// A resource
#[init(0)]
shared: u32,
#[shared]
struct Shared {
// A conditionally compiled resource behind feature_x
#[cfg(feature = "feature_x")]
x: u32,
dummy: (), // dummy such that we have at least one late resource
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
(
init::LateResources {
// The feature needs to be applied everywhere x is defined or used
Shared {
#[cfg(feature = "feature_x")]
x: 0,
dummy: (), // dummy such that we have at least one late resource
},
Local {},
init::Monotonics(),
)
}

50
examples/t-cfg.rs
View file

@ -1,50 +0,0 @@
//! [compile-pass] check that `#[cfg]` attributes are respected
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [SSI0, QEI0])]
mod app {
#[resources]
struct Resources {
#[cfg(never)]
#[init(0)]
foo: u32,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
#[cfg(never)]
static mut BAR: u32 = 0;
(init::LateResources {}, init::Monotonics())
}
#[idle]
fn idle(_: idle::Context) -> ! {
#[cfg(never)]
static mut BAR: u32 = 0;
loop {
cortex_m::asm::nop();
}
}
#[task(resources = [foo])]
fn foo(_: foo::Context) {
#[cfg(never)]
static mut BAR: u32 = 0;
}
#[task(priority = 3, resources = [foo])]
fn bar(_: bar::Context) {
#[cfg(never)]
static mut BAR: u32 = 0;
}
#[cfg(never)]
#[task]
fn quux(_: quux::Context) {}
}

10
examples/t-htask-main.rs
View file

@ -9,11 +9,17 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::debug;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
rtic::pend(lm3s6965::Interrupt::UART0);
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[task(binds = UART0)]

10
examples/t-idle-main.rs
View file

@ -9,9 +9,15 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::debug;
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
(init::LateResources {}, init::Monotonics())
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
(Shared {}, Local {}, init::Monotonics())
}
#[idle]

18
examples/t-init-main.rs
View file

@ -1,18 +0,0 @@
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
use cortex_m_semihosting::debug;
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
debug::exit(debug::EXIT_SUCCESS);
(init::LateResources {}, init::Monotonics())
}
}

18
examples/t-late-not-send.rs
View file

@ -1,4 +1,4 @@
//! [compile-pass] late resources don't need to be `Send` if they are owned by `idle`
//! [compile-pass] shared resources don't need to be `Send` if they are owned by `idle`
#![no_main]
#![no_std]
@ -16,24 +16,28 @@ mod app {
use super::NotSend;
use core::marker::PhantomData;
#[resources]
struct Resources {
#[shared]
struct Shared {
x: NotSend,
#[init(None)]
y: Option<NotSend>,
}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
(
init::LateResources {
Shared {
x: NotSend { _0: PhantomData },
y: None,
},
Local {},
init::Monotonics(),
)
}
#[idle(resources = [x, y])]
#[idle(shared = [x, y])]
fn idle(_: idle::Context) -> ! {
loop {
cortex_m::asm::nop();

81
examples/t-resource.rs
View file

@ -1,81 +0,0 @@
//! [compile-pass] Check code generation of resources
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
#[resources]
struct Resources {
#[init(0)]
o1: u32, // init
#[init(0)]
o2: u32, // idle
#[init(0)]
o3: u32, // EXTI0
#[init(0)]
o4: u32, // idle
#[init(0)]
o5: u32, // EXTI1
#[init(0)]
o6: u32, // init
#[init(0)]
s1: u32, // idle & uart0
#[init(0)]
s2: u32, // uart0 & uart1
#[init(0)]
s3: u32, // idle & uart0
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
(init::LateResources {}, init::Monotonics())
}
#[idle(resources = [o2, &o4, s1, &s3])]
fn idle(mut c: idle::Context) -> ! {
// owned by `idle` == `&'static mut`
let _: resources::o2 = c.resources.o2;
// owned by `idle` == `&'static` if read-only
let _: &u32 = c.resources.o4;
// shared with `idle` == `Mutex`
c.resources.s1.lock(|_| {});
// `&` if read-only
let _: &u32 = c.resources.s3;
loop {
cortex_m::asm::nop();
}
}
#[task(binds = UART0, resources = [o3, s1, s2, &s3])]
fn uart0(c: uart0::Context) {
// owned by interrupt == `&mut`
let _: resources::o3 = c.resources.o3;
// no `Mutex` proxy when access from highest priority task
let _: resources::s1 = c.resources.s1;
// no `Mutex` proxy when co-owned by cooperative (same priority) tasks
let _: resources::s2 = c.resources.s2;
// `&` if read-only
let _: &u32 = c.resources.s3;
}
#[task(binds = UART1, resources = [s2, &o5])]
fn uart1(c: uart1::Context) {
// owned by interrupt == `&` if read-only
let _: &u32 = c.resources.o5;
// no `Mutex` proxy when co-owned by cooperative (same priority) tasks
let _: resources::s2 = c.resources.s2;
}
}

21
examples/t-schedule-core-stable.rs
View file

@ -1,21 +0,0 @@
//! [compile-pass] Check `schedule` code generation
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
mod app {
#[init]
fn init(c: init::Context) -> (init::LateResources, init::Monotonics) {
let _c: cortex_m::Peripherals = c.core;
(init::LateResources {}, init::Monotonics())
}
#[task]
fn some_task(_: some_task::Context) {}
}

10
examples/t-schedule.rs
View file

@ -15,8 +15,14 @@ mod app {
#[monotonic(binds = SysTick, default = true)]
type MyMono = DwtSystick<8_000_000>; // 8 MHz
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
let mut dcb = cx.core.DCB;
let dwt = cx.core.DWT;
let systick = cx.core.SYST;
@ -114,7 +120,7 @@ mod app {
let handle: Result<baz::SpawnHandle, (u32, u32)> = baz::spawn_after(Seconds(1_u32), 0, 1);
let _: Result<(u32, u32), ()> = handle.unwrap().cancel();
(init::LateResources {}, init::Monotonics(mono))
(Shared {}, Local {}, init::Monotonics(mono))
}
#[idle]

10
examples/t-spawn.rs
View file

@ -9,13 +9,19 @@ use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
mod app {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
let _: Result<(), ()> = foo::spawn();
let _: Result<(), u32> = bar::spawn(0);
let _: Result<(), (u32, u32)> = baz::spawn(0, 1);
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[idle]

23
examples/t-stask-main.rs
View file

@ -1,23 +0,0 @@
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
mod app {
use cortex_m_semihosting::debug;
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
taskmain::spawn().ok();
(init::LateResources {}, init::Monotonics())
}
#[task]
fn taskmain(_: taskmain::Context) {
debug::exit(debug::EXIT_SUCCESS);
}
}

34
examples/task-local-minimal.rs
View file

@ -1,34 +0,0 @@
//! examples/task-local_minimal.rs
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[resources]
struct Resources {
// A local (move), late resource
#[task_local]
l: u32,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
(init::LateResources { l: 42 }, init::Monotonics())
}
// l is task_local
#[idle(resources =[l])]
fn idle(cx: idle::Context) -> ! {
hprintln!("IDLE:l = {}", cx.resources.l).unwrap();
debug::exit(debug::EXIT_SUCCESS);
loop {
cortex_m::asm::nop();
}
}
}

87
examples/task-local.rs
View file

@ -1,87 +0,0 @@
//! examples/task-local.rs
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
#[resources]
struct Resources {
// An early resource
#[init(0)]
shared: u32,
// A local (move), early resource
#[task_local]
#[init(1)]
l1: u32,
// An exclusive, early resource
#[lock_free]
#[init(1)]
e1: u32,
// A local (move), late resource
#[task_local]
l2: u32,
// An exclusive, late resource
#[lock_free]
e2: u32,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
rtic::pend(Interrupt::UART0);
rtic::pend(Interrupt::UART1);
(init::LateResources { e2: 2, l2: 2 }, init::Monotonics())
}
// `shared` cannot be accessed from this context
// l1 ok (task_local)
// e2 ok (lock_free)
#[idle(resources =[l1, e2])]
fn idle(cx: idle::Context) -> ! {
hprintln!("IDLE:l1 = {}", cx.resources.l1).unwrap();
hprintln!("IDLE:e2 = {}", cx.resources.e2).unwrap();
debug::exit(debug::EXIT_SUCCESS);
loop {
cortex_m::asm::nop();
}
}
// `shared` can be accessed from this context
// l2 ok (task_local)
// e1 ok (lock_free)
#[task(priority = 1, binds = UART0, resources = [shared, l2, e1])]
fn uart0(mut cx: uart0::Context) {
let shared = cx.resources.shared.lock(|shared| {
*shared += 1;
*shared
});
*cx.resources.e1 += 10;
hprintln!("UART0: shared = {}", shared).unwrap();
hprintln!("UART0:l2 = {}", cx.resources.l2).unwrap();
hprintln!("UART0:e1 = {}", cx.resources.e1).unwrap();
}
// `shared` can be accessed from this context
// e1 ok (lock_free)
#[task(priority = 1, binds = UART1, resources = [shared, e1])]
fn uart1(mut cx: uart1::Context) {
let shared = cx.resources.shared.lock(|shared| {
*shared += 1;
*shared
});
hprintln!("UART1: shared = {}", shared).unwrap();
hprintln!("UART1:e1 = {}", cx.resources.e1).unwrap();
}
}

10
examples/task.rs
View file

@ -11,11 +11,17 @@ use panic_semihosting as _;
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
foo::spawn().unwrap();
(init::LateResources {}, init::Monotonics())
(Shared {}, Local {}, init::Monotonics())
}
#[task]

26
examples/task_named_main.rs
View file

@ -1,26 +0,0 @@
//! examples/task_named_main.rs
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
mod app {
use cortex_m_semihosting::{debug, hprintln};
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
main::spawn().unwrap();
(init::LateResources {}, init::Monotonics())
}
#[task]
fn main(_: main::Context) {
hprintln!("This task is named main, useful for rust-analyzer").unwrap();
debug::exit(debug::EXIT_SUCCESS);
}
}

15
examples/type-usage.rs
View file

@ -1,15 +0,0 @@
//! examples/type-usage.rs
#![no_main]
#![no_std]
use panic_semihosting as _; // panic handler
use rtic::app;
#[app(device = lm3s6965, dispatchers = [SSI0])]
mod app {
type Test = u32;
#[task]
fn t1(_: t1::Context, _val: Test) {}
}

57
examples/types.rs
View file

@ -1,57 +0,0 @@
//! examples/types.rs
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, peripherals = true, dispatchers = [SSI0])]
mod app {
use cortex_m_semihosting::debug;
use dwt_systick_monotonic::DwtSystick;
#[monotonic(binds = SysTick, default = true)]
type MyMono = DwtSystick<8_000_000>; // 8 MHz
#[resources]
struct Resources {
#[init(0)]
shared: u32,
}
#[init]
fn init(cx: init::Context) -> (init::LateResources, init::Monotonics) {
let _: cortex_m::Peripherals = cx.core;
let _: lm3s6965::Peripherals = cx.device;
debug::exit(debug::EXIT_SUCCESS);
let mut dcb = cx.core.DCB;
let dwt = cx.core.DWT;
let systick = cx.core.SYST;
let mono = DwtSystick::new(&mut dcb, dwt, systick, 8_000_000);
(init::LateResources {}, init::Monotonics(mono))
}
#[idle]
fn idle(_: idle::Context) -> ! {
loop {
cortex_m::asm::nop();
}
}
#[task(binds = UART0, resources = [shared])]
fn uart0(cx: uart0::Context) {
let _: resources::shared = cx.resources.shared;
}
#[task(priority = 2, resources = [shared])]
fn foo(cx: foo::Context) {
let _: resources::shared = cx.resources.shared;
let _: foo::Resources = cx.resources;
}
}

4
macros/Cargo.toml
View file

@ -12,7 +12,7 @@ license = "MIT OR Apache-2.0"
name = "cortex-m-rtic-macros"
readme = "../README.md"
repository = "https://github.com/rtic-rs/cortex-m-rtic"
version = "0.6.0-alpha.4"
version = "0.6.0-alpha.5"
[lib]
proc-macro = true
@ -22,4 +22,4 @@ proc-macro2 = "1"
proc-macro-error = "1"
quote = "1"
syn = "1"
rtic-syntax = "0.5.0-alpha.3"
rtic-syntax = "0.5.0-alpha.4"

23
macros/src/codegen.rs
View file

@ -9,17 +9,17 @@ mod dispatchers;
mod hardware_tasks;
mod idle;
mod init;
mod locals;
mod local_resources;
mod local_resources_struct;
mod module;
mod post_init;
mod pre_init;
mod resources;
mod resources_struct;
mod shared_resources;
mod shared_resources_struct;
mod software_tasks;
mod timer_queue;
mod util;
// TODO document the syntax here or in `rtic-syntax`
pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
let mut mod_app = vec![];
let mut mains = vec![];
@ -52,7 +52,7 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
mod_app.push(quote!(
#mod_app_init
#mod_app_idle
#(#mod_app_idle)*
));
let main = util::suffixed("main");
@ -83,7 +83,10 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
}
));
let (mod_app_resources, mod_resources) = resources::codegen(app, analysis, extra);
let (mod_app_shared_resources, mod_shared_resources) =
shared_resources::codegen(app, analysis, extra);
let (mod_app_local_resources, mod_local_resources) =
local_resources::codegen(app, analysis, extra);
let (mod_app_hardware_tasks, root_hardware_tasks, user_hardware_tasks) =
hardware_tasks::codegen(app, analysis, extra);
@ -185,7 +188,9 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
#(#root)*
#mod_resources
#mod_shared_resources
#mod_local_resources
#(#root_hardware_tasks)*
@ -194,7 +199,9 @@ pub fn app(app: &App, analysis: &Analysis, extra: &Extra) -> TokenStream2 {
/// app module
#(#mod_app)*
#(#mod_app_resources)*
#(#mod_app_shared_resources)*
#(#mod_app_local_resources)*
#(#mod_app_hardware_tasks)*

7
macros/src/codegen/dispatchers.rs
View file

@ -76,12 +76,6 @@ pub fn codegen(app: &App, analysis: &Analysis, _extra: &Extra) -> Vec<TokenStrea
let inputs = util::mark_internal_ident(&inputs);
let (_, tupled, pats, _) = util::regroup_inputs(&task.inputs);
let locals_new = if task.locals.is_empty() {
quote!()
} else {
quote!(#name::Locals::new(),)
};
quote!(
#(#cfgs)*
#t::#name => {
@ -94,7 +88,6 @@ pub fn codegen(app: &App, analysis: &Analysis, _extra: &Extra) -> Vec<TokenStrea
#fq.get_mut_unchecked().split().0.enqueue_unchecked(index);
let priority = &rtic::export::Priority::new(PRIORITY);
#name(
#locals_new
#name::Context::new(priority)
#(,#pats)*
)

51
macros/src/codegen/hardware_tasks.rs
View file

@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context};
use crate::{
analyze::Analysis,
check::Extra,
codegen::{locals, module, resources_struct},
codegen::{local_resources_struct, module, shared_resources_struct},
};
/// Generate support code for hardware tasks (`#[exception]`s and `#[interrupt]`s)
@ -29,12 +29,6 @@ pub fn codegen(
let mut user_tasks = vec![];
for (name, task) in &app.hardware_tasks {
let locals_new = if task.locals.is_empty() {
quote!()
} else {
quote!(#name::Locals::new(),)
};
let symbol = task.args.binds.clone();
let priority = task.args.priority;
let cfgs = &task.cfgs;
@ -50,19 +44,35 @@ pub fn codegen(
rtic::export::run(PRIORITY, || {
#name(
#locals_new
#name::Context::new(&rtic::export::Priority::new(PRIORITY))
)
});
}
));
let mut needs_lt = false;
let mut shared_needs_lt = false;
let mut local_needs_lt = false;
// `${task}Locals`
if !task.args.local_resources.is_empty() {
let (item, constructor) = local_resources_struct::codegen(
Context::HardwareTask(name),
&mut local_needs_lt,
app,
);
root.push(item);
mod_app.push(constructor);
}
// `${task}Resources`
if !task.args.resources.is_empty() {
let (item, constructor) =
resources_struct::codegen(Context::HardwareTask(name), &mut needs_lt, app);
if !task.args.shared_resources.is_empty() {
let (item, constructor) = shared_resources_struct::codegen(
Context::HardwareTask(name),
&mut shared_needs_lt,
app,
);
root.push(item);
@ -71,30 +81,21 @@ pub fn codegen(
root.push(module::codegen(
Context::HardwareTask(name),
needs_lt,
shared_needs_lt,
local_needs_lt,
app,
analysis,
extra,
));
// `${task}Locals`
let mut locals_pat = None;
if !task.locals.is_empty() {
let (struct_, pat) = locals::codegen(Context::HardwareTask(name), &task.locals, app);
root.push(struct_);
locals_pat = Some(pat);
}
if !&task.is_extern {
if !task.is_extern {
let attrs = &task.attrs;
let context = &task.context;
let stmts = &task.stmts;
let locals_pat = locals_pat.iter();
user_tasks.push(quote!(
#(#attrs)*
#[allow(non_snake_case)]
fn #name(#(#locals_pat,)* #context: #name::Context) {
fn #name(#context: #name::Context) {
use rtic::Mutex as _;
use rtic::mutex_prelude::*;

42
macros/src/codegen/idle.rs
View file

@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context};
use crate::{
analyze::Analysis,
check::Extra,
codegen::{locals, module, resources_struct},
codegen::{local_resources_struct, module, shared_resources_struct},
};
/// Generates support code for `#[idle]` functions
@ -15,7 +15,7 @@ pub fn codegen(
extra: &Extra,
) -> (
// mod_app_idle -- the `${idle}Resources` constructor
Option<TokenStream2>,
Vec<TokenStream2>,
// root_idle -- items that must be placed in the root of the crate:
// - the `${idle}Locals` struct
// - the `${idle}Resources` struct
@ -26,34 +26,35 @@ pub fn codegen(
// call_idle
TokenStream2,
) {
if !app.idles.is_empty() {
let idle = &app.idles.first().unwrap();
let mut needs_lt = false;
let mut mod_app = None;
if let Some(idle) = &app.idle {
let mut shared_needs_lt = false;
let mut local_needs_lt = false;
let mut mod_app = vec![];
let mut root_idle = vec![];
let mut locals_pat = None;
let mut locals_new = None;
let name = &idle.name;
if !idle.args.resources.is_empty() {
let (item, constructor) = resources_struct::codegen(Context::Idle, &mut needs_lt, app);
if !idle.args.shared_resources.is_empty() {
let (item, constructor) =
shared_resources_struct::codegen(Context::Idle, &mut shared_needs_lt, app);
root_idle.push(item);
mod_app = Some(constructor);
mod_app.push(constructor);
}
if !idle.locals.is_empty() {
let (locals, pat) = locals::codegen(Context::Idle, &idle.locals, app);
if !idle.args.local_resources.is_empty() {
let (item, constructor) =
local_resources_struct::codegen(Context::Idle, &mut local_needs_lt, app);
locals_new = Some(quote!(#name::Locals::new()));
locals_pat = Some(pat);
root_idle.push(locals);
root_idle.push(item);
mod_app.push(constructor);
}
root_idle.push(module::codegen(
Context::Idle,
needs_lt,
shared_needs_lt,
local_needs_lt,
app,
analysis,
extra,
@ -62,11 +63,10 @@ pub fn codegen(
let attrs = &idle.attrs;
let context = &idle.context;
let stmts = &idle.stmts;
let locals_pat = locals_pat.iter();
let user_idle = Some(quote!(
#(#attrs)*
#[allow(non_snake_case)]
fn #name(#(#locals_pat,)* #context: #name::Context) -> ! {
fn #name(#context: #name::Context) -> ! {
use rtic::Mutex as _;
use rtic::mutex_prelude::*;
@ -74,16 +74,14 @@ pub fn codegen(
}
));
let locals_new = locals_new.iter();
let call_idle = quote!(#name(
#(#locals_new,)*
#name::Context::new(&rtic::export::Priority::new(0))
));
(mod_app, root_idle, user_idle, call_idle)
} else {
(
None,
vec![],
vec![],
None,
quote!(loop {

130
macros/src/codegen/init.rs
View file

@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context};
use crate::{
analyze::Analysis,
check::Extra,
codegen::{locals, module, resources_struct},
codegen::{local_resources_struct, module},
};
type CodegenResult = (
@ -18,68 +18,96 @@ type CodegenResult = (
// - the `${init}` module, which contains types like `${init}::Context`
Vec<TokenStream2>,
// user_init -- the `#[init]` function written by the user
Option<TokenStream2>,
// call_init -- the call to the user `#[init]` if there's one
Option<TokenStream2>,
TokenStream2,
// call_init -- the call to the user `#[init]`
TokenStream2,
);
/// Generates support code for `#[init]` functions
pub fn codegen(app: &App, analysis: &Analysis, extra: &Extra) -> CodegenResult {
if !app.inits.is_empty() {
let init = &app.inits.first().unwrap();
let mut needs_lt = false;
let name = &init.name;
let init = &app.init;
let mut local_needs_lt = false;
let name = &init.name;
let mut root_init = vec![];
let mut root_init = vec![];
let mut locals_pat = None;
let mut locals_new = None;
if !init.locals.is_empty() {
let (struct_, pat) = locals::codegen(Context::Init, &init.locals, app);
let context = &init.context;
let attrs = &init.attrs;
let stmts = &init.stmts;
let shared = &init.user_shared_struct;
let local = &init.user_local_struct;
locals_new = Some(quote!(#name::Locals::new()));
locals_pat = Some(pat);
root_init.push(struct_);
let shared_resources: Vec<_> = app
.shared_resources
.iter()
.map(|(k, v)| {
let ty = &v.ty;
let cfgs = &v.cfgs;
quote!(
#(#cfgs)*
#k: #ty,
)
})
.collect();
let local_resources: Vec<_> = app
.local_resources
.iter()
.map(|(k, v)| {
let ty = &v.ty;
let cfgs = &v.cfgs;
quote!(
#(#cfgs)*
#k: #ty,
)
})
.collect();
root_init.push(quote! {
struct #shared {
#(#shared_resources)*
}
let context = &init.context;
let attrs = &init.attrs;
let stmts = &init.stmts;
let locals_pat = locals_pat.iter();
let user_init_return = quote! {#name::LateResources, #name::Monotonics};
let user_init = Some(quote!(
#(#attrs)*
#[allow(non_snake_case)]
fn #name(#(#locals_pat,)* #context: #name::Context) -> (#user_init_return) {
#(#stmts)*
}
));
let mut mod_app = None;
if !init.args.resources.is_empty() {
let (item, constructor) = resources_struct::codegen(Context::Init, &mut needs_lt, app);
root_init.push(item);
mod_app = Some(constructor);
struct #local {
#(#local_resources)*
}
});
let locals_new = locals_new.iter();
let call_init = Some(
quote!(let (late, mut monotonics) = #name(#(#locals_new,)* #name::Context::new(core.into()));),
);
// let locals_pat = locals_pat.iter();
root_init.push(module::codegen(
Context::Init,
needs_lt,
app,
analysis,
extra,
));
let user_init_return = quote! {#shared, #local, #name::Monotonics};
(mod_app, root_init, user_init, call_init)
} else {
(None, vec![], None, None)
let user_init = quote!(
#(#attrs)*
#[allow(non_snake_case)]
fn #name(#context: #name::Context) -> (#user_init_return) {
#(#stmts)*
}
);
let mut mod_app = None;
// `${task}Locals`
if !init.args.local_resources.is_empty() {
let (item, constructor) =
local_resources_struct::codegen(Context::Init, &mut local_needs_lt, app);
root_init.push(item);
mod_app = Some(constructor);
}
// let locals_new = locals_new.iter();
let call_init = quote! {
let (shared_resources, local_resources, mut monotonics) = #name(#name::Context::new(core.into()));
};
root_init.push(module::codegen(
Context::Init,
false,
local_needs_lt,
app,
analysis,
extra,
));
(mod_app, root_init, user_init, call_init)
}

71
macros/src/codegen/local_resources.rs Normal file
View file

@ -0,0 +1,71 @@
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use rtic_syntax::ast::App;
use crate::{analyze::Analysis, check::Extra, codegen::util};
/// Generates `local` variables and local resource proxies
///
/// I.e. the `static` variables and theirs proxies.
pub fn codegen(
app: &App,
_analysis: &Analysis,
_extra: &Extra,
) -> (
// mod_app -- the `static` variables behind the proxies
Vec<TokenStream2>,
// mod_resources -- the `resources` module
TokenStream2,
) {
let mut mod_app = vec![];
// let mut mod_resources: _ = vec![];
// All local resources declared in the `#[local]' struct
for (name, res) in &app.local_resources {
let cfgs = &res.cfgs;
let ty = &res.ty;
let mangled_name = util::mark_internal_ident(&util::static_local_resource_ident(name));
let attrs = &res.attrs;
// late resources in `util::link_section_uninit`
let section = util::link_section_uninit();
// For future use
// let doc = format!(" RTIC internal: {}:{}", file!(), line!());
mod_app.push(quote!(
#[allow(non_upper_case_globals)]
// #[doc = #doc]
#[doc(hidden)]
#(#attrs)*
#(#cfgs)*
#section
static #mangled_name: rtic::RacyCell<core::mem::MaybeUninit<#ty>> = rtic::RacyCell::new(core::mem::MaybeUninit::uninit());
));
}
// All declared `local = [NAME: TY = EXPR]` local resources
for (task_name, resource_name, task_local) in app.declared_local_resources() {
let cfgs = &task_local.cfgs;
let ty = &task_local.ty;
let expr = &task_local.expr;
let attrs = &task_local.attrs;
let mangled_name = util::mark_internal_ident(&util::declared_static_local_resource_ident(
resource_name,
&task_name,
));
// For future use
// let doc = format!(" RTIC internal: {}:{}", file!(), line!());
mod_app.push(quote!(
#[allow(non_upper_case_globals)]
// #[doc = #doc]
#[doc(hidden)]
#(#attrs)*
#(#cfgs)*
static #mangled_name: rtic::RacyCell<#ty> = rtic::RacyCell::new(#expr);
));
}
(mod_app, TokenStream2::new())
}

110
macros/src/codegen/local_resources_struct.rs Normal file
View file

@ -0,0 +1,110 @@
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use rtic_syntax::{
ast::{App, TaskLocal},
Context,
};
use crate::codegen::util;
/// Generates local resources structs
pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, TokenStream2) {
let mut lt = None;
let resources = match ctxt {
Context::Init => &app.init.args.local_resources,
Context::Idle => &app.idle.as_ref().unwrap().args.local_resources,
Context::HardwareTask(name) => &app.hardware_tasks[name].args.local_resources,
Context::SoftwareTask(name) => &app.software_tasks[name].args.local_resources,
};
let task_name = util::get_task_name(ctxt, app);
let mut fields = vec![];
let mut values = vec![];
let mut has_cfgs = false;
for (name, task_local) in resources {
let (cfgs, ty, is_declared) = match task_local {
TaskLocal::External => {
let r = app.local_resources.get(name).expect("UNREACHABLE");
(&r.cfgs, &r.ty, false)
}
TaskLocal::Declared(r) => (&r.cfgs, &r.ty, true),
_ => unreachable!(),
};
has_cfgs |= !cfgs.is_empty();
let lt = if ctxt.runs_once() {
quote!('static)
} else {
lt = Some(quote!('a));
quote!('a)
};
let mangled_name = if matches!(task_local, TaskLocal::External) {
util::mark_internal_ident(&util::static_local_resource_ident(name))
} else {
util::mark_internal_ident(&util::declared_static_local_resource_ident(
name, &task_name,
))
};
fields.push(quote!(
#(#cfgs)*
pub #name: &#lt mut #ty
));
let expr = if is_declared {
// If the local resources is already initialized, we only need to access its value and
// not go through an `MaybeUninit`
quote!(#mangled_name.get_mut_unchecked())
} else {
quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr())
};
values.push(quote!(
#(#cfgs)*
#name: #expr
));
}
if lt.is_some() {
*needs_lt = true;
// The struct could end up empty due to `cfg`s leading to an error due to `'a` being unused
if has_cfgs {
fields.push(quote!(
#[doc(hidden)]
pub __marker__: core::marker::PhantomData<&'a ()>
));
values.push(quote!(__marker__: core::marker::PhantomData))
}
}
let doc = format!("Local resources `{}` has access to", ctxt.ident(app));
let ident = util::local_resources_ident(ctxt, app);
let ident = util::mark_internal_ident(&ident);
let item = quote!(
#[allow(non_snake_case)]
#[doc = #doc]
pub struct #ident<#lt> {
#(#fields,)*
}
);
let constructor = quote!(
impl<#lt> #ident<#lt> {
#[inline(always)]
pub unsafe fn new() -> Self {
#ident {
#(#values,)*
}
}
}
);
(item, constructor)
}

95
macros/src/codegen/locals.rs
View file

@ -1,95 +0,0 @@
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use rtic_syntax::{
ast::{App, Local},
Context, Map,
};
use crate::codegen::util;
pub fn codegen(
ctxt: Context,
locals: &Map<Local>,
app: &App,
) -> (
// locals
TokenStream2,
// pat
TokenStream2,
) {
assert!(!locals.is_empty());
let runs_once = ctxt.runs_once();
let ident = util::locals_ident(ctxt, app);
let mut lt = None;
let mut fields = vec![];
let mut items = vec![];
let mut names = vec![];
let mut values = vec![];
let mut pats = vec![];
let mut has_cfgs = false;
for (name, local) in locals {
let lt = if runs_once {
quote!('static)
} else {
lt = Some(quote!('a));
quote!('a)
};
let cfgs = &local.cfgs;
has_cfgs |= !cfgs.is_empty();
let expr = &local.expr;
let ty = &local.ty;
fields.push(quote!(
#(#cfgs)*
#name: &#lt mut #ty
));
items.push(quote!(
#(#cfgs)*
#[doc(hidden)]
static #name: rtic::RacyCell<#ty> = rtic::RacyCell::new(#expr)
));
values.push(quote!(
#(#cfgs)*
#name: #name.get_mut_unchecked()
));
names.push(name);
pats.push(quote!(
#(#cfgs)*
#name
));
}
if lt.is_some() && has_cfgs {
fields.push(quote!(__marker__: core::marker::PhantomData<&'a ()>));
values.push(quote!(__marker__: core::marker::PhantomData));
}
let locals = quote!(
#[allow(non_snake_case)]
#[doc(hidden)]
pub struct #ident<#lt> {
#(#fields),*
}
impl<#lt> #ident<#lt> {
#[inline(always)]
unsafe fn new() -> Self {
#(#items;)*
#ident {
#(#values),*
}
}
}
);
let ident = ctxt.ident(app);
(
locals,
quote!(#ident::Locals { #(#pats,)* .. }: #ident::Locals),
)
}

85
macros/src/codegen/module.rs
View file

@ -5,7 +5,8 @@ use rtic_syntax::{ast::App, Context};
pub fn codegen(
ctxt: Context,
resources_tick: bool,
shared_resources_tick: bool,
local_resources_tick: bool,
app: &App,
analysis: &Analysis,
extra: &Extra,
@ -56,18 +57,18 @@ pub fn codegen(
Context::SoftwareTask(_) => {}
}
if ctxt.has_locals(app) {
let ident = util::locals_ident(ctxt, app);
module_items.push(quote!(
#[doc(inline)]
pub use super::#ident as Locals;
));
}
// if ctxt.has_locals(app) {
// let ident = util::locals_ident(ctxt, app);
// module_items.push(quote!(
// #[doc(inline)]
// pub use super::#ident as Locals;
// ));
// }
if ctxt.has_resources(app) {
let ident = util::resources_ident(ctxt, app);
if ctxt.has_local_resources(app) {
let ident = util::local_resources_ident(ctxt, app);
let ident = util::mark_internal_ident(&ident);
let lt = if resources_tick {
let lt = if local_resources_tick {
lt = Some(quote!('a));
Some(quote!('a))
} else {
@ -76,12 +77,35 @@ pub fn codegen(
module_items.push(quote!(
#[doc(inline)]
pub use super::#ident as Resources;
pub use super::#ident as LocalResources;
));
fields.push(quote!(
/// Resources this task has access to
pub resources: #name::Resources<#lt>
/// Local Resources this task has access to
pub local: #name::LocalResources<#lt>
));
values.push(quote!(local: #name::LocalResources::new()));
}
if ctxt.has_shared_resources(app) {
let ident = util::shared_resources_ident(ctxt, app);
let ident = util::mark_internal_ident(&ident);
let lt = if shared_resources_tick {
lt = Some(quote!('a));
Some(quote!('a))
} else {
None
};
module_items.push(quote!(
#[doc(inline)]
pub use super::#ident as SharedResources;
));
fields.push(quote!(
/// Shared Resources this task has access to
pub shared: #name::SharedResources<#lt>
));
let priority = if ctxt.is_init() {
@ -89,38 +113,10 @@ pub fn codegen(
} else {
Some(quote!(priority))
};
values.push(quote!(resources: #name::Resources::new(#priority)));
values.push(quote!(shared: #name::SharedResources::new(#priority)));
}
if let Context::Init = ctxt {
let late_fields = analysis
.late_resources
.iter()
.flat_map(|resources| {
resources.iter().map(|name| {
let ty = &app.late_resources[name].ty;
let cfgs = &app.late_resources[name].cfgs;
quote!(
#(#cfgs)*
pub #name: #ty
)
})
})
.collect::<Vec<_>>();
let internal_late_ident = util::mark_internal_name("LateResources");
items.push(quote!(
/// Resources initialized at runtime
#[allow(non_snake_case)]
pub struct #internal_late_ident {
#(#late_fields),*
}
));
module_items.push(quote!(
pub use super::#internal_late_ident as LateResources;
));
let monotonic_types: Vec<_> = app
.monotonics
.iter()
@ -202,9 +198,6 @@ pub fn codegen(
pub use super::#internal_context_name as Context;
));
// not sure if this is the right way, maybe its backwards,
// that spawn_module should put in in root
if let Context::SoftwareTask(..) = ctxt {
let spawnee = &app.software_tasks[name];
let priority = spawnee.args.priority;

51
macros/src/codegen/post_init.rs
View file

@ -9,24 +9,39 @@ use crate::{analyze::Analysis, codegen::util};
pub fn codegen(app: &App, analysis: &Analysis) -> Vec<TokenStream2> {
let mut stmts = vec![];
// Initialize late resources
if !analysis.late_resources.is_empty() {
// BTreeSet wrapped in a vector
for name in analysis.late_resources.first().unwrap() {
let mangled_name = util::mark_internal_ident(&name);
// If it's live
let cfgs = app.late_resources[name].cfgs.clone();
if analysis.locations.get(name).is_some() {
stmts.push(quote!(
// We include the cfgs
#(#cfgs)*
// Late resource is a RacyCell<MaybeUninit<T>>
// - `get_mut_unchecked` to obtain `MaybeUninit<T>`
// - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>`
// - `write` the defined value for the late resource T
#mangled_name.get_mut_unchecked().as_mut_ptr().write(late.#name);
));
}
// Initialize shared resources
for (name, res) in &app.shared_resources {
let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(name));
// If it's live
let cfgs = res.cfgs.clone();
if analysis.shared_resource_locations.get(name).is_some() {
stmts.push(quote!(
// We include the cfgs
#(#cfgs)*
// Resource is a RacyCell<MaybeUninit<T>>
// - `get_mut_unchecked` to obtain `MaybeUninit<T>`
// - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>`
// - `write` the defined value for the late resource T
#mangled_name.get_mut_unchecked().as_mut_ptr().write(shared_resources.#name);
));
}
}
// Initialize local resources
for (name, res) in &app.local_resources {
let mangled_name = util::mark_internal_ident(&util::static_local_resource_ident(name));
// If it's live
let cfgs = res.cfgs.clone();
if analysis.local_resource_locations.get(name).is_some() {
stmts.push(quote!(
// We include the cfgs
#(#cfgs)*
// Resource is a RacyCell<MaybeUninit<T>>
// - `get_mut_unchecked` to obtain `MaybeUninit<T>`
// - `as_mut_ptr` to obtain a raw pointer to `MaybeUninit<T>`
// - `write` the defined value for the late resource T
#mangled_name.get_mut_unchecked().as_mut_ptr().write(local_resources.#name);
));
}
}

2
macros/src/codegen/pre_init.rs
View file

@ -126,7 +126,7 @@ pub fn codegen(app: &App, analysis: &Analysis, extra: &Extra) -> Vec<TokenStream
}
// If there's no user `#[idle]` then optimize returning from interrupt handlers
if app.idles.is_empty() {
if app.idle.is_none() {
// Set SLEEPONEXIT bit to enter sleep mode when returning from ISR
stmts.push(quote!(core.SCB.scr.modify(|r| r | 1 << 1);));
}

152
macros/src/codegen/resources.rs
View file

@ -1,152 +0,0 @@
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use rtic_syntax::{analyze::Ownership, ast::App};
use crate::{analyze::Analysis, check::Extra, codegen::util};
/// Generates `static` variables and resource proxies
/// Early resources are stored in `RacyCell<T>`
/// Late resource are stored in `RacyCell<MaybeUninit<T>>`
///
/// Safety:
/// - RacyCell<T> access is `unsafe`.
/// - RacyCell<MaybeUninit> is always written to before user access, thus
// the generated code for user access can safely `assume_init`.
pub fn codegen(
app: &App,
analysis: &Analysis,
extra: &Extra,
) -> (
// mod_app -- the `static` variables behind the proxies
Vec<TokenStream2>,
// mod_resources -- the `resources` module
TokenStream2,
) {
let mut mod_app = vec![];
let mut mod_resources = vec![];
for (name, res, expr, _) in app.resources(analysis) {
let cfgs = &res.cfgs;
let ty = &res.ty;
let mangled_name = util::mark_internal_ident(&name);
{
// late resources in `util::link_section_uninit`
let section = if expr.is_none() {
util::link_section_uninit(true)
} else {
None
};
// resource type and assigned value
let (ty, expr) = if let Some(expr) = expr {
// early resource
(
quote!(rtic::RacyCell<#ty>),
quote!(rtic::RacyCell::new(#expr)),
)
} else {
// late resource
(
quote!(rtic::RacyCell<core::mem::MaybeUninit<#ty>>),
quote!(rtic::RacyCell::new(core::mem::MaybeUninit::uninit())),
)
};
let attrs = &res.attrs;
// For future use
// let doc = format!(" RTIC internal: {}:{}", file!(), line!());
mod_app.push(quote!(
#[allow(non_upper_case_globals)]
// #[doc = #doc]
#[doc(hidden)]
#(#attrs)*
#(#cfgs)*
#section
static #mangled_name: #ty = #expr;
));
}
let r_prop = &res.properties;
// For future use
// let doc = format!(" RTIC internal: {}:{}", file!(), line!());
if !r_prop.task_local && !r_prop.lock_free {
mod_resources.push(quote!(
// #[doc = #doc]
#[doc(hidden)]
#[allow(non_camel_case_types)]
#(#cfgs)*
pub struct #name<'a> {
priority: &'a Priority,
}
#(#cfgs)*
impl<'a> #name<'a> {
#[inline(always)]
pub unsafe fn new(priority: &'a Priority) -> Self {
#name { priority }
}
#[inline(always)]
pub unsafe fn priority(&self) -> &Priority {
self.priority
}
}
));
let (ptr, _doc) = if expr.is_none() {
// late resource
(
quote!(
#(#cfgs)*
#mangled_name.get_mut_unchecked().as_mut_ptr()
),
"late",
)
} else {
// early resource
(
quote!(
#(#cfgs)*
#mangled_name.get_mut_unchecked()
),
"early",
)
};
let ceiling = match analysis.ownerships.get(name) {
Some(Ownership::Owned { priority }) => *priority,
Some(Ownership::CoOwned { priority }) => *priority,
Some(Ownership::Contended { ceiling }) => *ceiling,
None => 0,
};
// For future use
// let doc = format!(" RTIC internal ({} resource): {}:{}", doc, file!(), line!());
mod_app.push(util::impl_mutex(
extra,
cfgs,
true,
name,
quote!(#ty),
ceiling,
ptr,
));
}
}
let mod_resources = if mod_resources.is_empty() {
quote!()
} else {
quote!(mod resources {
use rtic::export::Priority;
#(#mod_resources)*
})
};
(mod_app, mod_resources)
}

107
macros/src/codegen/shared_resources.rs Normal file
View file

@ -0,0 +1,107 @@
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use rtic_syntax::{analyze::Ownership, ast::App};
use crate::{analyze::Analysis, check::Extra, codegen::util};
/// Generates `static` variables and shared resource proxies
pub fn codegen(
app: &App,
analysis: &Analysis,
extra: &Extra,
) -> (
// mod_app -- the `static` variables behind the proxies
Vec<TokenStream2>,
// mod_resources -- the `resources` module
TokenStream2,
) {
let mut mod_app = vec![];
let mut mod_resources = vec![];
for (name, res) in &app.shared_resources {
let cfgs = &res.cfgs;
let ty = &res.ty;
let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(&name));
// late resources in `util::link_section_uninit`
let section = util::link_section_uninit();
let attrs = &res.attrs;
// For future use
// let doc = format!(" RTIC internal: {}:{}", file!(), line!());
mod_app.push(quote!(
#[allow(non_upper_case_globals)]
// #[doc = #doc]
#[doc(hidden)]
#(#attrs)*
#(#cfgs)*
#section
static #mangled_name: rtic::RacyCell<core::mem::MaybeUninit<#ty>> = rtic::RacyCell::new(core::mem::MaybeUninit::uninit());
));
// For future use
// let doc = format!(" RTIC internal: {}:{}", file!(), line!());
if !res.properties.lock_free {
mod_resources.push(quote!(
// #[doc = #doc]
#[doc(hidden)]
#[allow(non_camel_case_types)]
#(#cfgs)*
pub struct #name<'a> {
priority: &'a Priority,
}
#(#cfgs)*
impl<'a> #name<'a> {
#[inline(always)]
pub unsafe fn new(priority: &'a Priority) -> Self {
#name { priority }
}
#[inline(always)]
pub unsafe fn priority(&self) -> &Priority {
self.priority
}
}
));
let ptr = quote!(
#(#cfgs)*
#mangled_name.get_mut_unchecked().as_mut_ptr()
);
let ceiling = match analysis.ownerships.get(name) {
Some(Ownership::Owned { priority }) => *priority,
Some(Ownership::CoOwned { priority }) => *priority,
Some(Ownership::Contended { ceiling }) => *ceiling,
None => 0,
};
// For future use
// let doc = format!(" RTIC internal ({} resource): {}:{}", doc, file!(), line!());
mod_app.push(util::impl_mutex(
extra,
cfgs,
true,
&name,
quote!(#ty),
ceiling,
ptr,
));
}
}
let mod_resources = if mod_resources.is_empty() {
quote!()
} else {
quote!(mod shared_resources {
use rtic::export::Priority;
#(#mod_resources)*
})
};
(mod_app, mod_resources)
}

52
macros/src/codegen/resources_struct.rs → macros/src/codegen/shared_resources_struct.rs
View file

@ -4,14 +4,15 @@ use rtic_syntax::{ast::App, Context};
use crate::codegen::util;
/// Generate shared resources structs
pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2, TokenStream2) {
let mut lt = None;
let resources = match ctxt {
Context::Init => &app.inits.first().unwrap().args.resources,
Context::Idle => &app.idles.first().unwrap().args.resources,
Context::HardwareTask(name) => &app.hardware_tasks[name].args.resources,
Context::SoftwareTask(name) => &app.software_tasks[name].args.resources,
Context::Init => unreachable!("Tried to generate shared resources struct for init"),
Context::Idle => &app.idle.as_ref().unwrap().args.shared_resources,
Context::HardwareTask(name) => &app.hardware_tasks[name].args.shared_resources,
Context::SoftwareTask(name) => &app.software_tasks[name].args.shared_resources,
};
let mut fields = vec![];
@ -19,7 +20,7 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
let mut has_cfgs = false;
for (name, access) in resources {
let (res, expr) = app.resource(name).expect("UNREACHABLE");
let res = app.shared_resources.get(name).expect("UNREACHABLE");
let cfgs = &res.cfgs;
has_cfgs |= !cfgs.is_empty();
@ -31,12 +32,9 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
None
};
let ty = &res.ty;
let mangled_name = util::mark_internal_ident(&name);
let mangled_name = util::mark_internal_ident(&util::static_shared_resource_ident(&name));
// let ownership = &analysis.ownerships[name];
let r_prop = &res.properties;
if !r_prop.task_local && !r_prop.lock_free {
if !res.properties.lock_free {
if access.is_shared() {
lt = Some(quote!('a));
@ -50,12 +48,12 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
fields.push(quote!(
#(#cfgs)*
pub #name: resources::#name<'a>
pub #name: shared_resources::#name<'a>
));
values.push(quote!(
#(#cfgs)*
#name: resources::#name::new(priority)
#name: shared_resources::#name::new(priority)
));
@ -76,24 +74,16 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
));
}
let is_late = expr.is_none();
if is_late {
let expr = if access.is_exclusive() {
quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr())
} else {
quote!(&*#mangled_name.get_unchecked().as_ptr())
};
values.push(quote!(
#(#cfgs)*
#name: #expr
));
let expr = if access.is_exclusive() {
quote!(&mut *#mangled_name.get_mut_unchecked().as_mut_ptr())
} else {
values.push(quote!(
#(#cfgs)*
#name: #mangled_name.get_mut_unchecked()
));
}
quote!(&*#mangled_name.get_unchecked().as_ptr())
};
values.push(quote!(
#(#cfgs)*
#name: #expr
));
}
if lt.is_some() {
@ -110,8 +100,8 @@ pub fn codegen(ctxt: Context, needs_lt: &mut bool, app: &App) -> (TokenStream2,
}
}
let doc = format!("Resources `{}` has access to", ctxt.ident(app));
let ident = util::resources_ident(ctxt, app);
let doc = format!("Shared resources `{}` has access to", ctxt.ident(app));
let ident = util::shared_resources_ident(ctxt, app);
let ident = util::mark_internal_ident(&ident);
let item = quote!(
#[allow(non_snake_case)]

39
macros/src/codegen/software_tasks.rs
View file

@ -5,7 +5,7 @@ use rtic_syntax::{ast::App, Context};
use crate::{
analyze::Analysis,
check::Extra,
codegen::{locals, module, resources_struct, util},
codegen::{local_resources_struct, module, shared_resources_struct, util},
};
pub fn codegen(
@ -45,7 +45,7 @@ pub fn codegen(
quote!(rtic::export::Queue(unsafe {
rtic::export::iQueue::u8_sc()
})),
Box::new(|| util::link_section_uninit(true)),
Box::new(|| util::link_section_uninit()),
)
};
mod_app.push(quote!(
@ -90,23 +90,32 @@ pub fn codegen(
));
// `${task}Resources`
let mut needs_lt = false;
if !task.args.resources.is_empty() {
let (item, constructor) =
resources_struct::codegen(Context::SoftwareTask(name), &mut needs_lt, app);
let mut shared_needs_lt = false;
let mut local_needs_lt = false;
// `${task}Locals`
if !task.args.local_resources.is_empty() {
let (item, constructor) = local_resources_struct::codegen(
Context::SoftwareTask(name),
&mut local_needs_lt,
app,
);
root.push(item);
mod_app.push(constructor);
}
// `${task}Locals`
let mut locals_pat = None;
if !task.locals.is_empty() {
let (struct_, pat) = locals::codegen(Context::SoftwareTask(name), &task.locals, app);
if !task.args.shared_resources.is_empty() {
let (item, constructor) = shared_resources_struct::codegen(
Context::SoftwareTask(name),
&mut shared_needs_lt,
app,
);
locals_pat = Some(pat);
root.push(struct_);
root.push(item);
mod_app.push(constructor);
}
if !&task.is_extern {
@ -114,12 +123,11 @@ pub fn codegen(
let attrs = &task.attrs;
let cfgs = &task.cfgs;
let stmts = &task.stmts;
let locals_pat = locals_pat.iter();
user_tasks.push(quote!(
#(#attrs)*
#(#cfgs)*
#[allow(non_snake_case)]
fn #name(#(#locals_pat,)* #context: #name::Context #(,#inputs)*) {
fn #name(#context: #name::Context #(,#inputs)*) {
use rtic::Mutex as _;
use rtic::mutex_prelude::*;
@ -130,7 +138,8 @@ pub fn codegen(
root.push(module::codegen(
Context::SoftwareTask(name),
needs_lt,
shared_needs_lt,
local_needs_lt,
app,
analysis,
extra,

81
macros/src/codegen/util.rs
View file

@ -41,7 +41,7 @@ pub fn impl_mutex(
ptr: TokenStream2,
) -> TokenStream2 {
let (path, priority) = if resources_prefix {
(quote!(resources::#name), quote!(self.priority()))
(quote!(shared_resources::#name), quote!(self.priority()))
} else {
(quote!(#name), quote!(self.priority))
};
@ -152,30 +152,12 @@ fn link_section_index() -> usize {
}
// NOTE `None` means in shared memory
pub fn link_section_uninit(empty_expr: bool) -> Option<TokenStream2> {
let section = if empty_expr {
let index = link_section_index();
format!(".uninit.rtic{}", index)
} else {
format!(".uninit.rtic{}", link_section_index())
};
pub fn link_section_uninit() -> Option<TokenStream2> {
let section = format!(".uninit.rtic{}", link_section_index());
Some(quote!(#[link_section = #section]))
}
/// Generates a pre-reexport identifier for the "locals" struct
pub fn locals_ident(ctxt: Context, app: &App) -> Ident {
let mut s = match ctxt {
Context::Init => app.inits.first().unwrap().name.to_string(),
Context::Idle => app.idles.first().unwrap().name.to_string(),
Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(),
};
s.push_str("Locals");
Ident::new(&s, Span::call_site())
}
// Regroups the inputs of a task
//
// `inputs` could be &[`input: Foo`] OR &[`mut x: i32`, `ref y: i64`]
@ -225,15 +207,39 @@ pub fn regroup_inputs(
}
}
/// Generates a pre-reexport identifier for the "resources" struct
pub fn resources_ident(ctxt: Context, app: &App) -> Ident {
let mut s = match ctxt {
Context::Init => app.inits.first().unwrap().name.to_string(),
Context::Idle => app.idles.first().unwrap().name.to_string(),
/// Get the ident for the name of the task
pub fn get_task_name(ctxt: Context, app: &App) -> Ident {
let s = match ctxt {
Context::Init => app.init.name.to_string(),
Context::Idle => app.idle.as_ref().unwrap().name.to_string(),
Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(),
};
s.push_str("Resources");
Ident::new(&s, Span::call_site())
}
/// Generates a pre-reexport identifier for the "shared resources" struct
pub fn shared_resources_ident(ctxt: Context, app: &App) -> Ident {
let mut s = match ctxt {
Context::Init => app.init.name.to_string(),
Context::Idle => app.idle.as_ref().unwrap().name.to_string(),
Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(),
};
s.push_str("SharedResources");
Ident::new(&s, Span::call_site())
}
/// Generates a pre-reexport identifier for the "local resources" struct
pub fn local_resources_ident(ctxt: Context, app: &App) -> Ident {
let mut s = match ctxt {
Context::Init => app.init.name.to_string(),
Context::Idle => app.idle.as_ref().unwrap().name.to_string(),
Context::HardwareTask(ident) | Context::SoftwareTask(ident) => ident.to_string(),
};
s.push_str("LocalResources");
Ident::new(&s, Span::call_site())
}
@ -275,6 +281,27 @@ pub fn monotonic_ident(name: &str) -> Ident {
Ident::new(&format!("MONOTONIC_STORAGE_{}", name), Span::call_site())
}
pub fn static_shared_resource_ident(name: &Ident) -> Ident {
Ident::new(
&format!("shared_resource_{}", name.to_string()),
Span::call_site(),
)
}
pub fn static_local_resource_ident(name: &Ident) -> Ident {
Ident::new(
&format!("local_resource_{}", name.to_string()),
Span::call_site(),
)
}
pub fn declared_static_local_resource_ident(name: &Ident, task_name: &Ident) -> Ident {
Ident::new(
&format!("local_{}_{}", task_name.to_string(), name.to_string()),
Span::call_site(),
)
}
/// The name to get better RT flag errors
pub fn rt_err_ident() -> Ident {
Ident::new(

11
macros/src/tests/single.rs
View file

@ -10,6 +10,17 @@ fn analyze() {
quote!(device = pac, dispatchers = [B, A]),
quote!(
mod app {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
(Shared {}, Local {}, init::Monotonics {})
}
#[task(priority = 1)]
fn a(_: a::Context) {}

11
ui/exception-invalid.rs
View file

@ -2,6 +2,17 @@
#[rtic::app(device = lm3s6965)]
mod app {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
(Shared {}, Local {}, init::Monotonics {})
}
#[task(binds = NonMaskableInt)]
fn nmi(_: nmi::Context) {}
}

8
ui/exception-invalid.stderr
View file

@ -1,5 +1,5 @@
error: only exceptions with configurable priority can be used as hardware tasks
--> $DIR/exception-invalid.rs:6:8
|
6 | fn nmi(_: nmi::Context) {}
| ^^^
--> $DIR/exception-invalid.rs:17:8
|
17 | fn nmi(_: nmi::Context) {}
| ^^^

11
ui/extern-interrupt-not-enough.rs
View file

@ -2,6 +2,17 @@
#[rtic::app(device = lm3s6965)]
mod app {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
(Shared {}, Local {}, init::Monotonics {})
}
#[task]
fn a(_: a::Context) {}
}

8
ui/extern-interrupt-not-enough.stderr
View file

@ -1,5 +1,5 @@
error: not enough interrupts to dispatch all software tasks (need: 1; given: 0)
--> $DIR/extern-interrupt-not-enough.rs:6:8
|
6 | fn a(_: a::Context) {}
| ^
--> $DIR/extern-interrupt-not-enough.rs:17:8
|
17 | fn a(_: a::Context) {}
| ^

11
ui/extern-interrupt-used.rs
View file

@ -2,6 +2,17 @@
#[rtic::app(device = lm3s6965, dispatchers = [UART0])]
mod app {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
(Shared {}, Local {}, init::Monotonics {})
}
#[task(binds = UART0)]
fn a(_: a::Context) {}
}

8
ui/extern-interrupt-used.stderr
View file

@ -1,5 +1,5 @@
error: dispatcher interrupts can't be used as hardware tasks
--> $DIR/extern-interrupt-used.rs:5:20
|
5 | #[task(binds = UART0)]
| ^^^^^
--> $DIR/extern-interrupt-used.rs:16:20
|
16 | #[task(binds = UART0)]
| ^^^^^

69
ui/local-cfg-task-local-err.rs
View file

@ -1,69 +0,0 @@
//! examples/local-cfg-task-local.rs
#![deny(unsafe_code)]
//#![deny(warnings)]
#![no_main]
#![no_std]
use cortex_m_semihosting::debug;
use cortex_m_semihosting::hprintln;
use lm3s6965::Interrupt;
use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
#[resources]
struct Resources {
// A local (move), early resource
#[cfg(feature = "feature_l1")]
#[task_local]
#[init(1)]
l1: u32,
// A local (move), late resource
#[task_local]
l2: u32,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
rtic::pend(Interrupt::UART0);
rtic::pend(Interrupt::UART1);
(
init::LateResources {
#[cfg(feature = "feature_l2")]
l2: 2,
#[cfg(not(feature = "feature_l2"))]
l2: 5,
},
init::Monotonics(),
)
}
// l1 ok (task_local)
#[idle(resources =[#[cfg(feature = "feature_l1")]l1])]
fn idle(_cx: idle::Context) -> ! {
#[cfg(feature = "feature_l1")]
hprintln!("IDLE:l1 = {}", _cx.resources.l1).unwrap();
debug::exit(debug::EXIT_SUCCESS);
loop {}
}
// l2 ok (task_local)
#[task(priority = 1, binds = UART0, resources = [
#[cfg(feature = "feature_l2")]l2,
])]
fn uart0(_cx: uart0::Context) {
#[cfg(feature = "feature_l2")]
hprintln!("UART0:l2 = {}", _cx.resources.l2).unwrap();
}
// l2 error, conflicting with uart0 for l2 (task_local)
#[task(priority = 1, binds = UART1, resources = [
#[cfg(not(feature = "feature_l2"))]l2
])]
fn uart1(_cx: uart1::Context) {
#[cfg(not(feature = "feature_l2"))]
hprintln!("UART0:l2 = {}", _cx.resources.l2).unwrap();
}
}

37
ui/local-cfg-task-local-err.stderr
View file

@ -1,37 +0,0 @@
error: task local resource "l2" is used by multiple tasks
--> $DIR/local-cfg-task-local-err.rs:25:9
|
25 | l2: u32,
| ^^
error: task local resource "l2" is used by task "uart0" with priority 1
--> $DIR/local-cfg-task-local-err.rs:54:39
|
54 | #[cfg(feature = "feature_l2")]l2,
| ^^
error: task local resource "l2" is used by task "uart1" with priority 1
--> $DIR/local-cfg-task-local-err.rs:63:44
|
63 | #[cfg(not(feature = "feature_l2"))]l2
| ^^
warning: unused import: `cortex_m_semihosting::debug`
--> $DIR/local-cfg-task-local-err.rs:8:5
|
8 | use cortex_m_semihosting::debug;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_imports)]` on by default
warning: unused import: `cortex_m_semihosting::hprintln`
--> $DIR/local-cfg-task-local-err.rs:9:5
|
9 | use cortex_m_semihosting::hprintln;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: unused import: `lm3s6965::Interrupt`
--> $DIR/local-cfg-task-local-err.rs:10:5
|
10 | use lm3s6965::Interrupt;
| ^^^^^^^^^^^^^^^^^^^

83
ui/local-err.rs
View file

@ -1,83 +0,0 @@
//! examples/local_err.rs
#![deny(unsafe_code)]
#![deny(warnings)]
#![no_main]
#![no_std]
// errors here, since we cannot bail compilation or generate stubs
// run cargo expand, then you see the root of the problem...
use cortex_m_semihosting::{debug, hprintln};
use lm3s6965::Interrupt;
use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
#[resources]
struct Resources {
// An early resource
#[init(0)]
shared: u32,
// A local (move), early resource
#[task_local]
#[init(1)]
l1: u32,
// An exclusive, early resource
#[lock_free]
#[init(1)]
e1: u32,
// A local (move), late resource
#[task_local]
l2: u32,
// An exclusive, late resource
#[lock_free]
e2: u32,
}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
rtic::pend(Interrupt::UART0);
rtic::pend(Interrupt::UART1);
(init::LateResources { e2: 2, l2: 2 }, init::Monotonics())
}
// `shared` cannot be accessed from this context
// l1 ok
// l2 rejeceted (not task_local)
// e2 ok
#[idle(resources =[l1, l2, e2])]
fn idle(cx: idle::Context) -> ! {
hprintln!("IDLE:l1 = {}", cx.resources.l1).unwrap();
hprintln!("IDLE:e2 = {}", cx.resources.e2).unwrap();
debug::exit(debug::EXIT_SUCCESS);
loop {}
}
// `shared` can be accessed from this context
// l2 rejected (not task_local)
// e1 rejected (not lock_free)
#[task(priority = 1, binds = UART0, resources = [shared, l2, e1])]
fn uart0(cx: uart0::Context) {
let shared: &mut u32 = cx.resources.shared;
*shared += 1;
*cx.resources.e1 += 10;
hprintln!("UART0: shared = {}", shared).unwrap();
hprintln!("UART0:l2 = {}", cx.resources.l2).unwrap();
hprintln!("UART0:e1 = {}", cx.resources.e1).unwrap();
}
// l2 rejected (not task_local)
#[task(priority = 2, binds = UART1, resources = [shared, l2, e1])]
fn uart1(cx: uart1::Context) {
let shared: &mut u32 = cx.resources.shared;
*shared += 1;
hprintln!("UART1: shared = {}", shared).unwrap();
hprintln!("UART1:l2 = {}", cx.resources.l2).unwrap();
hprintln!("UART1:e1 = {}", cx.resources.e1).unwrap();
}
}

60
ui/local-err.stderr
View file

@ -1,60 +0,0 @@
error: task local resource "l2" is used by multiple tasks
--> $DIR/local-err.rs:34:9
|
34 | l2: u32,
| ^^
error: task local resource "l2" is used by task "idle" with priority 0
--> $DIR/local-err.rs:52:28
|
52 | #[idle(resources =[l1, l2, e2])]
| ^^
error: task local resource "l2" is used by task "uart0" with priority 1
--> $DIR/local-err.rs:63:62
|
63 | #[task(priority = 1, binds = UART0, resources = [shared, l2, e1])]
| ^^
error: task local resource "l2" is used by task "uart1" with priority 2
--> $DIR/local-err.rs:74:62
|
74 | #[task(priority = 2, binds = UART1, resources = [shared, l2, e1])]
| ^^
error: Lock free resource "e1" is used by tasks at different priorities
--> $DIR/local-err.rs:30:9
|
30 | e1: u32,
| ^^
error: Resource "e1" is declared lock free but used by tasks at different priorities
--> $DIR/local-err.rs:63:66
|
63 | #[task(priority = 1, binds = UART0, resources = [shared, l2, e1])]
| ^^
error: Resource "e1" is declared lock free but used by tasks at different priorities
--> $DIR/local-err.rs:74:66
|
74 | #[task(priority = 2, binds = UART1, resources = [shared, l2, e1])]
| ^^
error: unused imports: `debug`, `hprintln`
--> $DIR/local-err.rs:10:28
|
10 | use cortex_m_semihosting::{debug, hprintln};
| ^^^^^ ^^^^^^^^
|
note: the lint level is defined here
--> $DIR/local-err.rs:4:9
|
4 | #![deny(warnings)]
| ^^^^^^^^
= note: `#[deny(unused_imports)]` implied by `#[deny(warnings)]`
error: unused import: `lm3s6965::Interrupt`
--> $DIR/local-err.rs:11:5
|
11 | use lm3s6965::Interrupt;
| ^^^^^^^^^^^^^^^^^^^

50
ui/locals-cfg.rs
View file

@ -1,50 +0,0 @@
#![no_main]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965, dispatchers = [SSI0])]
mod app {
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
#[cfg(never)]
static mut FOO: u32 = 0;
FOO;
(init::LateResources {}, init::Monotonics())
}
#[idle]
fn idle(_: idle::Context) -> ! {
#[cfg(never)]
static mut FOO: u32 = 0;
FOO;
loop {}
}
#[task(binds = SVCall)]
fn svcall(_: svcall::Context) {
#[cfg(never)]
static mut FOO: u32 = 0;
FOO;
}
#[task(binds = UART0)]
fn uart0(_: uart0::Context) {
#[cfg(never)]
static mut FOO: u32 = 0;
FOO;
}
#[task]
fn foo(_: foo::Context) {
#[cfg(never)]
static mut FOO: u32 = 0;
FOO;
}
}

29
ui/locals-cfg.stderr
View file

@ -1,29 +0,0 @@
error[E0425]: cannot find value `FOO` in this scope
--> $DIR/locals-cfg.rs:12:9
|
12 | FOO;
| ^^^ not found in this scope
error[E0425]: cannot find value `FOO` in this scope
--> $DIR/locals-cfg.rs:22:9
|
22 | FOO;
| ^^^ not found in this scope
error[E0425]: cannot find value `FOO` in this scope
--> $DIR/locals-cfg.rs:32:9
|
32 | FOO;
| ^^^ not found in this scope
error[E0425]: cannot find value `FOO` in this scope
--> $DIR/locals-cfg.rs:40:9
|
40 | FOO;
| ^^^ not found in this scope
error[E0425]: cannot find value `FOO` in this scope
--> $DIR/locals-cfg.rs:48:9
|
48 | FOO;
| ^^^ not found in this scope

80
ui/resources-cfg.rs
View file

@ -1,80 +0,0 @@
#![no_main]
use panic_semihosting as _;
#[rtic::app(device = lm3s6965)]
mod app {
#[resources]
struct Resources {
#[cfg(never)]
#[init(0)]
o1: u32, // init
#[cfg(never)]
#[init(0)]
o2: u32, // idle
#[cfg(never)]
#[init(0)]
o3: u32, // EXTI0
#[cfg(never)]
#[init(0)]
o4: u32, // idle
#[cfg(never)]
#[init(0)]
o5: u32, // EXTI1
#[cfg(never)]
#[init(0)]
o6: u32, // init
#[cfg(never)]
#[init(0)]
s1: u32, // idle & EXTI0
#[cfg(never)]
#[init(0)]
s2: u32, // EXTI0 & EXTI1
#[cfg(never)]
#[init(0)]
s3: u32,
}
#[init(resources = [o1, o4, o5, o6, s3])]
fn init(c: init::Context) -> (init::LateResources, init::Monotonics) {
c.resources.o1;
c.resources.o4;
c.resources.o5;
c.resources.o6;
c.resources.s3;
(init::LateResources {}, init::Monotonics())
}
#[idle(resources = [o2, &o4, s1, &s3])]
fn idle(c: idle::Context) -> ! {
c.resources.o2;
c.resources.o4;
c.resources.s1;
c.resources.s3;
loop {}
}
#[task(binds = UART0, resources = [o3, s1, s2, &s3])]
fn uart0(c: uart0::Context) {
c.resources.o3;
c.resources.s1;
c.resources.s2;
c.resources.s3;
}
#[task(binds = UART1, resources = [s2, &o5])]
fn uart1(c: uart1::Context) {
c.resources.s2;
c.resources.o5;
}
}

119
ui/resources-cfg.stderr
View file

@ -1,119 +0,0 @@
error[E0609]: no field `o1` on type `__rtic_internal_initResources<'_>`
--> $DIR/resources-cfg.rs:48:21
|
48 | c.resources.o1;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `o4` on type `__rtic_internal_initResources<'_>`
--> $DIR/resources-cfg.rs:49:21
|
49 | c.resources.o4;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `o5` on type `__rtic_internal_initResources<'_>`
--> $DIR/resources-cfg.rs:50:21
|
50 | c.resources.o5;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `o6` on type `__rtic_internal_initResources<'_>`
--> $DIR/resources-cfg.rs:51:21
|
51 | c.resources.o6;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `s3` on type `__rtic_internal_initResources<'_>`
--> $DIR/resources-cfg.rs:52:21
|
52 | c.resources.s3;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `o2` on type `__rtic_internal_idleResources<'_>`
--> $DIR/resources-cfg.rs:59:21
|
59 | c.resources.o2;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `o4` on type `__rtic_internal_idleResources<'_>`
--> $DIR/resources-cfg.rs:60:21
|
60 | c.resources.o4;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `s1` on type `__rtic_internal_idleResources<'_>`
--> $DIR/resources-cfg.rs:61:21
|
61 | c.resources.s1;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `s3` on type `__rtic_internal_idleResources<'_>`
--> $DIR/resources-cfg.rs:62:21
|
62 | c.resources.s3;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `o3` on type `__rtic_internal_uart0Resources<'_>`
--> $DIR/resources-cfg.rs:69:21
|
69 | c.resources.o3;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `s1` on type `__rtic_internal_uart0Resources<'_>`
--> $DIR/resources-cfg.rs:70:21
|
70 | c.resources.s1;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `s2` on type `__rtic_internal_uart0Resources<'_>`
--> $DIR/resources-cfg.rs:71:21
|
71 | c.resources.s2;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `s3` on type `__rtic_internal_uart0Resources<'_>`
--> $DIR/resources-cfg.rs:72:21
|
72 | c.resources.s3;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `s2` on type `__rtic_internal_uart1Resources<'_>`
--> $DIR/resources-cfg.rs:77:21
|
77 | c.resources.s2;
| ^^ unknown field
|
= note: available fields are: `__marker__`
error[E0609]: no field `o5` on type `__rtic_internal_uart1Resources<'_>`
--> $DIR/resources-cfg.rs:78:21
|
78 | c.resources.o5;
| ^^ unknown field
|
= note: available fields are: `__marker__`

10
ui/task-priority-too-high.rs
View file

@ -2,9 +2,15 @@
#[rtic::app(device = lm3s6965)]
mod app {
#[shared]
struct Shared {}
#[local]
struct Local {}
#[init]
fn init(_: init::Context) -> (init::LateResources, init::Monotonics) {
(init::LateResources {}, init::Monotonics())
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
(Shared {}, Local {}, init::Monotonics {})
}
#[task(binds = GPIOA, priority = 1)]