display: Restructure the program (with multiple software tasks).

display/firmware/src/display.rs

@@ -0,0 +1,106 @@
+use embedded_hal::blocking::delay::DelayUs;
+use embedded_hal::digital::v2::OutputPin;
+use epd_waveshare::{epd4in2::*, prelude::*};
+use mkl25z4_hal::time::CopyableMonoTimer;
+
+use super::information::Information;
+use super::pins::{
+    DisplayBmeSpi, DisplayBusy, DisplayCs, DisplayDc, DisplayPins, DisplayPwr, DisplayRst,
+};
+
+pub struct DisplayState {
+    // TODO
+}
+
+pub struct Display {
+    pwr: DisplayPwr,
+    epd: EPD4in2<DisplayBmeSpi, DisplayCs, DisplayBusy, DisplayDc, DisplayRst>,
+}
+
+impl Display {
+    pub fn init(
+        mut pins: DisplayPins,
+        spi: &mut DisplayBmeSpi,
+        mut time: CopyableMonoTimer,
+    ) -> Display {
+        // Enable power.
+        pins.display_pwr.set_low().ok();
+        // Wait a bit for power to stabilize.
+        time.delay_us(100u8);
+
+        let epd = EPD4in2::new(
+            spi,
+            pins.display_cs,
+            pins.display_busy,
+            pins.display_dc,
+            pins.display_rst,
+            &mut time,
+        )
+        .unwrap(); // TODO: Error handling?
+
+        // Disable power again.
+        pins.display_pwr.set_low().ok();
+
+        Display {
+            pwr: pins.display_pwr,
+            epd,
+        }
+    }
+
+    pub fn update(
+        &mut self,
+        _display_state: &DisplayState,
+        _info: &Information,
+        spi: &mut DisplayBmeSpi,
+        mut time: CopyableMonoTimer,
+    ) {
+        // Enable power.
+        self.pwr.set_low().ok();
+        // Wait a bit for power to stabilize.
+        time.delay_us(100u8);
+
+        // TODO: Error handling.
+        self.epd.wake_up(spi, &mut time).ok();
+
+        // TODO: Draw the display contents.
+        self.epd.set_background_color(Color::Black);
+        let checkerboard = Checkerboard::new(400, 300, true);
+        self.epd.update_frame_stream(spi, checkerboard).unwrap();
+        self.epd.display_frame(spi).unwrap();
+
+        // Disable power again.
+        self.pwr.set_high().ok();
+    }
+}
+
+struct Checkerboard {
+    width: usize,
+    height: usize,
+    index: usize,
+    buffer: [u8; 1],
+}
+
+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 }],
+        }
+    }
+}
+
+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
+        }
+    }
+}

display/firmware/src/information.rs

@@ -0,0 +1,7 @@
+//! Sensor information or information fetched from the internet.
+
+pub struct Information {
+    pub time: u32,
+    pub valid: bool,
+    // TODO
+}

display/firmware/src/main.rs

@@ -1,54 +1,37 @@
 #![no_main]
 #![no_std]
 
+mod display;
+mod information;
 mod pins;
+
+// TODO: Enable warnings again.
+#[allow(unused)]
 mod assets {
     include!(concat!(env!("OUT_DIR"), "/assets.rs"));
 }
 
-use cortex_m_semihosting::{debug, hprintln};
 use embedded_epd as epd;
-use embedded_epd::{gui, Display};
-use embedded_hal::blocking::delay::DelayMs;
-use embedded_hal::digital::v2::OutputPin;
-use embedded_hal::timer::CountDown;
-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 mkl25z4_hal::time::{CopyableMonoTimer, NonCopyableMonoTimer, U32Ext};
 use panic_semihosting as _;
 
