//! Blinks the LED on a Pico board
//!
//! This will blink an LED attached to GP25, which is the pin the Pico uses for the on-board LED.
#![no_std]
#![no_main]

use bsp::entry;
use defmt::*;
use defmt_rtt as _;
use embedded_hal::digital::v2::OutputPin;
use panic_probe as _;

// Provide an alias for our BSP so we can switch targets quickly.
// Uncomment the BSP you included in Cargo.toml, the rest of the code does not need to change.
use rp_pico as bsp;
// use sparkfun_pro_micro_rp2040 as bsp;

use bsp::hal::{
    clocks::{init_clocks_and_plls, Clock},
    pac,
    sio::Sio,
    watchdog::Watchdog,
};

fn toggle_clock<PIN>(clock_pin: &mut PIN, delay: &mut cortex_m::delay::Delay)
where
    PIN: OutputPin,
{
    clock_pin.set_high();
    delay.delay_ms(1);
    clock_pin.set_low();
    delay.delay_ms(1);
}

fn shift_out_bits<CLK_PIN, DATA_PIN>(
    data: u32,
    len: u8,
    clock_pin: &mut CLK_PIN,
    data_pin: &mut DATA_PIN,
    delay: &mut cortex_m::delay::Delay,
) where
    CLK_PIN: OutputPin,
    DATA_PIN: OutputPin,
{
    for i in 0..len {
        if data & (1 << (len - i - 1) as u32) != 0 {
            data_pin.set_high();
        } else {
            data_pin.set_low();
        }
        toggle_clock(clock_pin, delay);
    }
}

#[entry]
fn main() -> ! {
    info!("Program start");
    let mut pac = pac::Peripherals::take().unwrap();
    let core = pac::CorePeripherals::take().unwrap();
    let mut watchdog = Watchdog::new(pac.WATCHDOG);
    let sio = Sio::new(pac.SIO);

    // External high-speed crystal on the pico board is 12Mhz
    let external_xtal_freq_hz = 12_000_000u32;
    let clocks = init_clocks_and_plls(
        external_xtal_freq_hz,
        pac.XOSC,
        pac.CLOCKS,
        pac.PLL_SYS,
        pac.PLL_USB,
        &mut pac.RESETS,
        &mut watchdog,
    )
    .ok()
    .unwrap();

    let mut delay = cortex_m::delay::Delay::new(core.SYST, clocks.system_clock.freq().to_Hz());

    let pins = bsp::Pins::new(
        pac.IO_BANK0,
        pac.PADS_BANK0,
        sio.gpio_bank0,
        &mut pac.RESETS,
    );

    let mut led_pin = pins.led.into_push_pull_output();

    let mut row_data_pin = pins.gpio2.into_push_pull_output();
    let mut row_clock_pin = pins.gpio3.into_push_pull_output();

    let mut col_data_pin = pins.gpio4.into_push_pull_output();
    let mut col_clock_pin = pins.gpio5.into_push_pull_output();

    let mut white_pin = pins.gpio6.into_push_pull_output();
    let mut black_pin = pins.gpio7.into_push_pull_output();
    let mut strobe_pin = pins.gpio8.into_push_pull_output();

    loop {
        for x in 0..24 {
            for y in 0..16 {
                shift_out_bits(
                    1 << y,
                    16,
                    &mut row_clock_pin,
                    &mut row_data_pin,
                    &mut delay,
                );

                shift_out_bits(
                    1 << x,
                    24,
                    &mut col_clock_pin,
                    &mut col_data_pin,
                    &mut delay,
                );

                black_pin.set_high();
                strobe_pin.set_high();
                delay.delay_ms(20);
                strobe_pin.set_low();
                black_pin.set_low();

                delay.delay_ms(10);
            }
        }

        led_pin.set_high().unwrap();

        for y in 0..24 {
            shift_out_bits(0, 16, &mut row_clock_pin, &mut row_data_pin, &mut delay);

            shift_out_bits(
                1 << y,
                24,
                &mut col_clock_pin,
                &mut col_data_pin,
                &mut delay,
            );

            white_pin.set_high();
            strobe_pin.set_high();
            delay.delay_ms(20);
            strobe_pin.set_low();
            white_pin.set_low();

            delay.delay_ms(10);
        }

        led_pin.set_low().unwrap();
    }
}

// End of file