forked from pinealservo/blue_pill_ui
136 lines
5.2 KiB
Rust
136 lines
5.2 KiB
Rust
//! Blinks an LED and updates a UI based on an OLED display and rotary encoder
|
|
//!
|
|
//! This demonstrates decomposing an RTIC-based project into communicating
|
|
//! tasks and breaking out lower-level hardware details into separate modules.
|
|
//!
|
|
//! The UI model itself is a completely separate crate, and can also be built
|
|
//! for the `embedded-graphics-simulator` on the host, allowing for rapid UI
|
|
//! development without having to re-flash.
|
|
|
|
#![deny(unsafe_code)]
|
|
#![no_std]
|
|
#![no_main]
|
|
|
|
// RTIC requires that unused interrupts are declared in "dispatchers" when
|
|
// using software tasks; these free interrupts will be used to dispatch the
|
|
// software tasks.
|
|
//
|
|
// For a list, see:
|
|
// https://docs.rs/stm32f1xx-hal/0.6.1/stm32f1xx_hal/stm32/enum.Interrupt.html
|
|
#[rtic::app(device = stm32f1xx_hal::stm32, peripherals = true, dispatchers = [TAMPER])]
|
|
mod app {
|
|
use rtt_target::{rprintln, rtt_init_print};
|
|
use stm32f1xx_hal::prelude::*;
|
|
|
|
use blue_pill_ui::board::{self, Board, CounterHz, TIM2, TIM3, Event};
|
|
|
|
// Defining this struct makes shared resources available to tasks;
|
|
// they will be initialized by the values returned from `init` and
|
|
// will be wrapped in a `Mutex` and must be accessed via a closure
|
|
// passed to its `lock` method.
|
|
// If you annotate a field with #[lock_free] you can opt-out of the
|
|
// mutex but it may only be shared by tasks at the same priority.
|
|
#[shared]
|
|
struct Shared {
|
|
/// This will be used to communicate control updates from the
|
|
/// control polling task to the idle thread, which manages the
|
|
/// UI model and display drawing
|
|
update: Option<(i32, bool)>,
|
|
}
|
|
|
|
// This struct defines local resources (accessed by only one task);
|
|
// they will be initialized by the values returned from `init` and
|
|
// can be accessed directly.
|
|
#[local]
|
|
struct Local {
|
|
led: board::UserLed,
|
|
encoder: board::Encoder,
|
|
display: board::Display,
|
|
poll_timer: CounterHz<TIM2>,
|
|
blink_timer: CounterHz<TIM3>,
|
|
}
|
|
|
|
// This task does startup config; the peripherals are passed in thanks to
|
|
// `peripherals = true` in the app definition. They are the `device` and
|
|
// `core` fields of `init::Context`.
|
|
#[init]
|
|
fn init(cx: init::Context) -> (Shared, Local, init::Monotonics) {
|
|
rtt_init_print!();
|
|
rprintln!("init begin");
|
|
|
|
let Board { encoder, display, led, mut poll_timer, mut blink_timer } = Board::init(cx.device);
|
|
|
|
poll_timer.start(30.Hz()).unwrap();
|
|
poll_timer.listen(Event::Update);
|
|
blink_timer.start(2.Hz()).unwrap();
|
|
blink_timer.listen(Event::Update);
|
|
|
|
let delta = 0;
|
|
let button_up = false;
|
|
let update = Some((delta, button_up));
|
|
|
|
rprintln!("init end");
|
|
|
|
(Shared { update }, Local { led, encoder, display, poll_timer, blink_timer }, init::Monotonics())
|
|
}
|
|
|
|
/// The idle task never stops running, so it can hold `!Send` state like
|
|
/// our UI state. It busy-waits for updates via the shared `update`
|
|
/// resource.
|
|
#[idle(local = [display], shared = [update])]
|
|
fn idle(cx: idle::Context) -> ! {
|
|
let mut ui: ui::HelloDisplay<128,64> = ui::HelloDisplay::new();
|
|
let mut update = cx.shared.update;
|
|
loop {
|
|
if let Some((delta, button_up)) = update.lock(|upd| upd.take()) {
|
|
if delta != 0 {
|
|
ui.event(ui::HelloEvent::Knob(delta));
|
|
}
|
|
if button_up {
|
|
ui.event(ui::HelloEvent::Button);
|
|
}
|
|
ui.event(ui::HelloEvent::Tick);
|
|
cx.local.display.draw(&mut ui);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Poll the encoder and send its state to the idle task via the shared
|
|
// `update` resource. Print out the raw encoder count when the button is
|
|
// pressed.
|
|
//
|
|
// Since `count` is a local, we can have it initialized with a const expr.
|
|
#[task(local = [count: u16 = 0, encoder], shared = [update])]
|
|
fn count_update(mut cx: count_update::Context) {
|
|
// Skip update if the idle thread hasn't consumed it yet
|
|
if cx.shared.update.lock(|upd| upd.is_some()) {
|
|
return;
|
|
}
|
|
let delta = cx.local.encoder.poll_count_delta();
|
|
let button_up = cx.local.encoder.poll_button_up();
|
|
if button_up {
|
|
rprintln!("Button pressed: encoder count is {}", cx.local.encoder.count());
|
|
}
|
|
cx.shared.update.lock(|upd| upd.replace((delta, button_up)));
|
|
}
|
|
|
|
// Interrupt task for TIM2, the control polling timer
|
|
#[task(binds = TIM2, priority = 2, local = [poll_timer])]
|
|
fn tim2(cx: tim2::Context) {
|
|
// Delegate the state update to a software task
|
|
count_update::spawn().unwrap();
|
|
|
|
// Restart the timer and clear the interrupt flag
|
|
cx.local.poll_timer.start(30.Hz()).unwrap();
|
|
cx.local.poll_timer.clear_interrupt(Event::Update);
|
|
}
|
|
|
|
// Interrupt task for TIM3, the LED blink timer
|
|
#[task(binds = TIM3, priority = 1, local = [led, blink_timer])]
|
|
fn tim3(cx: tim3::Context) {
|
|
cx.local.led.toggle();
|
|
cx.local.blink_timer.start(2.Hz()).unwrap();
|
|
cx.local.blink_timer.clear_interrupt(Event::Update);
|
|
}
|
|
}
|