//! Blinks an LED
//!
//! This assumes that a LED is connected to pc13 as is the case on the blue pill board.
//!
//! Note: Without additional hardware, PC13 should not be used to drive an LED, see page 5.1.2 of
//! the reference manual for an explanation. This is not an issue on the blue pill.

#![deny(unsafe_code)]
#![no_std]
#![no_main]

use panic_rtt_target as _;

// 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 core::sync::atomic::{self, Ordering};
    use rtt_target::{rprintln, rtt_init_print};
    use stm32f1xx_hal::{
        prelude::*,
        stm32,
        timer::{Event, Timer},
    };

    use stm32f1xx_hal as hal;

    // 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 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 {
        led1: hal::gpio::gpioc::PC13<hal::gpio::Output<hal::gpio::PushPull>>,
        tmr2: hal::timer::CountDownTimer<stm32::TIM2>,
        tmr3: hal::timer::CountDownTimer<stm32::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");

        // Set everything to 8MHz using the external clock
        let mut flash = cx.device.FLASH.constrain();
        let rcc = cx.device.RCC.constrain();
        let clocks = rcc
            .cfgr
            .use_hse(8.mhz())
            .sysclk(8.mhz())
            .hclk(8.mhz())
            .pclk1(8.mhz())
            .pclk2(8.mhz())
            .adcclk(8.mhz())
            .freeze(&mut flash.acr);

        // LED is on pin C13, configure it for output
        let mut gpioc = cx.device.GPIOC.split();
        let led1 = gpioc.pc13.into_push_pull_output(&mut gpioc.crh);

        // Use TIM2 for the beat counter task
        let mut tmr2 = Timer::tim2(cx.device.TIM2, &clocks).start_count_down(1.hz());
        tmr2.listen(Event::Update);

        // Use TIM3 for the LED blinker task
        let mut tmr3 = Timer::tim3(cx.device.TIM3, &clocks).start_count_down(2.hz());
        tmr3.listen(Event::Update);

        rprintln!("init end");

        (Shared {}, Local { led1, tmr2, tmr3 }, init::Monotonics())
    }

    #[idle]
    fn idle(_: idle::Context) -> ! {
        loop {
            // The compiler may omit this loop without the following
            atomic::compiler_fence(Ordering::SeqCst);
        }
    }

    // Update the beat counter and periodically display the current count
    // on the RTT channel
    // Since `beat` is a local, we can have it initialized.
    #[task(local = [beat: u32 = 0])]
    fn beat_update(cx: beat_update::Context) {
        if *cx.local.beat % 10 == 0 {
            rprintln!("TIM2 beat = {}", *cx.local.beat);
        }

        *cx.local.beat += 1;
    }

    // Interrupt task for TIM2, the beat counter timer
    #[task(binds = TIM2, priority = 2, local = [tmr2])]
    fn tim2(cx: tim2::Context) {
        // Delegate the state update to a software task
        beat_update::spawn().unwrap();

        // Restart the timer and clear the interrupt flag
        cx.local.tmr2.start(1.hz());
        cx.local.tmr2.clear_update_interrupt_flag();
    }

    // Interrupt task for TIM3, the LED blink timer
    #[task(binds = TIM3, priority = 1, local = [led1, tmr3])]
    fn tim3(cx: tim3::Context) {
        cx.local.led1.toggle();
        cx.local.tmr3.start(2.hz());
        cx.local.tmr3.clear_update_interrupt_flag();
    }
}