diff --git a/book/en/src/by-example/tips.md b/book/en/src/by-example/tips.md index 8f71599a06..c0bfc56e14 100644 --- a/book/en/src/by-example/tips.md +++ b/book/en/src/by-example/tips.md @@ -75,3 +75,19 @@ $ cargo nm --example ramfunc --release | grep ' foo::' ``` console $ cargo nm --example ramfunc --release | grep ' bar::' {{#include ../../../../ci/expected/ramfunc.grep.bar}}``` + +## `binds` + +**NOTE**: Requires RTFM ~0.4.2 + +You can give hardware tasks more task-like names using the `binds` argument: you +name the function as you wish and specify the name of the interrupt / exception +in the `binds` argument. Types like `Spawn` will be placed in a module named +after the function, not the interrupt / exception. Example below: + +``` rust +{{#include ../../../../examples/binds.rs}} +``` +``` console +$ cargo run --example binds +{{#include ../../../../ci/expected/binds.run}}``` diff --git a/ci/expected/binds.run b/ci/expected/binds.run new file mode 100644 index 0000000000..f84cff0157 --- /dev/null +++ b/ci/expected/binds.run @@ -0,0 +1,4 @@ +init +foo called 1 time +idle +foo called 2 times diff --git a/ci/script.sh b/ci/script.sh index 5cc79fbbce..7cda1e5e66 100644 --- a/ci/script.sh +++ b/ci/script.sh @@ -93,6 +93,7 @@ main() { idle init interrupt + binds resource lock diff --git a/examples/binds.rs b/examples/binds.rs new file mode 100644 index 0000000000..a8b386fb7e --- /dev/null +++ b/examples/binds.rs @@ -0,0 +1,48 @@ +//! examples/binds.rs + +#![deny(unsafe_code)] +#![deny(warnings)] +#![no_main] +#![no_std] + +extern crate panic_semihosting; + +use cortex_m_semihosting::{debug, hprintln}; +use lm3s6965::Interrupt; +use rtfm::app; + +// `examples/interrupt.rs` rewritten to use `binds` +#[app(device = lm3s6965)] +const APP: () = { + #[init] + fn init() { + rtfm::pend(Interrupt::UART0); + + hprintln!("init").unwrap(); + } + + #[idle] + fn idle() -> ! { + hprintln!("idle").unwrap(); + + rtfm::pend(Interrupt::UART0); + + debug::exit(debug::EXIT_SUCCESS); + + loop {} + } + + #[interrupt(binds = UART0)] + fn foo() { + static mut TIMES: u32 = 0; + + *TIMES += 1; + + hprintln!( + "foo called {} time{}", + *TIMES, + if *TIMES > 1 { "s" } else { "" } + ) + .unwrap(); + } +}; diff --git a/macros/src/check.rs b/macros/src/check.rs index 464e280ac1..4adc2c1756 100644 --- a/macros/src/check.rs +++ b/macros/src/check.rs @@ -106,10 +106,12 @@ pub fn app(app: &App) -> parse::Result<()> { } // Check that free interrupts are not being used - for int in app.interrupts.keys() { - if app.free_interrupts.contains_key(int) { + for (handler, interrupt) in &app.interrupts { + let name = interrupt.args.binds(handler); + + if app.free_interrupts.contains_key(name) { return Err(parse::Error::new( - int.span(), + name.span(), "free interrupts (`extern { .. }`) can't be used as interrupt handlers", )); } diff --git a/macros/src/codegen.rs b/macros/src/codegen.rs index 83e5026670..1d201c0866 100644 --- a/macros/src/codegen.rs +++ b/macros/src/codegen.rs @@ -468,7 +468,8 @@ fn post_init(ctxt: &Context, app: &App, analysis: &Analysis) -> proc_macro2::Tok // the device into compile errors let device = &app.args.device; let nvic_prio_bits = quote!(#device::NVIC_PRIO_BITS); - for (name, exception) in &app.exceptions { + for (handler, exception) in &app.exceptions { + let name = exception.args.binds(handler); let priority = exception.args.priority; exprs.push(quote!(assert!(#priority <= (1 << #nvic_prio_bits)))); exprs.push(quote!(p.SCB.set_priority( @@ -1082,9 +1083,10 @@ fn exceptions(ctxt: &mut Context, app: &App, analysis: &Analysis) -> Vec Vec Vec proc_macro2::Toke // the device into compile errors let device = &app.args.device; let nvic_prio_bits = quote!(#device::NVIC_PRIO_BITS); - for (name, interrupt) in &app.interrupts { + for (handler, interrupt) in &app.interrupts { + let name = interrupt.args.binds(handler); let priority = interrupt.args.priority; exprs.push(quote!(p.NVIC.enable(#device::Interrupt::#name);)); exprs.push(quote!(assert!(#priority <= (1 << #nvic_prio_bits));)); diff --git a/macros/src/syntax.rs b/macros/src/syntax.rs index 9771ea922e..7f87f6339e 100644 --- a/macros/src/syntax.rs +++ b/macros/src/syntax.rs @@ -699,6 +699,29 @@ impl Init { } } +/// Union of `TaskArgs`, `ExceptionArgs` and `InterruptArgs` +pub struct Args { + pub binds: Option, + pub capacity: Option, + pub priority: u8, + pub resources: Idents, + pub schedule: Idents, + pub spawn: Idents, +} + +impl Default for Args { + fn default() -> Self { + Args { + binds: None, + capacity: None, + priority: 1, + resources: Idents::new(), + schedule: Idents::new(), + spawn: Idents::new(), + } + } +} + pub struct Exception { pub args: ExceptionArgs, pub attrs: Vec, @@ -708,16 +731,25 @@ pub struct Exception { } pub struct ExceptionArgs { + binds: Option, pub priority: u8, pub resources: Idents, pub schedule: Idents, pub spawn: Idents, } +impl ExceptionArgs { + /// Returns the name of the exception / interrupt this handler binds to + pub fn binds<'a>(&'a self, handler: &'a Ident) -> &'a Ident { + self.binds.as_ref().unwrap_or(handler) + } +} + impl Parse for ExceptionArgs { fn parse(input: ParseStream<'_>) -> parse::Result { - parse_args(input, false).map( - |TaskArgs { + parse_args(input, /* binds */ true, /* capacity */ false).map( + |Args { + binds, priority, resources, schedule, @@ -725,6 +757,7 @@ impl Parse for ExceptionArgs { .. }| { ExceptionArgs { + binds, priority, resources, schedule, @@ -755,7 +788,7 @@ impl Exception { } let span = item.ident.span(); - match &*item.ident.to_string() { + match &*args.binds.as_ref().unwrap_or(&item.ident).to_string() { "MemoryManagement" | "BusFault" | "UsageFault" | "SecureFault" | "SVCall" | "DebugMonitor" | "PendSV" => {} // OK "SysTick" => { @@ -893,30 +926,40 @@ pub struct TaskArgs { pub schedule: Idents, } -impl Default for TaskArgs { - fn default() -> Self { - TaskArgs { - capacity: None, - priority: 1, - resources: Idents::new(), - schedule: Idents::new(), - spawn: Idents::new(), - } - } -} - impl Parse for TaskArgs { fn parse(input: ParseStream<'_>) -> parse::Result { - parse_args(input, true) + parse_args(input, /* binds */ false, /* capacity */ true).map( + |Args { + capacity, + priority, + resources, + schedule, + spawn, + .. + }| { + TaskArgs { + capacity, + priority, + resources, + schedule, + spawn, + } + }, + ) } } -// Parser shared by TaskArgs and ExceptionArgs / InterruptArgs -fn parse_args(input: ParseStream<'_>, accept_capacity: bool) -> parse::Result { +// Parser shared by ExceptionArgs, InterruptArgs and TaskArgs +fn parse_args( + input: ParseStream<'_>, + accepts_binds: bool, + accepts_capacity: bool, +) -> parse::Result { if input.is_empty() { - return Ok(TaskArgs::default()); + return Ok(Args::default()); } + let mut binds = None; let mut capacity = None; let mut priority = None; let mut resources = None; @@ -936,7 +979,20 @@ fn parse_args(input: ParseStream<'_>, accept_capacity: bool) -> parse::Result { + "binds" if accepts_binds => { + if binds.is_some() { + return Err(parse::Error::new( + ident.span(), + "argument appears more than once", + )); + } + + // #ident + let ident = content.parse()?; + + binds = Some(ident); + } + "capacity" if accepts_capacity => { if capacity.is_some() { return Err(parse::Error::new( ident.span(), @@ -1052,7 +1108,11 @@ fn parse_args(input: ParseStream<'_>, accept_capacity: bool) -> parse::Result { return Err(parse::Error::new( ident.span(), - "expected one of: priority, resources, schedule or spawn", + format!( + "expected one of: {}{}priority, resources, schedule or spawn", + if accepts_binds { "binds, " } else { "" }, + if accepts_capacity { "capacity, " } else { "" }, + ), )); } } @@ -1065,7 +1125,8 @@ fn parse_args(input: ParseStream<'_>, accept_capacity: bool) -> parse::Result