-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()
-    }
-}
+use display::{Display, DisplayState};
+use information::Information;
+use pins::DisplayBmeSpi;
 
 #[rtfm::app(device = mkl25z4_hal::mkl25z4, peripherals = true)]
 const APP: () = {
-    struct Resources {}
+    struct Resources {
+        info: Information,
+        display_state: DisplayState,
+        display: Display,
+        display_bme_spi: Option<DisplayBmeSpi>,
+        time: CopyableMonoTimer,
+    }
 
-    #[init]
-    fn init(ctx: init::Context) {
+    #[init(spawn = [fetch_update])]
+    fn init(ctx: init::Context) -> init::LateResources {
         let mut sim = ctx.device.SIM;
         mkl25z4_hal::watchdog::disable(&mut sim);
         let clocks = ClockConfiguration::new()
@@ -69,29 +52,70 @@ const APP: () = {
             ctx.device.SPI1,
         );
 
-        // 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();
+        let time =
+            CopyableMonoTimer::new(NonCopyableMonoTimer::new(ctx.device.PIT, clocks, &mut sim));
+
+        let display = Display::init(pins.display, &mut pins.display_bme_spi, time);
+
+        // Fetch the first update.
+        ctx.spawn.fetch_update().ok();
+
+        init::LateResources {
+            info: Information {
+                time: 0,
+                valid: false,
+            },
+            display_state: DisplayState{
+                // TODO
+            },
+            display,
+            display_bme_spi: Some(pins.display_bme_spi),
+            time,
+        }
+    }
+
+    #[task(binds = LPTMR0, priority = 3, spawn = [fetch_update])]
+    fn lptmr0_interrupt(ctx: lptmr0_interrupt::Context) {
+        // Restart the timer.
+        // TODO
+
+        // Trigger an update of the displayed values.
+        ctx.spawn.fetch_update().ok();
+    }
+
+    #[task(binds = LLWU, priority = 3)]
+    fn llwu_interrupt(_: llwu_interrupt::Context) {
+        // TODO
+    }
+
+    #[task(priority = 1, spawn = [update_display], resources = [info])]
+    fn fetch_update(ctx: fetch_update::Context) {
+        // Fetch local updates.
+        // TODO
+
+        // Send local measurements to the base station. This needs to be done before fetching data
+        // from the base station as the base station might return the data to us.
+        // TODO
+
+        // Fetch updates via radio.
+        // TODO
+
+        // If the update failed, simply increment the time and place a hint that
+        // the information might be invalid.
+        // TODO
+
+        // Update the display to show the new values.
+        ctx.spawn.update_display().ok();
+    }
+
+    #[task(priority = 2, resources = [info, display_state, display, display_bme_spi, &time])]
+    fn update_display(ctx: update_display::Context) {
+        ctx.resources.display.update(
+            &ctx.resources.display_state,
+            &ctx.resources.info,
+            ctx.resources.display_bme_spi.as_mut().unwrap(),
+            ctx.resources.time.clone(),
+        );
     }
 
     #[idle]
@@ -105,36 +129,9 @@ const APP: () = {
             cortex_m::asm::wfi();
         }
     }
-};
-
-struct Checkerboard {
-    width: usize,
-    height: usize,
-    index: usize,
-    buffer: [u8; 1],
-}
-
-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 }],
-        }
-    }
-}
 
-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
-        }
+    extern "C" {
+        fn I2C0();
+        fn I2C1();
     }
-}
+};

display/firmware/src/pins.rs

@@ -5,6 +5,32 @@ use mkl25z4_hal::gpio::{self, gpioa, gpiob, gpioc, gpiod, gpioe, GpioExt};
 use mkl25z4_hal::spi::{self, Phase, Polarity, Spi};
 use mkl25z4_hal::time::U32Ext;
 
