display: Show dummy weather station values.

display/firmware/Cargo.lock

@@ -400,12 +400,12 @@ dependencies = [
 [[package]]
 name = "tinygfx"
 version = "0.1.0"
-source = "git+https://github.com/mgottschlag/tinygfx#6560a8e340ce288b9d3be0fad4933a9e22a74417"
+source = "git+https://github.com/mgottschlag/tinygfx#e2363c5489bb74bd8abb7f9e2a63220880b5a66e"
 
 [[package]]
 name = "tinygfx-assets"
 version = "0.1.0"
-source = "git+https://github.com/mgottschlag/tinygfx#6560a8e340ce288b9d3be0fad4933a9e22a74417"
+source = "git+https://github.com/mgottschlag/tinygfx#e2363c5489bb74bd8abb7f9e2a63220880b5a66e"
 dependencies = [
  "freetype-rs 0.24.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "lodepng 2.6.0 (registry+https://github.com/rust-lang/crates.io-index)",

display/firmware/build.rs

@@ -18,18 +18,32 @@ fn main() {
     let epd_font = font.generate(
         "ROBOTO_30",
         30,
-        " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:.",
+        " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:.,%°ß↗",
         "::tinygfx",
     );
-
     f.write_all(epd_font.as_bytes()).unwrap();
 
-    let clock_image = assets::Image::load("assets/ic_alarm_black_36dp.png").unwrap();
+    let epd_font = font.generate(
+        "ROBOTO_22",
+        22,
+        " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:.,%°ß",
+        "::tinygfx",
+    );
+    f.write_all(epd_font.as_bytes()).unwrap();
 
-    f.write_all(
-        clock_image
-            .generate_bitmap("ALARM_CLOCK_36", "::tinygfx")
-            .as_bytes(),
-    )
-    .unwrap();
+    for (filename, name) in [
+        ("assets/ic_alarm_black_36dp.png", "ALARM_CLOCK_36"),
+        ("assets/ic_thermometer_black_36dp.png", "THERMOMETER_36"),
+        ("assets/ic_water_percent_black_36dp.png", "WATER_PERCENT_36"),
+        (
+            "assets/ic_wifi_strength_alert_outline_black_36dp.png",
+            "WIFI_STRENGTH_ALERT_36",
+        ),
+    ]
+    .iter()
+    {
+        let clock_image = assets::Image::load(filename).unwrap();
+        f.write_all(clock_image.generate_bitmap(name, "::tinygfx").as_bytes())
+            .unwrap();
+    }
 }

display/firmware/src/display.rs

@@ -4,10 +4,11 @@ use epd_waveshare::epd4in2::EPD4in2;
 use epd_waveshare::prelude::{DisplayStream, WaveshareDisplay};
 use mkl25z4_hal::time::CopyableMonoTimer;
 use tinygfx::color::BlackWhite::{self, Black, White};
-use tinygfx::{Frame, Rectangle, Renderer, Text};
+use tinygfx::image::{MonoBitmapImage, MonoImageData};
+use tinygfx::{Clip, Frame, MonoImage, Rectangle, Renderer, Text, TextAlignment};
 
-use super::assets::ROBOTO_30;
-use super::information::Information;
+use super::assets::*;
+use super::information::{Information, TemperatureHumidity};
 use super::pins::{
     DisplayBmeSpi, DisplayBusy, DisplayCs, DisplayDc, DisplayPins, DisplayPwr, DisplayRst,
 };
@@ -54,7 +55,7 @@ impl Display {
     pub fn update(
         &mut self,
         _display_state: &DisplayState,
-        _info: &Information,
+        info: &Information,
         spi: &mut DisplayBmeSpi,
         mut time: CopyableMonoTimer,
     ) {
@@ -66,14 +67,70 @@ impl Display {
         // TODO: Error handling.
         self.epd.wake_up(spi, &mut time).ok();
 
-        // TODO: Draw the display contents.
-        let r = Rectangle::new(10, 10, 100, 50, Black);
-        let t = Text::new(20, 100, "asdf", &ROBOTO_30, Black);
+        // TODO: Insert values.
+        let date = Text::new(8, 8, "Samstag, 25.04.2020", &ROBOTO_22, Black);
+        let mut time = Text::new(392, 8, "12:34", &ROBOTO_22, Black);
+        time.align(TextAlignment::Right);
+        let top_bar = Rectangle::new(0, 34, 400, 1, Black);
+
+        let tile_width = 400 / 2 - 1;
+        let tile_height = (300 - 35) / 2 - 1;
+
+        let outside_strings = info.outside.map(|x| TempHumStrings::new(x));
+        let inside_strings = info.inside.map(|x| TempHumStrings::new(x));
+        let bathroom_strings = info.bathroom.map(|x| TempHumStrings::new(x));
+        let pressure_string = info.pressure.map(|x| PressureString::new(x));
+
+        let inside_tile = TempHumTile::new(
+            "Innen",
+            inside_strings.as_ref(),
+            0,
+            35,
+            tile_width,
+            tile_height,
+        );
+        let outside_tile = TempHumTile::new(
+            "Außen",
+            outside_strings.as_ref(),
+            200,
+            35,
+            tile_width,
+            tile_height,
+        );
+        let bathroom_tile = TempHumTile::new(
+            "Bad",
+            bathroom_strings.as_ref(),
+            0,
+            35 + tile_height + 1,
+            tile_width,
+            tile_height,
+        );
+        let pressure_tile = PressureTile::new(
+            pressure_string.as_ref(),
+            200,
+            35 + tile_height + 1,
+            tile_width,
+            tile_height,
+        );
+
+        let vert_separator = Rectangle::new(8, 35 + tile_height, 392, 1, Black);
+        let hor_separator = Rectangle::new(tile_width, 35 + 8, 1, 300 - 35 - 16, Black);
+
         let mut frame = Frame::new(400, 300, |mut renderer| {
             let clip = renderer.full_frame();
             renderer.clear(White);
-            r.draw(clip, &mut renderer);
-            t.draw(clip, &mut renderer);
+
+            top_bar.draw(clip, &mut renderer);
+            date.draw(clip, &mut renderer);
+            time.draw(clip, &mut renderer);
+
+            vert_separator.draw(clip, &mut renderer);
+            hor_separator.draw(clip, &mut renderer);
+
+            inside_tile.draw(clip, &mut renderer);
+            outside_tile.draw(clip, &mut renderer);
+            bathroom_tile.draw(clip, &mut renderer);
+            pressure_tile.draw(clip, &mut renderer);
         });
         frame.mirror_x(true);
         frame.mirror_y(true);
@@ -87,6 +144,287 @@ impl Display {
     }
 }
 
+struct TempHumStrings {
+    temp: [u8; 9],
+    temp_length: usize,
+    hum: [u8; 6],
+    hum_length: usize,
+}
+
+impl TempHumStrings {
+    fn new(data: TemperatureHumidity) -> TempHumStrings {
+        // TODO: Refactor the printing code.
+        let (temp, temp_length) = {
+            let mut x = data.temperature;
+            let mut length = 0;
+            let mut buffer = [0u8; 9];
+            let mut cursor = &mut buffer[..];
+            if x < 0 {
+                cursor[0] = '-' as u8;
+                x = -x;
+                cursor = &mut cursor[1..];
+                length += 1;
+            }
+            let orig_x = x;
+            x = i32::min(x, 9999);
+            if orig_x >= 1000 {
+                cursor[0] = '0' as u8 + (x / 1000) as u8;
+                cursor = &mut cursor[1..];
+                x %= 1000;
+                length += 1;
+            }
+            if orig_x >= 100 {
+                cursor[0] = '0' as u8 + (x / 100) as u8;
+                cursor = &mut cursor[1..];
+                x %= 100;
+                length += 1;
+            }
+            cursor[0] = '0' as u8 + (x / 10) as u8;
+            cursor[1] = ',' as u8;
+            cursor[2] = '0' as u8 + (x % 10) as u8;
+            cursor[3] = 0xc2;
+            cursor[4] = 0xb0;
+            cursor[5] = 'C' as u8;
+            length += 6;
+            (buffer, length)
+        };
+        let (hum, hum_length) = {
+            let mut x = data.humidity;
+            let mut length = 0;
+            let mut buffer = [0u8; 6];
+            let mut cursor = &mut buffer[..];
+            x = u32::min(x, 1000);
+            let orig_x = x;
+            if orig_x >= 1000 {
+                cursor[0] = '1' as u8;
+                cursor = &mut cursor[1..];
+                x %= 1000;
+                length += 1;
+            }
+            if orig_x >= 100 {
+                cursor[0] = '0' as u8 + (x / 100) as u8;
+                cursor = &mut cursor[1..];
+                x %= 100;
+                length += 1;
+            }
+            cursor[0] = '0' as u8 + (x / 10) as u8;
+            cursor[1] = ',' as u8;
+            cursor[2] = '0' as u8 + (x % 10) as u8;
+            cursor[3] = '%' as u8;
+            length += 4;
+            (buffer, length)
+        };
+        TempHumStrings {
+            temp,
+            temp_length,
+            hum,
+            hum_length,
+        }
+    }
+
+    fn temperature<'a>(&'a self) -> &'a str {
+        unsafe {
+            // Safe, we did not use any non-UTF characters above.
+            core::str::from_utf8_unchecked(&self.temp[0..self.temp_length])
+        }
+    }
+
+    fn humidity<'a>(&'a self) -> &'a str {
+        unsafe {
+            // Safe, we did not use any non-UTF characters above.
+            core::str::from_utf8_unchecked(&self.hum[0..self.hum_length])
+        }
+    }
+}
+
+struct TempHumTile<'a> {
+    title: Text<'a, BlackWhite>,
+    data: Option<(
+        MonoImage<'static, MonoBitmapImage, BlackWhite>,
+        Text<'a, BlackWhite>,
+        MonoImage<'static, MonoBitmapImage, BlackWhite>,
+        Text<'a, BlackWhite>,
+    )>,
+    error: Option<MonoImage<'static, MonoBitmapImage, BlackWhite>>,
+}
+
+impl<'a> TempHumTile<'a> {
+    fn new(
+        title: &'a str,
+        data: Option<&'a TempHumStrings>,
+        left: i32,
+        top: i32,
+        width: i32,
+        height: i32,
+    ) -> Self {
+        let center = left + width / 2;
+
+        let mut title = Text::new(center, top + 10, title, &ROBOTO_30, Black);
+        title.align(TextAlignment::Center);
+
+        let mut tile = Self {
+            title,
+            data: None,
+            error: None,
+        };
+
+        if let Some(data) = data {
+            let temp_width =
+                ROBOTO_30.get_text_size(data.temperature()).0 + 1 + THERMOMETER_36.width();
+            let temp_icon = MonoImage::new(
+                center - (temp_width / 2) as i32,
+                top + 48,
+                &THERMOMETER_36,
+                Black,
+            );
+            let mut temperature = Text::new(
+                center + (temp_width - temp_width / 2) as i32,
+                top + 48,
+                data.temperature(),
+                &ROBOTO_30,
+                Black,
+            );
+            temperature.align(TextAlignment::Right);
+            let hum_width = ROBOTO_30.get_text_size(data.humidity()).0 + 1 + THERMOMETER_36.width();
+            let hum_icon = MonoImage::new(
+                center - (hum_width / 2) as i32,
+                top + 82,
+                &WATER_PERCENT_36,
+                Black,
+            );
+            let mut humidity = Text::new(
+                center + (hum_width - hum_width / 2) as i32,
+                top + 82,
+                data.humidity(),
+                &ROBOTO_30,
+                Black,
+            );
+            humidity.align(TextAlignment::Right);
+
+            tile.data = Some((temp_icon, temperature, hum_icon, humidity));
+        } else {
+            tile.error = Some(MonoImage::new(
+                center - (WIFI_STRENGTH_ALERT_36.width() / 2) as i32,
+                top + height / 2 - (WIFI_STRENGTH_ALERT_36.height() / 2) as i32,
+                &WIFI_STRENGTH_ALERT_36,
+                Black,
+            ));
+        }
+
+        tile
+    }
+
+    fn draw(&self, clip: Clip, renderer: &mut Renderer<BlackWhite>) {
+        self.title.draw(clip, renderer);
+        if let Some(data) = self.data.as_ref() {
+            data.0.draw(clip, renderer);
+            data.1.draw(clip, renderer);
+            data.2.draw(clip, renderer);
+            data.3.draw(clip, renderer);
+        }
+        if let Some(error) = self.error.as_ref() {
+            error.draw(clip, renderer);
+        }
+    }
+}
+
+struct PressureString {
+    buffer: [u8; 9],
+    length: usize,
+}
+
+impl PressureString {
+    fn new(pressure: u32) -> PressureString {
+        let mut x = pressure;
+        let mut length = 0;
+        let mut buffer = [0u8; 9];
+        let mut cursor = &mut buffer[..];
+        // Round to one decimal place.
+        x = (x + 5) / 10;
+        x = u32::min(x, 99999);
+        if pressure >= 10000 {
+            cursor[0] = '0' as u8 + (x / 10000) as u8;
+            cursor = &mut cursor[1..];
+            x %= 10000;
+            length += 1;
+        }
+        if pressure >= 1000 {
+            cursor[0] = '0' as u8 + (x / 1000) as u8;
+            cursor = &mut cursor[1..];
+            x %= 1000;
+            length += 1;
+        }
+        if pressure >= 100 {
+            cursor[0] = '0' as u8 + (x / 100) as u8;
+            cursor = &mut cursor[1..];
+            x %= 100;
+            length += 1;
+        }
+        cursor[0] = '0' as u8 + (x / 10) as u8;
+        cursor[1] = ',' as u8;
+        cursor[2] = '0' as u8 + (x % 10) as u8;
+        cursor[3] = 'h' as u8;
+        cursor[4] = 'P' as u8;
+        cursor[5] = 'a' as u8;
+        length += 6;
+        PressureString { buffer, length }
+    }
+
+    fn to_str<'a>(&'a self) -> &'a str {
+        unsafe {
+            // Safe, we did not use any non-UTF characters above.
+            core::str::from_utf8_unchecked(&self.buffer[0..self.length])
+        }
+    }
+}
+
+struct PressureTile<'a> {
+    title: Text<'a, BlackWhite>,
+    data: Option<Text<'a, BlackWhite>>,
+    error: Option<MonoImage<'static, MonoBitmapImage, BlackWhite>>,
+}
+
+impl<'a> PressureTile<'a> {
+    fn new(data: Option<&'a PressureString>, left: i32, top: i32, width: i32, height: i32) -> Self {
+        let center = left + width / 2;
+
+        let mut title = Text::new(center, top + 10, "Luftdruck", &ROBOTO_30, Black);
+        title.align(TextAlignment::Center);
+
+        let mut tile = Self {
+            title,
+            data: None,
+            error: None,
+        };
+
+        if let Some(data) = data {
+            let mut pressure = Text::new(center, top + 48, data.to_str(), &ROBOTO_30, Black);
+            pressure.align(TextAlignment::Center);
+
+            tile.data = Some(pressure);
+        } else {
+            tile.error = Some(MonoImage::new(
+                center - (WIFI_STRENGTH_ALERT_36.width() / 2) as i32,
+                top + height / 2 - (WIFI_STRENGTH_ALERT_36.height() / 2) as i32,
+                &WIFI_STRENGTH_ALERT_36,
+                Black,
+            ));
+        }
+
+        tile
+    }
+
+    fn draw(&self, clip: Clip, renderer: &mut Renderer<BlackWhite>) {
+        self.title.draw(clip, renderer);
+        if let Some(data) = self.data.as_ref() {
+            data.draw(clip, renderer);
+        }
+        if let Some(error) = self.error.as_ref() {
+            error.draw(clip, renderer);
+        }
+    }
+}
+
 struct TinyGfxStream<Draw> {
     frame: Frame<Draw, BlackWhite>,
     buffer: [u8; 400 / 8],

display/firmware/src/information.rs

@@ -3,5 +3,16 @@
 pub struct Information {
     pub time: u32,
     pub valid: bool,
-    // TODO
+
+    pub inside: Option<TemperatureHumidity>,
+    pub outside: Option<TemperatureHumidity>,
+    pub bathroom: Option<TemperatureHumidity>,
+
+    pub pressure: Option<u32>,
+}
+
+#[derive(Copy, Clone)]
+pub struct TemperatureHumidity {
+    pub temperature: i32,
+    pub humidity: u32,
 }

display/firmware/src/main.rs

@@ -16,7 +16,7 @@ use mkl25z4_hal::time::{CopyableMonoTimer, NonCopyableMonoTimer, U32Ext};
 use panic_semihosting as _;
 
 use display::{Display, DisplayState};
-use information::Information;
+use information::{Information, TemperatureHumidity};
 use pins::DisplayBmeSpi;
 
 #[rtfm::app(device = mkl25z4_hal::mkl25z4, peripherals = true)]
@@ -63,6 +63,10 @@ const APP: () = {
             info: Information {
                 time: 0,
                 valid: false,
+                inside: None,
+                outside: None,
+                bathroom: None,
+                pressure: None,
             },
             display_state: DisplayState{
                 // TODO
@@ -88,7 +92,7 @@ const APP: () = {
     }
 
     #[task(priority = 1, spawn = [update_display], resources = [info])]
-    fn fetch_update(ctx: fetch_update::Context) {
+    fn fetch_update(mut ctx: fetch_update::Context) {
         // Fetch local updates.
         // TODO
 
@@ -98,6 +102,13 @@ const APP: () = {
 
         // Fetch updates via radio.
         // TODO
+        ctx.resources.info.lock(|info| {
+            info.inside = Some(TemperatureHumidity {
+                temperature: -212,
+                humidity: 345,
+            });
+            info.pressure = Some(100000);
+        });
 
         // If the update failed, simply increment the time and place a hint that
         // the information might be invalid.