display: Revert to simple EPD display example code.

display/firmware/src/board/led.rs

@@ -1,88 +0,0 @@
-//! User LEDs
-
-use mkl25z4_hal::gpio;
-use embedded_hal::digital::v2::OutputPin;
-
-pub struct Led {
-    pub red: gpio::gpiob::PB18<gpio::Output<gpio::PushPull>>,
-    pub green: gpio::gpiob::PB19<gpio::Output<gpio::PushPull>>,
-    pub blue: gpio::gpiod::PD1<gpio::Output<gpio::PushPull>>,
-}
-
-impl Led {
-    /// Sets the LED's color
-    pub fn set_color(&mut self, red: bool, green: bool, blue: bool) {
-        if red {
-            self.red.set_low().ok();
-        } else {
-            self.red.set_high().ok();
-        }
-        if green {
-            self.green.set_low().ok();
-        } else {
-            self.green.set_high().ok();
-        }
-        if blue {
-            self.blue.set_low().ok();
-        } else {
-            self.blue.set_high().ok();
-        }
-        // NOTE(safe) atomic write
-        /*unsafe {
-            if red {
-                (*GPIOB::ptr()).pcor.write(|w| w.ptco().bits(1 << 18));
-            } else {
-                (*GPIOB::ptr()).psor.write(|w| w.ptso().bits(1 << 18));
-            }
-            if green {
-                (*GPIOB::ptr()).pcor.write(|w| w.ptco().bits(1 << 19));
-            } else {
-                (*GPIOB::ptr()).psor.write(|w| w.ptso().bits(1 << 19));
-            }
-            if blue {
-                (*GPIOD::ptr()).pcor.write(|w| w.ptco().bits(1 << 1));
-            } else {
-                (*GPIOD::ptr()).psor.write(|w| w.ptso().bits(1 << 1));
-            }
-        }*/    }
-}
-
-//impl Led {
-//    /// Turns off the LED
-//    pub fn off(&self) {
-//        // NOTE(safe) atomic write
-//        unsafe { (*GPIOG.get()).bsrr.write(|w| w.bits(1 << (self.i + 16))) }
-//    }
-//
-//    /// Turns on the LED
-//    pub fn on(&self) {
-//        // NOTE(safe) atomic write
-//        unsafe { (*GPIOG.get()).bsrr.write(|w| w.bits(1 << self.i)) }
-//    }
-//}
-
-/*/// Initializes all the user LEDs
-pub fn init(portb: &PORTB, gpiob: &GPIOB, portd: &PORTD, gpiod: &GPIOD, sim: &SIM) {
-    // Power up peripherals
-    //rcc.ahb1enr.modify(|_, w| w.gpiogen().set_bit());
-    sim.scgc5.modify(|_, w| w.portb().set_bit().portd().set_bit());
-
-    // Configure pins as outputs
-    portb.pcr[18].modify(|_, w| w.mux().bits(1));
-    portb.pcr[19].modify(|_, w| w.mux().bits(1));
-    portd.pcr[1].modify(|_, w| w.mux().bits(1));
-    gpiod.pcor.write(|w| unsafe { w.ptco().bits(1 << 1) });
-    gpiob.pcor.write(|w| unsafe { w.ptco().bits((1 << 18) | (1 << 19)) });
-    gpiod.pddr.write(|w| unsafe { w.pdd().bits(1 << 1) });
-    gpiob.pddr.write(|w| unsafe { w.pdd().bits((1 << 18) | (1 << 19)) });
-    /*gpiog
-        .moder
-        .modify(
-            |_, w| {
-                w.moder13()
-                    .bits(1)
-                    .moder14()
-                    .bits(1)
-            },
-        );*/
-}*/

display/firmware/src/board/mod.rs

@@ -1 +0,0 @@
-pub mod led;

display/firmware/src/main.rs

@@ -1,27 +1,25 @@
 #![no_main]
 #![no_std]
 
-mod board;
 mod pins;
 mod assets {
     include!(concat!(env!("OUT_DIR"), "/assets.rs"));
 }
 
-
 use cortex_m_semihosting::{debug, hprintln};
