minor component fixes

Cargo.lock

@@ -363,6 +363,7 @@ dependencies = [
  "embedded-hal-bus",
  "embedded-io 0.7.1",
  "embedded-storage",
+ "embedded-text",
  "esp-alloc",
  "esp-bootloader-esp-idf",
  "esp-hal",
@@ -1049,6 +1050,17 @@ dependencies = [
  "embedded-storage",
 ]
 
+[[package]]
+name = "embedded-text"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cf5c72c52db2f7dbe4a9c1ed81cd21301e8d66311b194fa41c04fb4f71843ba"
+dependencies = [
+ "az",
+ "embedded-graphics",
+ "object-chain",
+]
+
 [[package]]
 name = "enumset"
 version = "1.1.14"
@@ -2130,6 +2142,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "object-chain"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41af26158b0f5530f7b79955006c2727cd23d0d8e7c3109dc316db0a919784dd"
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"

Cargo.toml

@@ -54,6 +54,7 @@ esp-storage = "0.9.0"
 embedded-storage = "0.3.1"
 binary_serde = "1.0.25"
 static_assertions = { version = "1.1.0", default-features = false }
+embedded-text = "0.7.3"
 
 [build-dependencies]
 log = "0.4.27"

model/common.scad

@@ -1,45 +1,266 @@
+include <BOSL2/std.scad>
+
 BASE_MODEL_SCALE = [1.1, 1, 1.1];
 BASE_MODEL_TRANSLATE = [-0.4, 0, 16.978];
+EPS = 0.01;
+$fn = 50;
 
-module main_display(){
+module pin_header(cols = 4, rows = 1, anchor = BOTTOM, spin = 0, orient = UP) {
-    // Outer dimensions, height currently unknown
+  // Standard pin header dimensions (in mm)
-    cube([55.04, 89.3, 10]);
+  base_height = 2.54; // Height of the plastic base
+  pin_width = 0.64; // Width/thickness of the square pin
+  pin_length = 6.0; // Length of pin sticking up
+  pitch = 2.54;
+
+  // 1. The Plastic Base is the Parent
+  // It directly receives your anchor, spin, and orient arguments.
+  color("darkgrey")
+    cuboid([cols * pitch, rows * pitch, base_height], anchor=anchor, spin=spin, orient=orient) {
+
+      // 2. Metal Pins are the Children
+      // Placed relative to the center of the plastic base
+      color("silver")
+        xcopies(spacing=pitch, n=cols) {
+          ycopies(spacing=pitch, n=rows) {
+            up(base_height / 2)
+              cuboid([pin_width, pin_width, pin_length], anchor=BOTTOM);
+          }
+        }
+
+      // Allows attaching other objects to this header if needed
+      children();
+    }
 }
 
-module pad(){
+module main_display(pin_header = false) {
-    // A button has 4.2 x 6 mm -> At least ~20x20 are required for the PCB
+  // Outer dimensions
-    cube([20, 20, 10]);
+  width = 55.04;
+  length = 89.35;
+  height = 2.7;
+
+  display_height = 3;
+  display_length = 77.6;
+  display_inset = 5.7;
+
+  sd_width = 26.6;
+  sd_height = 3;
+  sd_length = 16.6;
+  sd_inset = 29.4;
+
+  hole_diameter = 3;
+  hole_inset = 1.5;
+
+  difference() {
+    cuboid([length, width, height]) {
+      position(TOP + RIGHT)
+        left(display_inset)
+          color("black")
+            cuboid([display_length, width, display_height], anchor=BOTTOM + RIGHT);
+
+      position(BOTTOM + RIGHT + FRONT)
+        left(sd_inset)
+          cuboid([sd_width, sd_length, sd_height], anchor=TOP + RIGHT + FRONT);
+
+      position(BOTTOM + LEFT)
+        xrot(180)
+          pin_header(14, spin=90, anchor=BOTTOM + BACK);
+    }
+
+    xcopies(length - (2 * hole_inset) - hole_diameter) {
+      ycopies(width - (2 * hole_inset) - hole_diameter) {
+        zcyl(d=hole_diameter, h=height + EPS);
+      }
+    }
+  }
 }
 
-module small_display_below_main()
+module pad() {
-{
+  // A button has 4.2 x 6 mm -> At least ~20x20 are required for the PCB
-    // https://de.aliexpress.com/item/1005003753680706.html
+  cube([20, 20, 10]);
-    cube([45.8, 20, 11.3]);
-    // old i2c variant:
-    //cube([43.5, 19.44, 4.5]);
-
-    // initial dimension ideas
-    // cube([38,16,4]);
-    // translate([150,0,0]) cube([22,5.5,4]);
 }
 
-module tertiary_display()
+module secondary_display(pin_header = false) {
-{
+  // https://de.aliexpress.com/item/1005003753680706.html
-    // https://de.aliexpress.com/item/1005006034531826.html
+  length = 45.8;
-    cube([80, 36, 10]);
+  width = 20;
+  height = 3.7;
+
+  hole_diameter = 2;
+  hole_inset = 1.5;
+
+  difference() {
+    cuboid([length, width, height]) {
+      if (pin_header)
+        position(LEFT + TOP)
+          pin_header(7, spin=90, anchor=BACK + BOTTOM);
+    }
+
+    right(length / 2 - hole_inset) {
+      ycopies(width - (2 * hole_inset) - hole_diameter) {
+        zcyl(d=hole_diameter, h=height + EPS, anchor=RIGHT);
+      }
+    }
+  }
 }
 
-module battery() {
+module battery(anchor = BOTTOM) {
-    // 18650
+  // 18650
-    rotate([0,90,0]) cylinder(d=18, h=65);
+  rotate([0, 90, 0]) cylinder(d=18, h=65, anchor=anchor);
 }
 
-module microcontroller() {
+/// USB-C port and switch not 100% dimensionally accurate, take care!
-    // width 32 including USB-C port
+module micro_controller(battery_holder = false, battery = false) {
-    length = 91.5;
+  pcb_length = 91.5;
-    height = 20;
+  pcb_height = 6.5; // including components, highest point: jst connector, followed by uC
-    battery_length = 65;
+  pcb_height_no_components = 1.1;
-    delta = length - battery_length;
+  pcb_width = 28.8;
-    cube([length, 32, height]);
+
-    translate([delta / 2,16, 15]) battery();
+  hole_diameter = 2.5;
+  hole_inset = 1;
+  usb_protrusion = 1.7;
+  usb_width = 9;
+  usb_inset_from_pcb_end = 5;
+  power_switch_protrusion = 2.1;
+  power_switch_inset_from_pcb_end = 8.1;
+  power_switch_width = 4;
+
+  battery_holder_height = 15;
+  battery_holder_width = 21;
+  battery_holder_length = 77.3;
+
+  battery_length = 65;
+  battery_protrusion = 4.5;
+
+  difference() {
+    cuboid([pcb_length, pcb_width, pcb_height], rounding=2, edges="Z") {
+      if (battery_holder)
+        position(TOP)
+          cube([battery_holder_length, battery_holder_width, battery_holder_height], anchor=BOTTOM + CENTER) {
+            if (battery)
+              position(TOP)
+                up(battery_protrusion)
+                  battery(anchor=CENTER + LEFT);
+          }
+      position(RIGHT + BOTTOM) {
+        position(FRONT)
+          left(usb_inset_from_pcb_end)
+            cube([usb_width, usb_protrusion, pcb_height - pcb_height_no_components], orient=FRONT, anchor=RIGHT + BOTTOM + FRONT);
+        position(BACK)
+          left(power_switch_inset_from_pcb_end)
+            cube([power_switch_width, power_switch_protrusion, pcb_height - pcb_height_no_components], orient=FRONT, anchor=RIGHT + TOP + FRONT);
+      }
+    }
+
+    xcopies(pcb_length - (2 * hole_inset) - hole_diameter) {
+      ycopies(pcb_width - (2 * hole_inset) - hole_diameter) {
+        cyl(d=hole_diameter, h=pcb_height + EPS, orient=UP);
+      }
+    }
+  }
+}
+
+module nfc(pin_header = true) {
+  length = 43;
+  width = 40.5;
+  height = 4;
+
+  pin_protrusion = 2.2;
+
+  hole_diameter = 3;
+  hole_inset = 6;
+
+  x_span = length - (2 * hole_inset) - hole_diameter;
+  y_span = width - (2 * hole_inset) - hole_diameter;
+
+  color("red")
+    difference() {
+      cuboid([length, width, height], rounding=2, edges="Z") {
+        // pin header is lower than highest other component -> in the cube.
+        if (pin_header)
+          right(6 - pin_protrusion) // ugly: 6mm is the pin height
+            position(LEFT + TOP)
+              yrot(-90)
+                pin_header(7, spin=90, anchor=FRONT + TOP);
+      }
+
+      move_copies(
+        [
+          [x_span / 2, -y_span / 2], // Bottom-Left corner
+          [-x_span / 2, y_span / 2], // Top-Right corner
+        ]
+      ) {
+        zcyl(d=hole_diameter, h=height + EPS);
+      }
+    }
+}
+
+module tertiary_display(pin_headers = true) {
+  // https://de.aliexpress.com/item/1005006034531826.html
+
+  pcb_length = 81;
+  pcb_width = 36.1;
+  pcb_height = 3.7;
+
+  hole_diameter = 2.8;
+  hole_inset = 1;
+
+  display_length = 71.2;
+  display_width = 24.4;
+  display_height = 7;
+
+  piggy_length = 41.8;
+  piggy_width = 19.1;
+  piggy_height = 8.5 - 2.6;
+  piggy_inset = 6.2;
+
+  jumper_protrusion = 6.6;
+  pin_protrusion = 6.2;
+
+  color("green")
+    difference() {
+      cuboid([pcb_length, pcb_width, pcb_height]) {
+        position(TOP)
+          cuboid([display_length, display_width, display_height], anchor=BOTTOM);
+      }
+
+      xcopies(pcb_length - (2 * hole_inset) - hole_diameter) {
+        ycopies(pcb_width - (2 * hole_inset) - hole_diameter) {
+          zcyl(d=hole_diameter, h=pcb_height + 1);
+        }
+      }
+    }
+
+  // Replaces position(BOTTOM + BACK + LEFT) so that difference cannot mess with color.
+  translate([-pcb_length / 2 + piggy_inset, pcb_width / 2, -pcb_height / 2]) {
+    color("black")
+      cuboid([piggy_length, piggy_width, piggy_height], anchor=TOP + BACK + LEFT);
+
+    if (pin_headers) {
+      // Replaces position(LEFT + BOTTOM) so that parent child cannot mess with color.
+      translate([0, -piggy_width / 2, -piggy_height])
+        right(6 - pin_protrusion)
+          yrot(-90)
+            pin_header(4, spin=90, anchor=BACK + TOP);
+
+      // Replaces position(RIGHT + BOTTOM) so that parent child cannot mess with color.
+      translate([piggy_length, -piggy_width / 2, -piggy_height])
+        left(6 - pin_protrusion)
+          yrot(90)
+            back(1.6)
+              pin_header(2, spin=-90, anchor=BACK + TOP);
+
+      // Replaces position(BACK + TOP) so that parent child cannot mess with color.
+      translate([piggy_length / 2, -EPS, 0])
+        pin_header(16, anchor=BACK + TOP);
+    }
+  }
+}
+
+// show different components as overview
+if (false) {
+  back(30) tertiary_display(true);
+  back(80) yrot(180) secondary_display(true);
+  right(100) zrot(90) main_display(true);
+  fwd(20) micro_controller(true, true);
+  fwd(60) nfc(true);
 }

src/background_tasks/nfc.rs

@@ -1,6 +1,5 @@
-use crate::storage::cardstore::CardStore;
+use crate::peripherals::Peripherals;
 use embedded_hal_bus::i2c::AtomicDevice;
-use esp_hal::rtc_cntl::Rtc;
 use esp_hal::{Blocking, i2c::master::I2c, time::Instant};
 
 use crate::{
@@ -16,8 +15,7 @@ use crate::{
 )]
 pub async fn nfc_scanner(
     mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>,
-    mut card_store: CardStore,
+    peripherals: &'static Peripherals,
-    rtc: Rtc<'static>,
 ) {
     loop {
         while CARD_DATA.lock().await.is_none() {
@@ -37,7 +35,14 @@ pub async fn nfc_scanner(
                     };
                     CARD_DATA.lock().await.replace(card);
 
-                    match card_store.save_raw_card(split_data, rtc.current_time_us()) {
+                    match peripherals
+                        .store
+                        .lock()
+                        .await
+                        .card_store
+                        .save_raw_card(split_data, peripherals.rtc.current_time_us())
+                        .await
+                    {
                         Ok(()) => {}
                         Err(error) => {
                             log::error!("Error storing card in flash: {:?}", error)

src/bin/main.rs

@@ -7,6 +7,7 @@
 )]
 #![deny(clippy::large_stack_frames)]
 
+use alloc::boxed::Box;
 use creaturedex::background_tasks;
 use creaturedex::drivers::i2c_bus::I2cBusPinConfiguration;
 use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
@@ -15,11 +16,14 @@ use creaturedex::drivers::spi_bus;
 use creaturedex::drivers::tertiary_lcd::{
     BOX, EMPTY, EXAMPLE, HEART, TertiaryDisplay, TertiaryDisplayPinConfiguration,
 };
+use creaturedex::navigation::navigation::Mutex;
 use creaturedex::navigation::inputs::Inputs;
 use creaturedex::navigation::navigation::{self};
 use creaturedex::navigation::outputs::Outputs;
-use creaturedex::storage::cardstore::CardStore;
+use creaturedex::peripherals::Peripherals;
-use creaturedex::storage::store::Store;
+use creaturedex::peripherals::storage::cardstore::CardStore;
+use creaturedex::peripherals::storage::flash_store::FlashStore;
+use creaturedex::peripherals::storage::store::Store;
 use embassy_executor::Spawner;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::{
@@ -58,41 +62,44 @@ async fn main(spawner: Spawner) {
     creaturedex::logging::init();
 
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
-    let peripherals = esp_hal::init(config);
+    let esp_peripherals = esp_hal::init(config);
 
     esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: HEAP_SIZE);
 
     let sw_interrupt =
-        esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
+        esp_hal::interrupt::software::SoftwareInterruptControl::new(esp_peripherals.SW_INTERRUPT);
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
+    let timg0 = TimerGroup::new(esp_peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
 
     let (primary, mut secondaries) = retry(
         5,
         spi_bus::DisplayPinConfiguration {
-            spi_peripheral: peripherals.SPI2,
+            spi_peripheral: esp_peripherals.SPI2,
-            sck: peripherals.GPIO36,
+            sck: esp_peripherals.GPIO36,
-            mosi: peripherals.GPIO35,
+            mosi: esp_peripherals.GPIO35,
-            miso: peripherals.GPIO37,
+            miso: esp_peripherals.GPIO37,
-            cs_primary: peripherals.GPIO11,
+            cs_primary: esp_peripherals.GPIO11,
-            cs_secondary_1: peripherals.GPIO13,
+            cs_secondary_1: esp_peripherals.GPIO13,
-            cs_secondary_2: peripherals.GPIO14,
+            cs_secondary_2: esp_peripherals.GPIO14,
-            cs_secondary_3: peripherals.GPIO21,
+            cs_secondary_3: esp_peripherals.GPIO21,
-            reset_primary: peripherals.GPIO10,
+            reset_primary: esp_peripherals.GPIO10,
-            reset_secondary: peripherals.GPIO47,
+            reset_secondary: esp_peripherals.GPIO47,
-            dc_pin: peripherals.GPIO12,
+            dc_pin: esp_peripherals.GPIO12,
         },
         spi_bus::DisplayPinConfiguration::build,
     );
 
     // Initialize the shared I2C bus using the refactored i2c_bus module.
     let shared_i2c = {
-        use alloc::boxed::Box;
+        let bus = retry(
-        let bus = retry(5, I2cBusPinConfiguration {
+            5,
-            i2c_peripheral: peripherals.I2C0,
+            I2cBusPinConfiguration {
-            scl: peripherals.GPIO18,
+                i2c_peripheral: esp_peripherals.I2C0,
-            sda: peripherals.GPIO17,
+                scl: esp_peripherals.GPIO18,
-        }, I2cBusPinConfiguration::build);
+                sda: esp_peripherals.GPIO17,
+            },
+            I2cBusPinConfiguration::build,
+        );
         Box::leak(Box::new(bus))
     };
 
@@ -113,12 +120,26 @@ async fn main(spawner: Spawner) {
         );
     }
 
-    let store = Store::new(peripherals.FLASH).expect("Could not initialize Flash Store");
+    let flash_store = Box::leak(Box::new(
-    let cardstore = CardStore::new(store).expect("Could not initialize Card Store");
+        FlashStore::new(esp_peripherals.FLASH).expect("Could not initialize Flash Store"),
+    ));
 
-    let rtc = Rtc::new(peripherals.LPWR);
+    let card_store = CardStore::new(flash_store)
+        .await
+        .expect("Could not initialize Card Store");
+
+    let store = Store {
+        flash_store,
+        card_store,
+    };
+    let rtc = Rtc::new(esp_peripherals.LPWR);
     //setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
 
+    let peripherals = Box::leak(Box::new(Peripherals {
+        store: Mutex::new(store),
+        rtc,
+    }));
+
     let mut nfc_driver = NfcPn532Driver::new(AtomicDevice::new(shared_i2c));
     if nfc_driver.configure_sam().await.is_ok() {
         log::info!("NFC SAM configuration successful on the shared I2C bus");
@@ -128,12 +149,12 @@ async fn main(spawner: Spawner) {
 
     let button_config = InputConfig::default().with_pull(Pull::Up);
     let inputs = Inputs {
-        up: Input::new(peripherals.GPIO38, button_config),
+        up: Input::new(esp_peripherals.GPIO38, button_config),
-        down: Input::new(peripherals.GPIO39, button_config),
+        down: Input::new(esp_peripherals.GPIO39, button_config),
-        left: Input::new(peripherals.GPIO40, button_config),
+        left: Input::new(esp_peripherals.GPIO40, button_config),
-        right: Input::new(peripherals.GPIO41, button_config),
+        right: Input::new(esp_peripherals.GPIO41, button_config),
-        back: Input::new(peripherals.GPIO8, button_config),
+        back: Input::new(esp_peripherals.GPIO8, button_config),
-        ok: Input::new(peripherals.GPIO0, button_config),
+        ok: Input::new(esp_peripherals.GPIO0, button_config),
     };
 
     display_shit(&mut secondaries[0], "foo 1");
@@ -153,9 +174,9 @@ async fn main(spawner: Spawner) {
     };
 
     log::info!("Setup complete, entering main loop");
-    spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
+    spawner.spawn(navigation::run(inputs, outputs, peripherals).expect("run task failed"));
     spawner.spawn(
-        background_tasks::nfc_scanner(nfc_driver, cardstore, rtc).expect("nfc scanner task failed"),
+        background_tasks::nfc_scanner(nfc_driver, peripherals).expect("nfc scanner task failed"),
     );
     core::future::pending::<()>().await
 }

src/drivers/primary_lcd.rs

@@ -1,3 +1,6 @@
+use core::error::Error;
+use core::fmt::Debug;
+use core::fmt::Display;
 use display_interface_spi::SPIInterface;
 use embedded_graphics::draw_target::DrawTarget;
 use embedded_graphics::pixelcolor::Rgb565;
@@ -6,10 +9,27 @@ use embedded_hal_bus::spi::AtomicDevice;
 use embedded_hal_bus::util::AtomicCell;
 use esp_hal::delay::Delay;
 use esp_hal::gpio::Output;
-use ili9341::{DisplaySize240x320, Ili9341, Orientation};
+use ili9341::{DisplayError, DisplaySize240x320, Ili9341, Orientation};
 
 use crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput};
 
+#[derive(Debug)]
+pub struct PrimaryDisplayError(DisplayError);
+
+impl Display for PrimaryDisplayError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl Error for PrimaryDisplayError {}
+
+impl From<DisplayError> for PrimaryDisplayError {
+    fn from(value: DisplayError) -> Self {
+        Self(value)
+    }
+}
+
 type GenericPrimaryDisplay<'a, BUS, DC, RES> =
     Ili9341<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RES>;
 pub type PrimaryDisplay<'a> =

src/lib.rs

@@ -10,5 +10,5 @@ pub mod drivers;
 pub mod logging;
 pub mod navigation;
 pub mod network;
-pub mod storage;
+pub mod peripherals;
 pub mod views;

src/navigation/navigation.rs

@@ -1,9 +1,15 @@
+use crate::alloc::string::ToString;
 use crate::card::model::Card;
 use crate::navigation::inputs::ButtonAction;
 use crate::navigation::inputs::Inputs;
 use crate::navigation::outputs::Outputs;
 use crate::navigation::state::NavigationState;
+use crate::peripherals::Peripherals;
+use crate::views::error_view::ErrorView;
 use crate::views::view::View;
+use alloc::boxed::Box;
+use alloc::string::String;
+use core::error;
 
 use embassy_futures::select::{Either, select};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
@@ -27,16 +33,49 @@ pub struct NewState {
 }
 
 pub trait Navigable {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send;
+    fn display(
+        &self,
+        outputs: &mut Outputs,
+        peripherals: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send;
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send;
 }
 
 #[embassy_executor::task]
-pub async fn run(mut inputs: Inputs, mut outputs: Outputs) {
+pub async fn run(mut inputs: Inputs, mut outputs: Outputs, peripherals: &'static Peripherals) {
+    async fn display_error(
+        error: String,
+        state: &mut NavigationState,
+        outputs: &mut Outputs,
+        peripherals: &Peripherals,
+    ) -> () {
+        let error_view = ErrorView {
+            error: error.to_string(),
+        };
+        state.screens.push(View::Error(error_view));
+        state
+            .screens
+            .last()
+            // Unwrap: we just pushed the state
+            .unwrap()
+            .display(outputs, peripherals)
+            .await
+            // Unwrap: display will panic on error in error view
+            .unwrap();
+    }
+
     log::info!("starting navigation");
 
     let mut state = NavigationState::new();
-    state.screens.last().unwrap().display(&mut outputs).await;
+    if let Err(error) = state
+        .screens
+        .last()
+        .unwrap()
+        .display(&mut outputs, peripherals)
+        .await
+    {
+        display_error(error.to_string(), &mut state, &mut outputs, &peripherals).await;
+    };
 
     loop {
         let selection = select(
@@ -82,7 +121,15 @@ pub async fn run(mut inputs: Inputs, mut outputs: Outputs) {
         state.screens.push(new_state.view);
 
         if action != Action::Timer || new_state.redraw {
-            state.screens.last().unwrap().display(&mut outputs).await;
+            if let Err(error) = state
+                .screens
+                .last()
+                .unwrap()
+                .display(&mut outputs, peripherals)
+                .await
+            {
+                display_error(error.to_string(), &mut state, &mut outputs, &peripherals).await;
+            }
         }
 
         Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)).await;

src/peripherals.rs

@@ -0,0 +1,11 @@
+pub mod storage;
+
+use crate::navigation::navigation::Mutex;
+use crate::peripherals::storage::store::Store;
+
+use esp_hal::rtc_cntl::Rtc;
+
+pub struct Peripherals {
+    pub store: Mutex<Store>,
+    pub rtc: Rtc<'static>,
+}

src/peripherals/storage.rs

@@ -1,6 +1,6 @@
 pub struct MemoryRegion {
-    offset: u32,
+    pub offset: u32,
-    size: usize,
+    pub size: usize,
 }
 
 impl MemoryRegion {
@@ -15,17 +15,18 @@ impl MemoryRegion {
     }
 }
 
-const MAX_FLASH: usize = 16 * 1024 * 1024;
+pub const MAX_FLASH: usize = 16 * 1024 * 1024;
 
-const MAGIC_REGION: MemoryRegion = MemoryRegion::new(0, 4);
+pub const MAGIC_REGION: MemoryRegion = MemoryRegion::new(0, 4);
 
-const SETTINGS_REGION: MemoryRegion = MemoryRegion::new(MAGIC_REGION.end() as u32, 1024);
+pub const SETTINGS_REGION: MemoryRegion = MemoryRegion::new(MAGIC_REGION.end() as u32, 1024);
 
-const CARDSTORE_REGION: MemoryRegion = MemoryRegion::new(
+pub const CARDSTORE_REGION: MemoryRegion = MemoryRegion::new(
     SETTINGS_REGION.end() as u32,
     MAX_FLASH - SETTINGS_REGION.end(),
 );
 
 pub mod cardstore;
+pub mod flash_store;
 pub mod settings;
 pub mod store;

src/peripherals/storage/cardstore.rs

@@ -1,14 +1,16 @@
 use alloc::collections::BTreeMap;
 use alloc::vec::Vec;
+use core::error::Error;
+use core::fmt::Display;
 
 use binary_serde::{BinarySerde, DeserializeError, Endianness};
 
 //use crate::card::model::Nfcraw_card;
 
 use crate::card::model::RawCard;
-use crate::storage::store::{Store, StoreError};
+use crate::peripherals::storage::flash_store::{FlashStore, FlashStoreError};
 
-use crate::storage::{CARDSTORE_REGION, MemoryRegion};
+use crate::peripherals::storage::{CARDSTORE_REGION, MemoryRegion};
 
 const MAX_CARDS: usize = 20000;
 
@@ -65,13 +67,25 @@ impl AllocationTableEntry {
 
 #[derive(Debug)]
 pub enum CardStoreError {
-    Store(StoreError),
+    Store(FlashStoreError),
     CorruptedEntry(DeserializeError),
-    NoEntry,
+    NoEntry(u32),
 }
 
-impl From<StoreError> for CardStoreError {
+impl Error for CardStoreError {}
-    fn from(error: StoreError) -> CardStoreError {
+
+impl Display for CardStoreError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            CardStoreError::Store(e) => e.fmt(f),
+            CardStoreError::CorruptedEntry(e) => e.fmt(f),
+            CardStoreError::NoEntry(uuid) => write!(f, "No Card Entry\nuuid: 0x{uuid:x}"),
+        }
+    }
+}
+
+impl From<FlashStoreError> for CardStoreError {
+    fn from(error: FlashStoreError) -> CardStoreError {
         CardStoreError::Store(error)
     }
 }
@@ -83,16 +97,16 @@ impl From<DeserializeError> for CardStoreError {
 }
 
 pub struct CardStore {
-    store: Store,
+    store: &'static FlashStore,
     count: u32,
     pub allocation_table: BTreeMap<u32, AllocationTableEntry>,
 }
 
 impl CardStore {
-    pub fn new(mut store: Store) -> Result<Self, CardStoreError> {
+    pub async fn new(store: &'static FlashStore) -> Result<Self, CardStoreError> {
         let mut count_bytes: [u8; COUNT_REGION.size] = [0; COUNT_REGION.size];
 
-        store.read(COUNT_REGION.offset, &mut count_bytes)?;
+        store.read(COUNT_REGION.offset, &mut count_bytes).await?;
 
         let count: u32 = u32::from_ne_bytes(count_bytes);
 
@@ -101,10 +115,12 @@ impl CardStore {
         let mut allocation_table_entries: Vec<u8> =
             Vec::with_capacity(AllocationTableEntry::SERIALIZED_SIZE * count as usize);
 
-        store.read(
+        store
-            ALLOCATION_TABLE_REGION.offset,
+            .read(
-            &mut allocation_table_entries,
+                ALLOCATION_TABLE_REGION.offset,
-        )?;
+                &mut allocation_table_entries,
+            )
+            .await?;
 
         let chunks =
             allocation_table_entries.into_chunks::<{ AllocationTableEntry::SERIALIZED_SIZE }>();
@@ -123,14 +139,14 @@ impl CardStore {
         })
     }
 
-    pub fn get_card_by_uuid(&mut self, uuid: u32) -> Result<RawCard, CardStoreError> {
+    pub async fn get_card_by_uuid(&self, uuid: u32) -> Result<RawCard, CardStoreError> {
         let entry = self
             .allocation_table
             .get(&uuid)
-            .ok_or(CardStoreError::NoEntry)?;
+            .ok_or(CardStoreError::NoEntry(uuid))?;
 
         let mut raw_card: [u8; size_of::<RawCard>()] = [0; size_of::<RawCard>()];
-        self.store.read(entry.offset, &mut raw_card)?;
+        self.store.read(entry.offset, &mut raw_card).await?;
 
         Ok(RawCard::binary_deserialize(
             raw_card.as_ref(),
@@ -138,7 +154,7 @@ impl CardStore {
         )?)
     }
 
-    pub fn save_raw_card(
+    pub async fn save_raw_card(
         &mut self,
         raw_card: RawCard,
         timestamp: u64,
@@ -183,10 +199,12 @@ impl CardStore {
             log::debug!("writing RawCard to flash");
             let mut serialized_card: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE];
             raw_card.binary_serialize(&mut serialized_card, Endianness::Little);
-            self.store.write_erase(
+            self.store
-                CARDS_REGION.offset + entry.offset * RawCard::SERIALIZED_SIZE as u32,
+                .write_erase(
-                &mut serialized_card,
+                    CARDS_REGION.offset + entry.offset * RawCard::SERIALIZED_SIZE as u32,
-            )?;
+                    &mut serialized_card,
+                )
+                .await?;
         } else {
             entry.last_read_date = timestamp;
             entry.read_count += 1;
@@ -198,17 +216,20 @@ impl CardStore {
         let mut serialized_entry: [u8; AllocationTableEntry::SERIALIZED_SIZE] =
             [0; AllocationTableEntry::SERIALIZED_SIZE];
         entry.binary_serialize(&mut serialized_entry, Endianness::Little);
-        self.store.write_erase(
+        self.store
-            ALLOCATION_TABLE_REGION.offset
+            .write_erase(
-                + entry.offset * AllocationTableEntry::SERIALIZED_SIZE as u32,
+                ALLOCATION_TABLE_REGION.offset
-            &mut serialized_entry,
+                    + entry.offset * AllocationTableEntry::SERIALIZED_SIZE as u32,
-        )?;
+                &mut serialized_entry,
+            )
+            .await?;
 
         self.count += 1;
         log::debug!("writing card count to flash");
         let mut serialized_count: [u8; 4] = self.count.to_le_bytes();
         self.store
-            .write(COUNT_REGION.offset, serialized_count.as_mut_slice())?;
+            .write(COUNT_REGION.offset, serialized_count.as_mut_slice())
+            .await?;
         Ok(())
     }
 }

src/peripherals/storage/flash_store.rs

@@ -1,22 +1,42 @@
+use core::error::Error;
+use core::fmt::Display;
+
+use crate::navigation::navigation::Mutex;
 use embedded_storage::nor_flash::NorFlash;
 use embedded_storage::nor_flash::ReadNorFlash;
 use esp_storage::{FlashStorage, FlashStorageError};
 
-use crate::storage::MAGIC_REGION;
+use crate::peripherals::storage::MAGIC_REGION;
 
-pub type StoreError = FlashStorageError;
+#[derive(Debug)]
+pub struct FlashStoreError(FlashStorageError);
+
+impl From<FlashStorageError> for FlashStoreError {
+    fn from(value: FlashStorageError) -> Self {
+        Self(value)
+    }
+}
+
+impl Error for FlashStoreError {}
+
+impl Display for FlashStoreError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use core::fmt::Debug;
+        self.0.fmt(f)
+    }
+}
 
 const FLASH_ADDR: u32 = 0x9000;
 
 const INITIALIZATION_SIZE: usize = 0x1000;
 const FLASH_INITIALIZE_MAGIC: u32 = 0xde6de6de;
 
-pub struct Store {
+pub struct FlashStore {
-    pub storage: FlashStorage<'static>,
+    pub storage: Mutex<FlashStorage<'static>>,
 }
 
-impl Store {
+impl FlashStore {
-    pub fn new(flash: esp_hal::peripherals::FLASH<'static>) -> Result<Self, StoreError> {
+    pub fn new(flash: esp_hal::peripherals::FLASH<'static>) -> Result<Self, FlashStoreError> {
         let mut storage = FlashStorage::new(flash);
 
         let mut magic: [u8; 4] = [0, 0, 0, 0];
@@ -30,29 +50,37 @@ impl Store {
             Self::initialize_flash(&mut storage)?;
         }
 
-        Ok(Self { storage })
+        Ok(Self {
+            storage: Mutex::new(storage),
+        })
     }
 
-    pub fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
+    pub async fn read(&self, offset: u32, bytes: &mut [u8]) -> Result<(), FlashStoreError> {
-        self.storage.read(FLASH_ADDR + offset, bytes)
+        self.storage.lock().await.read(FLASH_ADDR + offset, bytes)?;
+        Ok(())
     }
 
-    pub fn write(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
+    pub async fn write(&self, offset: u32, bytes: &mut [u8]) -> Result<(), FlashStoreError> {
         log::debug!("Writing {} bytes at offset 0x{offset:08x}", bytes.len());
-        self.storage.write(FLASH_ADDR + offset, bytes)
+        self.storage
+            .lock()
+            .await
+            .write(FLASH_ADDR + offset, bytes)?;
+        Ok(())
     }
 
-    pub fn write_erase(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
+    pub async fn write_erase(&self, offset: u32, bytes: &mut [u8]) -> Result<(), FlashStoreError> {
         log::debug!(
             "Erasing and Writing {} bytes at offset 0x{offset:08x}",
             bytes.len()
         );
-        self.storage
+        let mut lock = self.storage.lock().await;
-            .erase(FLASH_ADDR + offset, FLASH_ADDR + bytes.len() as u32)?;
+        lock.erase(FLASH_ADDR + offset, FLASH_ADDR + bytes.len() as u32)?;
-        self.storage.write(FLASH_ADDR + offset, bytes)
+        lock.write(FLASH_ADDR + offset, bytes)?;
+        Ok(())
     }
 
-    pub fn has_magic_bytes(storage: &mut FlashStorage) -> Result<bool, StoreError> {
+    pub fn has_magic_bytes(storage: &mut FlashStorage) -> Result<bool, FlashStoreError> {
         let mut magic: [u8; 4] = [0, 0, 0, 0];
         storage.read(FLASH_ADDR + MAGIC_REGION.offset, &mut magic)?;
         log::debug!("Magic bytes are {magic:?}");
@@ -60,7 +88,7 @@ impl Store {
         Ok(u32::from_ne_bytes(magic) == FLASH_INITIALIZE_MAGIC)
     }
 
-    pub fn initialize_flash(storage: &mut FlashStorage) -> Result<(), StoreError> {
+    pub fn initialize_flash(storage: &mut FlashStorage) -> Result<(), FlashStoreError> {
         storage.erase(FLASH_ADDR, FLASH_ADDR + INITIALIZATION_SIZE as u32)?;
         let zeros: [u8; INITIALIZATION_SIZE] = [0; INITIALIZATION_SIZE];
         storage.write(FLASH_ADDR + MAGIC_REGION.end() as u32, &zeros)?;
@@ -72,7 +100,9 @@ impl Store {
         if Self::has_magic_bytes(storage)? {
             Ok(())
         } else {
-            Err(StoreError::Other(FLASH_INITIALIZE_MAGIC as i32))
+            Err(FlashStoreError(FlashStorageError::Other(
+                FLASH_INITIALIZE_MAGIC as i32,
+            )))
         }
     }
 }

src/peripherals/storage/store.rs

@@ -0,0 +1,7 @@
+use crate::peripherals::storage::cardstore::CardStore;
+use crate::peripherals::storage::flash_store::FlashStore;
+
+pub struct Store {
+    pub flash_store: &'static FlashStore,
+    pub card_store: CardStore,
+}

src/views.rs

@@ -1,4 +1,5 @@
 pub mod card_view;
+pub mod error_view;
 pub mod flash_info_view;
 pub mod journal_view;
 pub mod main_menu;

src/views/card_view.rs

@@ -1,7 +1,11 @@
 use crate::display::sprite::render_sprite_onto_ili9341;
+use crate::drivers::primary_lcd::PrimaryDisplayError;
 use crate::navigation::navigation::NewState;
 use crate::navigation::outputs::Outputs;
+use crate::peripherals::Peripherals;
+use alloc::boxed::Box;
 use alloc::format;
+use core::error;
 use embedded_graphics::mono_font::MonoTextStyle;
 use embedded_graphics::mono_font::ascii::FONT_6X10;
 use embedded_graphics::pixelcolor::Rgb565;
@@ -25,10 +29,16 @@ pub struct CardView {
 }
 
 impl Navigable for CardView {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+    fn display(
+        &self,
+        outputs: &mut Outputs,
+        _: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
         async move {
             let display = &mut outputs.primary_display;
-            display.clear(Rgb565::BLACK).unwrap();
+            display
+                .clear(Rgb565::BLACK)
+                .map_err(PrimaryDisplayError::from)?;
 
             let background = Rectangle::new(Point::new(0, 0), Size::new(240, 320));
             let bg_color = self.card.cardtype.clone().into();
@@ -42,59 +52,60 @@ impl Navigable for CardView {
                 style,
             )
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
             Text::new(
                 &format!("Type: {}", self.card.cardtype),
                 Point::new(20, 250),
                 style,
             )
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
             Text::new(
                 &format!("Event: {}", self.card.event),
                 Point::new(20, 260),
                 style,
             )
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
             Text::new(
                 &format!("UUID: {}", self.card.uuid),
                 Point::new(20, 270),
                 style,
             )
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
             Text::new(
                 &format!("Trait1: {}", self.card.trait1),
                 Point::new(20, 280),
                 style,
             )
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
             Text::new(
                 &format!("Trait2: {}", self.card.trait2),
                 Point::new(20, 290),
                 style,
             )
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
             Text::new(
                 &format!("Trait3: {}", self.card.trait3),
                 Point::new(20, 300),
                 style,
             )
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
             Text::new(
                 &format!("Secret: {}", self.card.secret),
                 Point::new(20, 310),
                 style,
             )
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
 
             let palette: Palette = self.card.cardtype.clone().into();
             render_sprite_onto_ili9341(display, self.card.sprite.data.as_slice(), &palette);
+            Ok(())
         }
     }
 

src/views/error_view.rs

@@ -0,0 +1,94 @@
+use crate::navigation::navigation::Action;
+use crate::navigation::navigation::Navigable;
+use crate::navigation::navigation::NewState;
+use crate::navigation::outputs::Outputs;
+use crate::peripherals::Peripherals;
+use crate::views::view::View;
+use alloc::boxed::Box;
+use alloc::format;
+use alloc::string::String;
+use core::error;
+use embedded_graphics::{
+    Drawable,
+    mono_font::{MonoTextStyle, ascii::FONT_10X20},
+    pixelcolor::Rgb565,
+    prelude::*,
+    primitives::Rectangle,
+    text::Text,
+};
+
+use embedded_text::{
+    TextBox,
+    alignment::HorizontalAlignment,
+    style::{HeightMode, TextBoxStyleBuilder},
+};
+#[derive(Debug, Clone)]
+pub struct ErrorView {
+    pub error: String,
+}
+
+impl Navigable for ErrorView {
+    fn display(
+        &self,
+        outputs: &mut Outputs,
+        _: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+        async move {
+            let style = MonoTextStyle::new(&FONT_10X20, Rgb565::RED);
+            let display_area = outputs.primary_display.bounding_box();
+            Text::new(
+                "Error",
+                Point::new((display_area.size.width / 2 - 25) as i32, 30),
+                style,
+            )
+            .draw(&mut outputs.primary_display)
+            .unwrap_or_else(|error| {
+                panic!(
+                    "Error: {error:?}\nDraw error while rendering error: {}",
+                    self.error
+                )
+            });
+
+            let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+            let textbox_style = TextBoxStyleBuilder::new()
+                .height_mode(HeightMode::FitToText)
+                .alignment(HorizontalAlignment::Center)
+                .build();
+
+            let bounds = Rectangle::new(Point::new(0, 30), display_area.size);
+
+            TextBox::with_textbox_style(&format!("{}", self.error), bounds, style, textbox_style)
+                .draw(&mut outputs.primary_display)
+                .unwrap_or_else(|error| {
+                    panic!(
+                        "Error: {error:?}\nDraw error while rendering error: {}",
+                        self.error
+                    )
+                });
+            Ok(())
+        }
+    }
+
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
+        async move {
+            let Action::Button(input) = input else {
+                // Skip timer inputs
+                return NewState {
+                    view: View::Error(self.clone()),
+                    replace_view: true,
+                    redraw: false,
+                };
+            };
+
+            let new_menu = match input {
+                _ => View::Error(self.clone()),
+            };
+
+            NewState {
+                replace_view: matches!(new_menu, View::FlashInfo(_)),
+                view: new_menu,
+                redraw: true,
+            }
+        }
+    }
+}

src/views/flash_info_view.rs

@@ -1,27 +1,84 @@
-use crate::navigation::inputs::ButtonAction;
+use crate::drivers::primary_lcd::PrimaryDisplayError;
 use crate::navigation::navigation::Action;
 use crate::navigation::navigation::Navigable;
 use crate::navigation::navigation::NewState;
 use crate::navigation::outputs::Outputs;
+use crate::peripherals::Peripherals;
+use crate::peripherals::storage::MAGIC_REGION;
+use crate::peripherals::storage::cardstore::COUNT_REGION;
 use crate::views::view::View;
-use embedded_graphics::mono_font::MonoTextStyle;
+use alloc::boxed::Box;
-use embedded_graphics::mono_font::ascii::FONT_10X20;
+use core::error;
-use embedded_graphics::pixelcolor::Rgb565;
-use embedded_graphics::prelude::DrawTarget;
-use embedded_graphics::prelude::RgbColor;
-use embedded_graphics::text::Text;
-
 use embedded_graphics::prelude::Point;
+use embedded_graphics::{
+    Drawable,
+    mono_font::{MonoTextStyle, ascii::FONT_10X20},
+    pixelcolor::Rgb565,
+    prelude::*,
+    primitives::Rectangle,
+    text::Text,
+};
 
+use alloc::format;
+use embedded_text::{
+    TextBox,
+    alignment::HorizontalAlignment,
+    style::{HeightMode, TextBoxStyleBuilder},
+};
 #[derive(Debug, Clone)]
 pub struct FlashInfoView {}
 
 impl Navigable for FlashInfoView {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+    fn display(
-        let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+        &self,
-        Text::new("Flash Initialized: {:?}", Point::new(40, 40), style);
+        outputs: &mut Outputs,
+        peripherals: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+        async move {
+            let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+            let mut magic_bytes: [u8; MAGIC_REGION.size] = [0; MAGIC_REGION.size];
+            peripherals
+                .store
+                .lock()
+                .await
+                .flash_store
+                .read(MAGIC_REGION.offset, &mut magic_bytes)
+                .await?;
+            let mut card_count_bytes: [u8; COUNT_REGION.size] = [0; COUNT_REGION.size];
+            peripherals
+                .store
+                .lock()
+                .await
+                .flash_store
+                .read(COUNT_REGION.offset, &mut card_count_bytes)
+                .await?;
 
-        core::future::ready(())
+            let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+            let textbox_style = TextBoxStyleBuilder::new()
+                .height_mode(HeightMode::FitToText)
+                .alignment(HorizontalAlignment::Center)
+                .build();
+
+            let display_area = outputs.primary_display.bounding_box();
+            let bounds = Rectangle::new(Point::new(0, 30), display_area.size);
+
+            TextBox::with_textbox_style(
+                &format!(
+                    "
+Flash Init Magic: 0x{:x}\n
+Card Count: {}\n 
+",
+                    u32::from_le_bytes(magic_bytes),
+                    u32::from_le_bytes(card_count_bytes)
+                ),
+                bounds,
+                style,
+                textbox_style,
+            )
+            .draw(&mut outputs.primary_display)
+            .map_err(PrimaryDisplayError::from)?;
+            Ok(())
+        }
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/journal_view.rs

@@ -1,3 +1,7 @@
+use crate::drivers::primary_lcd::PrimaryDisplayError;
+use crate::peripherals::Peripherals;
+use alloc::boxed::Box;
+use core::error;
 use core::future;
 
 use alloc::vec::Vec;
@@ -22,9 +26,17 @@ pub struct JournalView {
 }
 
 impl Navigable for JournalView {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+    fn display(
+        &self,
+        outputs: &mut Outputs,
+        _: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
         async move {
-            outputs.primary_display.clear(Rgb565::BLACK).unwrap();
+            outputs
+                .primary_display
+                .clear(Rgb565::BLACK)
+                .map_err(PrimaryDisplayError::from)?;
+            Ok(())
         }
     }
 

src/views/main_menu.rs

@@ -1,4 +1,8 @@
+use crate::drivers::primary_lcd::PrimaryDisplayError;
+use crate::peripherals::Peripherals;
+use alloc::boxed::Box;
 use alloc::vec;
+use core::error;
 
 use crate::card::model::Card;
 use crate::card::{decoder::split_nfc_hex, mock::*};
@@ -22,16 +26,26 @@ pub struct MainMenu {
 }
 
 impl Navigable for MainMenu {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+    fn display(
-        let display = &mut outputs.primary_display;
+        &self,
-        display.clear(Rgb565::BLACK).unwrap();
+        outputs: &mut Outputs,
+        _: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+        async move {
+            let display = &mut outputs.primary_display;
+            display.clear(Rgb565::BLACK).unwrap();
 
-        menu_item::show(display, "Scan card", 0, self.selected);
+            menu_item::show(display, "Scan card", 0, self.selected)
-        menu_item::show(display, "Last card", 1, self.selected);
+                .map_err(PrimaryDisplayError::from)?;
-        menu_item::show(display, "Journal", 2, self.selected);
+            menu_item::show(display, "Last card", 1, self.selected)
-        menu_item::show(display, "Settings", 3, self.selected);
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Journal", 2, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Settings", 3, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
 
-        core::future::ready(())
+            Ok(())
+        }
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/menu_item.rs

@@ -7,7 +7,7 @@ use embedded_graphics::prelude::Point;
 use embedded_graphics::prelude::RgbColor;
 use embedded_graphics::text::Text;
 
-pub fn show<D>(display: &mut D, name: &str, position: i32, selected: i32)
+pub fn show<D>(display: &mut D, name: &str, position: i32, selected: i32) -> Result<(), D::Error>
 where
     D: DrawTarget<Color = Rgb565>,
     D::Error: core::fmt::Debug,
@@ -24,6 +24,6 @@ where
             style
         },
     )
-    .draw(display)
+    .draw(display)?;
-    .unwrap();
+    Ok(())
 }

src/views/scan_menu.rs

@@ -1,7 +1,11 @@
+use crate::drivers::primary_lcd::PrimaryDisplayError;
 use crate::navigation::inputs::ButtonAction;
 use crate::navigation::navigation::CARD_DATA;
 use crate::navigation::navigation::NewState;
 use crate::navigation::outputs::Outputs;
+use crate::peripherals::Peripherals;
+use alloc::boxed::Box;
+use core::error;
 
 use alloc::format;
 use embedded_graphics::Drawable;
@@ -33,54 +37,61 @@ pub struct ScanMenu {
 }
 
 impl Navigable for ScanMenu {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+    fn display(
-        let display = &mut outputs.primary_display;
+        &self,
-        let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+        outputs: &mut Outputs,
-        display.clear(Rgb565::BLACK).unwrap();
+        _: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+        async move {
+            let display = &mut outputs.primary_display;
+            let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+            display
+                .clear(Rgb565::BLACK)
+                .map_err(PrimaryDisplayError::from)?;
 
-        let display_area = display.bounding_box();
+            let display_area = display.bounding_box();
 
-        Text::new("Scanning...", Point::new(20, 30), style)
+            Text::new("Scanning...", Point::new(20, 30), style)
+                .draw(display)
+                .map_err(PrimaryDisplayError::from)?;
+
+            // Create styles used by the drawing operations.
+            let arc_stroke = PrimitiveStyleBuilder::new()
+                .stroke_color(Rgb565::WHITE)
+                .stroke_width(5)
+                .stroke_alignment(StrokeAlignment::Inside)
+                .build();
+            let character_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+            let text_style = TextStyleBuilder::new()
+                .baseline(Baseline::Middle)
+                .alignment(Alignment::Center)
+                .build();
+
+            let sweep = self.progress as f32 * 360.0 / 255.0;
+
+            let width = display_area.size.width;
+            let bounding_box =
+                Rectangle::with_center(display_area.center(), Size::new_equal(4 * width / 5));
+            // log::info!("bounding_box: {:?}", bounding_box);
+            // log::info!("display_area: {:?}", display_area);
+            // Draw an arc with a 5px wide stroke.
+            Arc::new(
+                bounding_box.top_left,
+                bounding_box.size.width,
+                90.0.deg(),
+                sweep.deg(),
+            )
+            .into_styled(arc_stroke)
             .draw(display)
-            .unwrap();
+            .map_err(PrimaryDisplayError::from)?;
 
-        // Create styles used by the drawing operations.
+            // Draw centered text.
-        let arc_stroke = PrimitiveStyleBuilder::new()
+            let text = format!("{:.2}%", 100. * (self.progress as f32) / 255.);
-            .stroke_color(Rgb565::WHITE)
+            Text::with_text_style(&text, display_area.center(), character_style, text_style)
-            .stroke_width(5)
+                .draw(display)
-            .stroke_alignment(StrokeAlignment::Inside)
+                .map_err(PrimaryDisplayError::from)?;
-            .build();
+            Ok(())
-        let character_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+        }
-        let text_style = TextStyleBuilder::new()
-            .baseline(Baseline::Middle)
-            .alignment(Alignment::Center)
-            .build();
-
-        let sweep = self.progress as f32 * 360.0 / 255.0;
-
-        let width = display_area.size.width;
-        let bounding_box =
-            Rectangle::with_center(display_area.center(), Size::new_equal(4 * width / 5));
-        // log::info!("bounding_box: {:?}", bounding_box);
-        // log::info!("display_area: {:?}", display_area);
-        // Draw an arc with a 5px wide stroke.
-        Arc::new(
-            bounding_box.top_left,
-            bounding_box.size.width,
-            90.0.deg(),
-            sweep.deg(),
-        )
-        .into_styled(arc_stroke)
-        .draw(display)
-        .unwrap();
-
-        // Draw centered text.
-        let text = format!("{:.2}%", 100. * (self.progress as f32) / 255.);
-        Text::with_text_style(&text, display_area.center(), character_style, text_style)
-            .draw(display)
-            .unwrap();
-
-        core::future::ready(())
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/settings_menu.rs

@@ -1,6 +1,10 @@
+use crate::drivers::primary_lcd::PrimaryDisplayError;
 use crate::navigation::navigation::{Action, Navigable, NewState};
 use crate::navigation::outputs::Outputs;
+use crate::peripherals::Peripherals;
 use crate::views::{flash_info_view::FlashInfoView, menu_item, view::View};
+use alloc::boxed::Box;
+use core::error;
 
 use crate::navigation::inputs::ButtonAction;
 
@@ -16,14 +20,22 @@ pub struct SettingsMenu {
 }
 
 impl Navigable for SettingsMenu {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+    fn display(
-        let display = &mut outputs.primary_display;
+        &self,
-        display.clear(Rgb565::BLACK).unwrap();
+        outputs: &mut Outputs,
-        menu_item::show(display, "System Inforation", 0, self.selected);
+        _: &Peripherals,
-        menu_item::show(display, "Wifi Information", 1, self.selected);
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
-        menu_item::show(display, "Flash Information", 2, self.selected);
+        async move {
-
+            let display = &mut outputs.primary_display;
-        core::future::ready(())
+            display.clear(Rgb565::BLACK).unwrap();
+            menu_item::show(display, "System Inforation", 0, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Wifi Information", 1, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Flash Information", 2, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            Ok(())
+        }
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/view.rs

@@ -1,14 +1,18 @@
 use crate::navigation::outputs::Outputs;
+use crate::peripherals::Peripherals;
 use crate::views::card_view::CardView;
 use crate::views::{
-    flash_info_view::FlashInfoView, journal_view::JournalView, main_menu::MainMenu,
+    error_view::ErrorView, flash_info_view::FlashInfoView, journal_view::JournalView,
-    scan_menu::ScanMenu, settings_menu::SettingsMenu,
+    main_menu::MainMenu, scan_menu::ScanMenu, settings_menu::SettingsMenu,
 };
+use alloc::boxed::Box;
+use core::error;
 
 use crate::navigation::navigation::{Navigable, NewState};
 
 #[derive(Debug, Clone)]
 pub enum View {
+    Error(ErrorView),
     Main(MainMenu),
     Scan(ScanMenu),
     Settings(SettingsMenu),
@@ -18,15 +22,22 @@ pub enum View {
 }
 
 impl Navigable for View {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+    fn display(
+        &self,
+        outputs: &mut Outputs,
+        peripherals: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
         async move {
             match self {
-                View::Main(main_menu) => main_menu.display(outputs).await,
+                View::Error(error_view) => error_view.display(outputs, peripherals).await,
-                View::Scan(scan_menu) => scan_menu.display(outputs).await,
+                View::Main(main_menu) => main_menu.display(outputs, peripherals).await,
-                View::Settings(settings_menu) => settings_menu.display(outputs).await,
+                View::Scan(scan_menu) => scan_menu.display(outputs, peripherals).await,
-                View::Journal(journal_view) => journal_view.display(outputs).await,
+                View::Settings(settings_menu) => settings_menu.display(outputs, peripherals).await,
-                View::Card(card_view) => card_view.display(outputs).await,
+                View::Journal(journal_view) => journal_view.display(outputs, peripherals).await,
-                View::FlashInfo(flash_info_view) => flash_info_view.display(outputs).await,
+                View::Card(card_view) => card_view.display(outputs, peripherals).await,
+                View::FlashInfo(flash_info_view) => {
+                    flash_info_view.display(outputs, peripherals).await
+                }
             }
         }
     }
@@ -37,6 +48,7 @@ impl Navigable for View {
     ) -> impl core::future::Future<Output = NewState> + Send {
         async move {
             match self {
+                View::Error(error_view) => error_view.handle_input(input).await,
                 View::Main(main_menu) => main_menu.handle_input(input).await,
                 View::Scan(scan_menu) => scan_menu.handle_input(input).await,
                 View::Settings(settings_menu) => settings_menu.handle_input(input).await,