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
//! LED roulette and software loopback running concurrently
//!
//! ```
//!
//! #![feature(const_fn)]
//! #![feature(used)]
//! #![no_std]
//!
//! // version = "0.2.0", 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::{C0, C1, C16, Local, P0, P1};
//!
//! // 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 prio: P0, ceil: &C16) {
//! let gpioa = GPIOA.access(prio, ceil);
//! let gpioe = GPIOE.access(prio, ceil);
//! let rcc = RCC.access(prio, ceil);
//! let tim7 = TIM7.access(prio, ceil);
//! let timer = Timer(&tim7);
//! let usart1 = USART1.access(prio, ceil);
//!
//! led::init(&gpioe, &rcc);
//! timer.init(&rcc, FREQUENCY);
//! Serial(&usart1).init(&gpioa, &rcc, BAUD_RATE);
//!
//! timer.resume();
//! }
//!
//! // IDLE LOOP
//! fn idle(_prio: P0, _ceil: C0) -> ! {
//! // 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 prio: P1, ref ceil: C1) {
//! let usart1 = USART1.access(prio, ceil);
//! 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 prio: P1, ref ceil: C1) {
//! static STATE: Local<u8, Tim7> = Local::new(0);
//!
//! let tim7 = TIM7.access(prio, ceil);
//! 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.