-use mkl25z4_hal as hal;
-use panic_semihosting as _;
-use mkl25z4_hal::gpio::GpioExt;
-use mkl25z4_hal::spi::{Phase, Polarity, Spi};
-use mkl25z4_hal::time::{NonCopyableMonoTimer, U32Ext};
-use mkl25z4_hal::timer::{Timer, TimerInterrupt};
-use embedded_hal::digital::v2::OutputPin;
-use embedded_epd::{gui, Display};
 use embedded_epd as epd;
-use nb::block;
+use embedded_epd::{gui, Display};
+use embedded_hal::blocking::delay::DelayMs;
+use embedded_hal::digital::v2::OutputPin;
 use embedded_hal::timer::CountDown;
-
-use board::led;
+use epd_waveshare::{epd4in2::*, prelude::*};
+use mkl25z4_hal as hal;
+use mkl25z4_hal::clocks::ClockConfiguration;
+use mkl25z4_hal::time::NonCopyableMonoTimer;
+use mkl25z4_hal::time::U32Ext;
+use mkl25z4_hal::timer::Timer;
+use nb::block;
+use panic_semihosting as _;
 
 struct EPDTimer<Timer> {
     timer: Timer,
@@ -47,116 +45,53 @@ where
 
 #[rtfm::app(device = mkl25z4_hal::mkl25z4, peripherals = true)]
 const APP: () = {
-    struct Resources {
-    }
+    struct Resources {}
 
     #[init]
     fn init(ctx: init::Context) {
         let mut sim = ctx.device.SIM;
         mkl25z4_hal::watchdog::disable(&mut sim);
-        let clocks = mkl25z4_hal::clocks::init();
-
-        let mut gpiob = ctx.device.GPIOB.split(&mut sim);
-        let mut gpioc = ctx.device.GPIOC.split(&mut sim);
-        let mut gpiod = ctx.device.GPIOD.split(&mut sim);
-
-        let mut led = led::Led {
-            red: gpiob.pb18.into_push_pull_output(&mut gpiob.pddr),
-            green: gpiob.pb19.into_push_pull_output(&mut gpiob.pddr),
-            blue: gpiod.pd1.into_push_pull_output(&mut gpiod.pddr),
-        };
-        //led::init(&p.device.PORTB, &p.device.GPIOB, &p.device.PORTD, &p.device.GPIOD, &p.device.SIM);
-        led.set_color(true, true, true);
-
-        /*for _ in 0..2 {
-            time.delay_ms(1000);
-            led.set_color(false, false, true);
-            time.delay_ms(1000);
-            led.set_color(false, true, false);
-        }*/
-
-        let mosi = gpioc.pc6.into_alternate(&mut gpioc.pddr);
-        let miso = gpioc.pc7.into_alternate(&mut gpioc.pddr);
-        let sck = gpioc.pc5.into_alternate(&mut gpioc.pddr);
-        let mode = hal::spi::Mode {
-            polarity: Polarity::IdleLow,
-            phase: Phase::CaptureOnFirstTransition,
-        };
-        let spi0 = Spi::spi0(ctx.device.SPI0, mosi, miso, sck, mode, &mut sim);
-
-        // Initialize the display.
-        let busy = gpioc.pc3.into_floating_input(&mut gpioc.pddr);
-        let mut reset = gpioc.pc2.into_push_pull_output(&mut gpioc.pddr);
-        reset.set_high().unwrap();
-        let mut data_cmd = gpioc.pc1.into_push_pull_output(&mut gpioc.pddr);
-        data_cmd.set_high().unwrap();
-        let mut cs = gpioc.pc0.into_push_pull_output(&mut gpioc.pddr);
-        cs.set_high().unwrap();
-
-        let t = EPDTimer {
-            timer: Timer::pit(ctx.device.PIT, hal::time::Hertz(1), clocks, &mut sim),
-        };
-
-        let mut display = epd::gdew042z15::GDEW042Z15::new(spi0, busy, reset, data_cmd, cs, t);
-        block!(display.init()).ok();
-        block!(display.start_frame()).ok();
-        led.set_color(false, false, false);
-        let layout = gui::Layout::new(
-            400,
-            300,
-            gui::VerticalSplit::expand_bottom(
-                24,
-                gui::Fill::new(epd::Color::White),
-                gui::VerticalSplit::expand_bottom(
-                    1,
-                    gui::Fill::new(epd::Color::Black),
-                    gui::HorizontalSplit::expand_right(
-                        48,
-                        gui::Fill::new(epd::Color::White),
-                        //gui::Image::new(&assets::ALARM_CLOCK_36),
-                        gui::HorizontalSplit::expand_right(
-                            1,
-                            gui::Fill::new(epd::Color::Black),
-                            gui::HorizontalSplit::expand_left(
-                                49,
-                                gui::VerticalSplit::expand_bottom(
-                                    132,
-                                    gui::Align::new(
-                                        gui::HorizontalAlign::Center,
-                                        gui::VerticalAlign::Top,
-                                        gui::Text::new("12:34", &assets::ROBOTO_100),
-                                    ),
-                                    gui::Align::new(
-                                        gui::HorizontalAlign::Center,
-                                        gui::VerticalAlign::Top,
-                                        gui::HorizontalSplit::expand_right(
-                                            36,
-                                            gui::Image::new(&assets::ALARM_CLOCK_36),
-                                            gui::Text::new("Do. 8:00", &assets::ROBOTO_30),
-                                        ),
-                                    ),
-                                ),
-                                gui::Fill::new(epd::Color::White),
-                            ),
-                        ),
-                    ),
-                ),
-            ),
+        let clocks = ClockConfiguration::new()
+            .use_irc()
+            .core_clock(24.mhz())
+            .bus_clock(24.mhz())
+            .apply(&mut sim, ctx.device.OSC0, ctx.device.MCG);
+
+        let mut pins = pins::Pins::configure(
+            &mut sim,
+            clocks,
+            ctx.device.GPIOA,
+            ctx.device.GPIOB,
+            ctx.device.GPIOC,
+            ctx.device.GPIOD,
+            ctx.device.GPIOE,
+            ctx.device.SPI0,
+            ctx.device.SPI1,
         );
-        let mut row_buffer = [0u8; 400 / 8];
-        layout.render(&mut display, &mut row_buffer);
-        display.end_frame();
-        led.set_color(true, true, false);
-
-        let (_, _, _, _, _, mut t) = display.destroy();
-
-        /*let pit_ = display.time.deactivate(&mut p.device.SIM);*/
-        t.start(epd::Hertz(1));
-        t.timer.enable_interrupt();
-        let mut nvic = ctx.core.NVIC;
-        nvic.enable(mkl25z4::Interrupt::PIT);
 
-        led.set_color(true, true, true);
+        // Enable power.
+        pins.display_pwr.set_low().ok();
+        pins.display_rst.set_high().unwrap();
+        pins.display_dc.set_high().unwrap();
+        pins.display_cs.set_high().unwrap();
+
+        let mut timer = NonCopyableMonoTimer::new(ctx.device.PIT, clocks, &mut sim);
+
+        let mut epd = EPD4in2::new(
+            &mut pins.display_bme_spi,
+            pins.display_cs,
+            pins.display_busy,
+            pins.display_dc,
+            pins.display_rst,
+            &mut timer,
+        )
+        .unwrap();
+
+        epd.set_background_color(Color::Black);
+        let checkerboard = Checkerboard::new(400, 300, true);
+        epd.update_frame_stream(&mut pins.display_bme_spi, checkerboard)
+            .unwrap();
+        epd.display_frame(&mut pins.display_bme_spi).unwrap();
     }
 
     #[idle]
@@ -172,241 +107,34 @@ const APP: () = {
     }
 };
 
-/*#![no_main]
-#![no_std]
-
-extern crate cortex_m;
-extern crate cortex_m_rt as rt;
-//extern crate cortex_m_rtfm as rtfm;
-extern crate embedded_epd as epd;
-extern crate embedded_hal;
-extern crate mkl25z4;
-extern crate mkl25z4_hal as hal;
-//extern crate panic_halt;
-extern crate panic_semihosting;
-extern crate void;
-#[macro_use(block)]
-extern crate nb;
-extern crate bme280;
-
-mod board;
-mod assets {
-    include!(concat!(env!("OUT_DIR"), "/assets.rs"));
+struct Checkerboard {
+    width: usize,
+    height: usize,
+    index: usize,
+    buffer: [u8; 1],
 }
 
-use bme280::BME280;
-use board::led;
-use embedded_hal::prelude::*;
-use embedded_hal::timer::CountDown;
-use epd::{gui, Display};
-use hal::gpio::GpioExt;
-use hal::i2c::BlockingI2c;
-use hal::spi::{Phase, Polarity, Spi};
-use hal::time::{NonCopyableMonoTimer, U32Ext};
-use hal::timer::{Timer, TimerInterrupt};
-use rt::pre_init;
-use rtfm::{app, Threshold};
-
-/*use core::sync::atomic;
-use core::sync::atomic::Ordering;*/
-
-struct EPDTimer<Timer> {
-    timer: Timer,
-}
-
-impl<Timer> CountDown for EPDTimer<Timer>
-where
-    Timer: CountDown<Time = hal::time::Hertz>,
-{
-    type Time = epd::Hertz;
-
-    fn start<T>(&mut self, timeout: T)
-    where
-        T: Into<epd::Hertz>,
-    {
-        self.timer.start(hal::time::Hertz(timeout.into().0))
-    }
-
-    fn wait(&mut self) -> nb::Result<(), void::Void> {
-        self.timer.wait()
-    }
-}
-
-#[pre_init]
-unsafe fn disable_watchdog() {
-    use mkl25z4::SIM;
-    (*SIM::ptr()).copc.write(|w| w.bits(0));
-}
-
-app! {
-    device: mkl25z4,
-
-    resources: {
-        static ON: bool = false;
-        static pit: hal::timer::Timer<mkl25z4::PIT>;
-        static rgb_led: led::Led;
-    },
-
-    tasks: {
-        PIT: {
-            path: pit_handler,
-            resources: [pit, rgb_led, ON],
-        },
-    },
-}
-
-fn init(mut p: init::Peripherals, _r: init::Resources) -> init::LateResources {
-    mkl25z4_hal::watchdog::disable(&mut p.device.SIM);
-    let clocks = mkl25z4_hal::clocks::init();
-    //let time = hal::time::MonoTimer::new(p.device.PIT, clocks, &mut p.device.SIM);
-
-    let mut gpiob = p.device.GPIOB.split(&mut p.device.SIM);
-    let mut gpioc = p.device.GPIOC.split(&mut p.device.SIM);
-    let mut gpiod = p.device.GPIOD.split(&mut p.device.SIM);
-
-    let mut led = led::Led {
-        red: gpiob.pb18.into_push_pull_output(&mut gpiob.pddr),
-        green: gpiob.pb19.into_push_pull_output(&mut gpiob.pddr),
-        blue: gpiod.pd1.into_push_pull_output(&mut gpiod.pddr),
-    };
-    //led::init(&p.device.PORTB, &p.device.GPIOB, &p.device.PORTD, &p.device.GPIOD, &p.device.SIM);
-    led.set_color(true, true, true);
-
-    let timer = NonCopyableMonoTimer::new(p.device.PIT, clocks, &mut p.device.SIM);
-    let scl = gpiob.pb2.into_alternate(&mut gpiob.pddr);
-    let sda = gpiob.pb3.into_alternate(&mut gpiob.pddr);
-    let i2c0 = BlockingI2c::i2c0(
-        p.device.I2C0,
-        sda,
-        scl,
-        100000u32.hz(),
-        timer,
-        clocks,
-        &mut p.device.SIM,
-        1000000,
-        10,
-        1000000,
-        1000000,
-    );
-    let mut bme280 = BME280::new_primary(i2c0);
-    let (_, _, _, timer) = i2c0.free(&mut p.device.SIM);
-    let pit_ = timer.free(&mut p.device.SIM);
-
-    /*for _ in 0..2 {
-        time.delay_ms(1000);
-        led.set_color(false, false, true);
-        time.delay_ms(1000);
-        led.set_color(false, true, false);
-    }*/
-
-    let mosi = gpioc.pc6.into_alternate(&mut gpioc.pddr);
-    let miso = gpioc.pc7.into_alternate(&mut gpioc.pddr);
-    let sck = gpioc.pc5.into_alternate(&mut gpioc.pddr);
-    let mode = hal::spi::Mode {
-        polarity: Polarity::IdleLow,
-        phase: Phase::CaptureOnFirstTransition,
-    };
-    let spi0 = Spi::spi0(p.device.SPI0, mosi, miso, sck, mode, &mut p.device.SIM);
-
-    // Initialize the display.
-    let busy = gpioc.pc3.into_floating_input(&mut gpioc.pddr);
-    let mut reset = gpioc.pc2.into_push_pull_output(&mut gpioc.pddr);
-    reset.set_high();
-    let mut data_cmd = gpioc.pc1.into_push_pull_output(&mut gpioc.pddr);
-    data_cmd.set_high();
-    let mut cs = gpioc.pc0.into_push_pull_output(&mut gpioc.pddr);
-    cs.set_high();
-
-    let t = EPDTimer {
-        timer: Timer::pit(pit_, hal::time::Hertz(1), clocks, &mut p.device.SIM),
-    };
-
-    let mut display = epd::gdew042z15::GDEW042Z15::new(spi0, busy, reset, data_cmd, cs, t);
-    block!(display.init()).ok();
-    block!(display.start_frame()).ok();
-    led.set_color(false, false, false);
-    let layout = gui::Layout::new(
-        400,
-        300,
-        gui::VerticalSplit::expand_bottom(
-            24,
-            gui::Fill::new(epd::Color::White),
-            gui::VerticalSplit::expand_bottom(
-                1,
-                gui::Fill::new(epd::Color::Black),
-                gui::HorizontalSplit::expand_right(
-                    48,
-                    gui::Fill::new(epd::Color::White),
-                    //gui::Image::new(&assets::ALARM_CLOCK_36),
-                    gui::HorizontalSplit::expand_right(
-                        1,
-                        gui::Fill::new(epd::Color::Black),
-                        gui::HorizontalSplit::expand_left(
-                            49,
-                            gui::VerticalSplit::expand_bottom(
-                                132,
-                                gui::Align::new(
-                                    gui::HorizontalAlign::Center,
-                                    gui::VerticalAlign::Top,
-                                    gui::Text::new("12:34", &assets::ROBOTO_100),
-                                ),
-                                gui::Align::new(
-                                    gui::HorizontalAlign::Center,
-                                    gui::VerticalAlign::Top,
-                                    gui::HorizontalSplit::expand_right(
-                                        36,
-                                        gui::Image::new(&assets::ALARM_CLOCK_36),
-                                        gui::Text::new("Do. 8:00", &assets::ROBOTO_30),
-                                    ),
-                                ),
-                            ),
-                            gui::Fill::new(epd::Color::White),
-                        ),
-                    ),
-                ),
-            ),
-        ),
-    );
-    let mut row_buffer = [0u8; 400 / 8];
-    layout.render(&mut display, &mut row_buffer);
-    display.end_frame();
-    led.set_color(true, true, false);
-
-    let (_, _, _, _, _, mut t) = display.destroy();
-
-    /*let pit_ = display.time.deactivate(&mut p.device.SIM);*/
-    t.start(epd::Hertz(1));
-    t.timer.enable_interrupt();
-    p.core.NVIC.enable(mkl25z4::Interrupt::PIT);
-
-    led.set_color(true, true, true);
-
-    init::LateResources {
-        pit: t.timer,
-        rgb_led: led,
+impl Checkerboard {
+    fn new(width: usize, height: usize, start_black: bool) -> Self {
+        Self {
+            width: width / 8,
+            height,
+            index: 0,
+            buffer: [if start_black { 0x55 } else { 0xaa }],
+        }
     }
 }
 
-fn idle() -> ! {
-    // Sleep
-    loop {
-        // wfi needs to be disabled for GDB
-        /*// add some side effect to prevent this from turning into a UDF instruction
-        // see rust-lang/rust#28728 for details
-        atomic::compiler_fence(Ordering::SeqCst);*/
-        rtfm::wfi();
+impl DisplayStream for Checkerboard {
+    fn next<'a>(&'a mut self) -> Option<&'a [u8]> {
+        if self.index != self.width * self.height {
+            self.index += 1;
+            if (self.index - 1) % self.width == 0 {
+                self.buffer[0] = !self.buffer[0];
+            }
+            Some(&self.buffer)
+        } else {
+            None
+        }
     }
 }
-
-// TASKS
-
-// Toggle the state of the LED
-fn pit_handler(_t: &mut Threshold, mut r: PIT::Resources) {
-    if *r.ON {
-        r.rgb_led.set_color(false, false, true);
-    } else {
-        r.rgb_led.set_color(true, false, false);
-    }
-    r.pit.wait().ok();
-    *r.ON = !*r.ON;
-}*/