//! # RTC Sleep Example
//!
//! This application demonstrates use of RTC Interrupt to wake from deepsleep.
//! It is also intended as a general introduction to interrupts and RTC with RP2040.
//!
//! See the `Cargo.toml` file for Copyright and license details.

#![no_std]
#![no_main]

// Ensure we halt the program on panic (if we don't mention this crate it won't
// be linked)
use panic_halt as _;

// Alias for our HAL crate
use rp2040_hal as hal;

// A shorter alias for the Peripheral Access Crate, which provides low-level
// register access and to the gpio and rtc modules.
use hal::{clocks::ClockGate, gpio, pac, rtc};

// Some traits we need
use embedded_hal::digital::StatefulOutputPin;

// Our interrupt macro
use hal::pac::interrupt;

// Some short-cuts to useful types
use core::cell::RefCell;
use critical_section::Mutex;

// Time & clock traits
use fugit::{HertzU32, RateExtU32};
use hal::Clock;

/// The linker will place this boot block at the start of our program image. We
/// need this to help the ROM bootloader get our code up and running.
/// Note: This boot block is not necessary when using a rp-hal based BSP
/// as the BSPs already perform this step.
#[link_section = ".boot2"]
#[used]
pub static BOOT2: [u8; 256] = rp2040_boot2::BOOT_LOADER_GENERIC_03H;

/// External high-speed crystal on the Raspberry Pi Pico board is 12 MHz. Adjust
/// if your board has a different frequency
const XTAL_FREQ_HZ: HertzU32 = HertzU32::Hz(12_000_000u32);

/// This how we transfer our RTC instance into the Interrupt Handler.
static GLOBAL_SHARED: Mutex<RefCell<Option<rtc::RealTimeClock>>> = Mutex::new(RefCell::new(None));

/// Entry point to our bare-metal application.
///
/// The `#[rp2040_hal::entry]` macro ensures the Cortex-M start-up code calls this function
/// as soon as all global variables and the spinlock are initialised.
///
/// The function configures the RP2040 peripherals, then toggles a GPIO pin in
/// an infinite loop. If there is an LED connected to that pin, it will blink.
#[rp2040_hal::entry]
fn main() -> ! {
    // Grab our singleton objects
    let mut pac = pac::Peripherals::take().unwrap();
    let mut core = pac::CorePeripherals::take().unwrap();

    // Configure the clocks
    let mut clocks = hal::clocks::ClocksManager::new(pac.CLOCKS);
    // First, enable and wait for xosc to be stable.
    let xosc = hal::xosc::setup_xosc_blocking(pac.XOSC, XTAL_FREQ_HZ).unwrap();

    // use xosc at 12MHz for clk_ref -> clk_sys -> clk_peri
    clocks
        .reference_clock
        .configure_clock(&xosc, XTAL_FREQ_HZ)
        .unwrap();
    clocks
        .system_clock
        .configure_clock(&clocks.reference_clock, XTAL_FREQ_HZ)
        .unwrap();
    clocks
        .peripheral_clock
        .configure_clock(&clocks.system_clock, XTAL_FREQ_HZ)
        .unwrap();
    // use xosc at 12MHz/256 for clk_rtc
    clocks.rtc_clock.configure_clock(&xosc, 46875.Hz()).unwrap();
    // Only leave the rtc's clock enabled while in deep sleep.
    let mut config = ClockGate::default();
    config.set_rtc_rtc(true);
    clocks.configure_sleep_enable(config);

    // The single-cycle I/O block controls our GPIO pins
    let sio = hal::Sio::new(pac.SIO);

    // Set the pins to their default state
    let pins = gpio::Pins::new(
        pac.IO_BANK0,
        pac.PADS_BANK0,
        sio.gpio_bank0,
        &mut pac.RESETS,
    );

    // Configure GPIO 25 as an output to drive our LED.
    let mut led = pins.gpio25.into_push_pull_output();

    // Prepare the RTC for the example using the 1/1/0 (Day/Month/Year) at 0:00:00 as the initial
    // day and time (it may not have been a Monday but it doesn't matter for this example.).
    let mut rtc = hal::rtc::RealTimeClock::new(
        pac.RTC,
        clocks.rtc_clock,
        &mut pac.RESETS,
        rtc::DateTime {
            year: 0,
            month: 1,
            day: 1,
            day_of_week: rtc::DayOfWeek::Monday,
            hour: 0,
            minute: 0,
            second: 0,
        },
    )
    .unwrap();

    // Trigger the IRQ every time a minute starts.
    rtc.schedule_alarm(rtc::DateTimeFilter::default().second(0));
    // Let the alarm trigger an interrupt in the NVIC.
    rtc.enable_interrupt();

    // Give away our rtc by moving them into the `GLOBAL_SHARED` variable.
    // We won't need to access it in the main thread again
    critical_section::with(|cs| {
        GLOBAL_SHARED.borrow(cs).replace(Some(rtc));
    });

    // Let the core enter deep-sleep while waiting on wfi
    core.SCB.set_sleepdeep();

    // Unmask the RTC IRQ so that the NVIC interrupt controller
    // will jump to the interrupt function when the interrupt occurs.
    // We do this last so that the interrupt can't go off while
    // it is in the middle of being configured
    unsafe {
        pac::NVIC::unmask(pac::Interrupt::RTC_IRQ);
    }

    loop {
        // Wait to be awaken by an interrupt
        cortex_m::asm::wfi();

        // Toggle the led
        let _ = led.toggle();
    }
}

#[allow(non_snake_case)]
#[interrupt]
fn RTC_IRQ() {
    critical_section::with(|cs| {
        // borrow the content of the Mutexed RefCell.
        let mut maybe_rtc = GLOBAL_SHARED.borrow_ref_mut(cs);

        // borrow the content of the Option
        if let Some(rtc) = maybe_rtc.as_mut() {
            // clear the interrupt flag so that it stops firing for now and can be triggered again.
            rtc.clear_interrupt();
        }
    });
}

// End of file