+pub type DisplayBusy = gpioc::PC4<gpio::Input<gpio::PullUp>>;
+pub type DisplayCs = gpioc::PC8<gpio::Output<gpio::PushPull>>;
+pub type DisplayDc = gpioc::PC9<gpio::Output<gpio::PushPull>>;
+pub type DisplayRst = gpioc::PC10<gpio::Output<gpio::PushPull>>;
+pub type DisplayPwr = gpioc::PC11<gpio::Output<gpio::PushPull>>;
+
+pub struct DisplayPins {
+    /// Display busy (active low).
+    pub display_busy: gpioc::PC4<gpio::Input<gpio::PullUp>>,
+    /// Display chip select (active low).
+    pub display_cs: gpioc::PC8<gpio::Output<gpio::PushPull>>,
+    /// Display data/command.
+    pub display_dc: gpioc::PC9<gpio::Output<gpio::PushPull>>,
+    /// Display reset (active low).
+    pub display_rst: gpioc::PC10<gpio::Output<gpio::PushPull>>,
+    /// Display supply voltage enable (active low).
+    pub display_pwr: gpioc::PC11<gpio::Output<gpio::PushPull>>,
+}
+
+pub type DisplayBmeSpi = Spi<
+    SPI0,
+    gpioc::PC7<gpio::Alternate5>,
+    gpioc::PC6<gpio::Alternate5>,
+    gpioc::PC5<gpio::Alternate2>,
+>;
+
 pub struct Pins {
     /// 5V supply for the LED (active high).
     pub enable_5v: gpioa::PA1<gpio::Output<gpio::PushPull>>,
@@ -61,24 +87,10 @@ pub struct Pins {
     /// BME280 chip select (active low).
     pub bme_cs: gpioc::PC2<gpio::Output<gpio::PushPull>>,
 
-    /// Display busy (active low).
-    pub display_busy: gpioc::PC4<gpio::Input<gpio::PullUp>>,
-    /// Display chip select (active low).
-    pub display_cs: gpioc::PC8<gpio::Output<gpio::PushPull>>,
-    /// Display data/command.
-    pub display_dc: gpioc::PC9<gpio::Output<gpio::PushPull>>,
-    /// Display reset (active low).
-    pub display_rst: gpioc::PC10<gpio::Output<gpio::PushPull>>,
-    /// Display supply voltage enable (active low).
-    pub display_pwr: gpioc::PC11<gpio::Output<gpio::PushPull>>,
+    pub display: DisplayPins,
 
     /// SPI for both display and BME280.
-    pub display_bme_spi: Spi<
-        SPI0,
-        gpioc::PC7<gpio::Alternate5>,
-        gpioc::PC6<gpio::Alternate5>,
-        gpioc::PC5<gpio::Alternate2>,
-    >,
+    pub display_bme_spi: DisplayBmeSpi,
 }
 
 impl Pins {
@@ -146,11 +158,14 @@ impl Pins {
             nrf_pwr: gpiob.pb3.into_push_pull_output(&mut gpiob.pddr),
             nrf_spi: spi1,
             bme_cs: gpioc.pc2.into_push_pull_output(&mut gpioc.pddr),
-            display_busy: gpioc.pc4.into_pull_up_input(&mut gpioc.pddr),
-            display_cs: gpioc.pc8.into_push_pull_output(&mut gpioc.pddr),
-            display_dc: gpioc.pc9.into_push_pull_output(&mut gpioc.pddr),
-            display_rst: gpioc.pc10.into_push_pull_output(&mut gpioc.pddr),
-            display_pwr: gpioc.pc11.into_push_pull_output(&mut gpioc.pddr),
+
+            display: DisplayPins {
+                display_busy: gpioc.pc4.into_pull_up_input(&mut gpioc.pddr),
+                display_cs: gpioc.pc8.into_push_pull_output(&mut gpioc.pddr),
+                display_dc: gpioc.pc9.into_push_pull_output(&mut gpioc.pddr),
+                display_rst: gpioc.pc10.into_push_pull_output(&mut gpioc.pddr),
+                display_pwr: gpioc.pc11.into_push_pull_output(&mut gpioc.pddr),
+            },
 
             display_bme_spi: spi0,
         };
@@ -162,8 +177,8 @@ impl Pins {
         pins.nrf_cs.set_high().ok();
         pins.nrf_pwr.set_high().ok();
         pins.bme_cs.set_high().ok();
-        pins.display_cs.set_high().ok();
-        pins.display_pwr.set_high().ok();
+        pins.display.display_cs.set_high().ok();
+        pins.display.display_pwr.set_high().ok();
 
         pins
     }