1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! LED roulette and serial loopback running concurrently
//!
//! ```
//! 
//! #![feature(const_fn)]
//! #![feature(used)]
//! #![no_std]
//! 
//! // version = "0.2.2", default-features = false
//! extern crate cast;
//! 
//! // version = "0.2.0"
//! extern crate cortex_m_rt;
//! 
//! // version = "0.1.0"
//! #[macro_use]
//! extern crate cortex_m_rtfm as rtfm;
//! 
//! extern crate f3;
//! 
//! use cast::{u8, usize};
//! use f3::led::{self, LEDS};
//! use f3::serial::Serial;
//! use f3::stm32f30x::interrupt::{Tim7, Usart1Exti25};
//! use f3::stm32f30x;
//! use f3::timer::Timer;
//! use rtfm::{Local, P0, P1, T0, T1, TMax};
//! 
//! // CONFIGURATION
//! pub const BAUD_RATE: u32 = 115_200; // bits per second
//! const FREQUENCY: u32 = 4; // Hz
//! 
//! // RESOURCES
//! peripherals!(stm32f30x, {
//!     GPIOA: Peripheral {
//!         register_block: Gpioa,
//!         ceiling: C0,
//!     },
//!     GPIOE: Peripheral {
//!         register_block: Gpioe,
//!         ceiling: C0,
//!     },
//!     RCC: Peripheral {
//!         register_block: Rcc,
//!         ceiling: C0,
//!     },
//!     TIM7: Peripheral {
//!         register_block: Tim7,
//!         ceiling: C1,
//!     },
//!     USART1: Peripheral {
//!         register_block: Usart1,
//!         ceiling: C1,
//!     },
//! });
//! 
//! // INITIALIZATION PHASE
//! fn init(ref priority: P0, threshold: &TMax) {
//!     let gpioa = GPIOA.access(priority, threshold);
//!     let gpioe = GPIOE.access(priority, threshold);
//!     let rcc = RCC.access(priority, threshold);
//!     let tim7 = TIM7.access(priority, threshold);
//!     let usart1 = USART1.access(priority, threshold);
//! 
//!     let timer = Timer(&tim7);
//!     let serial = Serial(&usart1);
//! 
//!     led::init(&gpioe, &rcc);
//!     timer.init(&rcc, FREQUENCY);
//!     serial.init(&gpioa, &rcc, BAUD_RATE);
//! 
//!     timer.resume();
//! }
//! 
//! // IDLE LOOP
//! fn idle(_priority: P0, _threshold: T0) -> ! {
//!     // Sleep
//!     loop {
//!         rtfm::wfi();
//!     }
//! }
//! 
//! // TASKS
//! tasks!(stm32f30x, {
//!     loopback: Task {
//!         interrupt: Usart1Exti25,
//!         priority: P1,
//!         enabled: true,
//!     },
//!     roulette: Task {
//!         interrupt: Tim7,
//!         priority: P1,
//!         enabled: true,
//!     },
//! });
//! 
//! fn loopback(_task: Usart1Exti25, ref priority: P1, ref threshold: T1) {
//!     let usart1 = USART1.access(priority, threshold);
//!     let serial = Serial(&usart1);
//! 
//!     if let Ok(byte) = serial.read() {
//!         if serial.write(byte).is_err() {
//!             // As we are echoing the bytes as soon as they arrive, it should
//!             // be impossible to have a TX buffer overrun
//!             #[cfg(debug_assertions)]
//!             unreachable!()
//!         }
//!     } else {
//!         // Only reachable through `rtfm::request(loopback)`
//!         #[cfg(debug_assertions)]
//!         unreachable!()
//!     }
//! }
//! 
//! fn roulette(mut task: Tim7, ref priority: P1, ref threshold: T1) {
//!     static STATE: Local<u8, Tim7> = Local::new(0);
//! 
//!     let tim7 = TIM7.access(priority, threshold);
//!     let timer = Timer(&tim7);
//! 
//!     if timer.clear_update_flag().is_ok() {
//!         let state = STATE.borrow_mut(&mut task);
//! 
//!         let curr = *state;
//!         let next = (curr + 1) % u8(LEDS.len()).unwrap();
//! 
//!         LEDS[usize(curr)].off();
//!         LEDS[usize(next)].on();
//! 
//!         *state = next;
//!     } else {
//!         // Only reachable through `rtfm::request(roulette)`
//!         #[cfg(debug_assertion)]
//!         unreachable!()
//!     }
//! }
//! ```
// Auto-generated. Do not modify.