minor component fixes

Cargo.lock

@@ -53,12 +53,6 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c583acf993cf4245c4acb0a2cc2ab1f9cc097de73411bb6d3647ff6af2b1013d"
 
-[[package]]
-name = "array-init"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d62b7694a562cdf5a74227903507c56ab2cc8bdd1f781ed5cb4cf9c9f810bfc"
-
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -102,29 +96,6 @@ dependencies = [
  "vsimd",
 ]
 
-[[package]]
-name = "binary_serde"
-version = "1.0.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4b2fe974c561ed04fb89673dd221bed36fc4794b71ca6ae96ffe19949045686"
-dependencies = [
- "array-init",
- "binary_serde_macros",
- "recursive_array",
- "thiserror-no-std",
-]
-
-[[package]]
-name = "binary_serde_macros"
-version = "1.0.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4790b8dbcfa9d3adf2020ebf5fd36c6bc89a77d434131615ea349bc9620e8831"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "bitfield"
 version = "0.17.0"
@@ -348,7 +319,6 @@ name = "creaturedex"
 version = "0.1.0"
 dependencies = [
  "base64 0.23.1",
- "binary_serde",
  "ch1115",
  "critical-section",
  "display-interface-spi",
@@ -362,21 +332,17 @@ dependencies = [
  "embedded-hal-async",
  "embedded-hal-bus",
  "embedded-io 0.7.1",
- "embedded-storage",
- "embedded-text",
  "esp-alloc",
  "esp-bootloader-esp-idf",
  "esp-hal",
  "esp-hal-wifimanager",
  "esp-println",
  "esp-rtos",
- "esp-storage",
  "i2c-character-display",
  "ili9341",
  "log",
  "num_enum",
  "pn532",
- "static_assertions",
 ]
 
 [[package]]
@@ -1050,17 +1016,6 @@ 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"
@@ -2142,12 +2097,6 @@ 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"
@@ -2847,12 +2796,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "recursive_array"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69bad83913c3b39011ad9d43b7ac0cae139cec5d7e7288fbea5bb4b4e3cc78f6"
-
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -3330,26 +3273,6 @@ dependencies = [
  "syn 3.0.3",
 ]
 
-[[package]]
-name = "thiserror-impl-no-std"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58e6318948b519ba6dc2b442a6d0b904ebfb8d411a3ad3e07843615a72249758"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "thiserror-no-std"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3ad459d94dd517257cc96add8a43190ee620011bb6e6cdc82dafd97dfafafea"
-dependencies = [
- "thiserror-impl-no-std",
-]
-
 [[package]]
 name = "thread_local"
 version = "1.1.10"

Cargo.toml

@@ -50,11 +50,6 @@ embassy-sync = "0.8.0"
 embedded-hal-async = "1.0.0"
 i2c-character-display = "0.5.1"
 ch1115 = { version = "0.1.2", features = ["graphics"] }
-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"

src/background_tasks/nfc.rs

@@ -1,4 +1,3 @@
-use crate::peripherals::Peripherals;
 use embedded_hal_bus::i2c::AtomicDevice;
 use esp_hal::{Blocking, i2c::master::I2c, time::Instant};
 
@@ -15,7 +14,6 @@ use crate::{
 )]
 pub async fn nfc_scanner(
     mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>,
-    peripherals: &'static Peripherals,
 ) {
     loop {
         while CARD_DATA.lock().await.is_none() {
@@ -26,29 +24,10 @@ pub async fn nfc_scanner(
                         log::error!("Failed to split NFC card data");
                         continue;
                     };
-                    let card = match Card::try_from(split_data) {
-                        Ok(card) => card,
-                        Err(err) => {
-                            log::error!("Invalid card data: {err}");
-                            continue;
-                        }
-                    };
-                    CARD_DATA.lock().await.replace(card);
-
-                    match peripherals
-                        .store
+                    CARD_DATA
                         .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)
-                        }
-                    }
-
+                        .replace(Card::try_from(split_data).unwrap());
                     let elapsed_ms = start.elapsed().as_millis();
                     log::info!(
                         "NFC read duration: {} ms, card data length: {}",
@@ -56,8 +35,8 @@ pub async fn nfc_scanner(
                         card_data.len()
                     );
                 }
-                Err(_) => {
-                    log::info!("No NFC card found");
+                Err(e) => {
+                    log::error!("NFC read failed: {e}");
                 }
             }
         }

src/bin/main.rs

@@ -7,7 +7,6 @@
 )]
 #![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;
@@ -16,14 +15,10 @@ 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::peripherals::Peripherals;
-use creaturedex::peripherals::storage::cardstore::CardStore;
-use creaturedex::peripherals::storage::flash_store::FlashStore;
-use creaturedex::peripherals::storage::store::Store;
+use creaturedex::network::wifi::setup_wifi;
 use embassy_executor::Spawner;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::{
@@ -37,8 +32,6 @@ use esp_hal::gpio::{Input, InputConfig, Pull};
 use esp_hal::timer::timg::TimerGroup;
 use log::error;
 
-use esp_hal::rtc_cntl::Rtc;
-
 #[panic_handler]
 fn panic(panic_info: &core::panic::PanicInfo) -> ! {
     error!("{}", panic_info);
@@ -62,52 +55,41 @@ async fn main(spawner: Spawner) {
     creaturedex::logging::init();
 
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
-    let esp_peripherals = esp_hal::init(config);
+    let 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(esp_peripherals.SW_INTERRUPT);
-    let timg0 = TimerGroup::new(esp_peripherals.TIMG0);
+        esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
 
-    let (primary, mut secondaries) = retry(
-        5,
-        spi_bus::DisplayPinConfiguration {
-            spi_peripheral: esp_peripherals.SPI2,
-            sck: esp_peripherals.GPIO36,
-            mosi: esp_peripherals.GPIO35,
-            miso: esp_peripherals.GPIO37,
-            cs_primary: esp_peripherals.GPIO11,
-            cs_secondary_1: esp_peripherals.GPIO13,
-            cs_secondary_2: esp_peripherals.GPIO14,
-            cs_secondary_3: esp_peripherals.GPIO21,
-            reset_primary: esp_peripherals.GPIO10,
-            reset_secondary: esp_peripherals.GPIO47,
-            dc_pin: esp_peripherals.GPIO12,
-        },
-        spi_bus::DisplayPinConfiguration::build,
-    );
+    let (primary, mut secondaries) = spi_bus::DisplayPinConfiguration {
+        spi_peripheral: peripherals.SPI2,
+        sck: peripherals.GPIO36,
+        mosi: peripherals.GPIO35,
+        miso: peripherals.GPIO37,
+        cs_primary: peripherals.GPIO11,
+        cs_secondary_1: peripherals.GPIO13,
+        cs_secondary_2: peripherals.GPIO14,
+        cs_secondary_3: peripherals.GPIO21,
+        reset_primary: peripherals.GPIO10,
+        reset_secondary: peripherals.GPIO47,
+        dc_pin: peripherals.GPIO12,
+    }
+    .build();
 
     // Initialize the shared I2C bus using the refactored i2c_bus module.
     let shared_i2c = {
-        let bus = retry(
-            5,
-            I2cBusPinConfiguration {
-                i2c_peripheral: esp_peripherals.I2C0,
-                scl: esp_peripherals.GPIO18,
-                sda: esp_peripherals.GPIO17,
-            },
-            I2cBusPinConfiguration::build,
-        );
-        Box::leak(Box::new(bus))
+        let config = I2cBusPinConfiguration {
+            i2c_peripheral: peripherals.I2C0,
+            scl: peripherals.GPIO18,
+            sda: peripherals.GPIO17,
+        };
+        config.build()
     };
 
-    let mut lcd: TertiaryDisplay = retry(
-        5,
-        TertiaryDisplayPinConfiguration { i2c: shared_i2c },
-        TertiaryDisplayPinConfiguration::build,
-    );
+    let mut lcd: TertiaryDisplay = TertiaryDisplayPinConfiguration { i2c: shared_i2c }.build();
     lcd.load_charset(EXAMPLE).unwrap();
     let h = EXAMPLE[HEART];
     let e = EXAMPLE[EMPTY];
@@ -120,25 +102,7 @@ async fn main(spawner: Spawner) {
         );
     }
 
-    let flash_store = Box::leak(Box::new(
-        FlashStore::new(esp_peripherals.FLASH).expect("Could not initialize Flash Store"),
-    ));
-
-    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,
-    }));
+    setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
 
     let mut nfc_driver = NfcPn532Driver::new(AtomicDevice::new(shared_i2c));
     if nfc_driver.configure_sam().await.is_ok() {
@@ -149,12 +113,12 @@ async fn main(spawner: Spawner) {
 
     let button_config = InputConfig::default().with_pull(Pull::Up);
     let inputs = Inputs {
-        up: Input::new(esp_peripherals.GPIO38, button_config),
-        down: Input::new(esp_peripherals.GPIO39, button_config),
-        left: Input::new(esp_peripherals.GPIO40, button_config),
-        right: Input::new(esp_peripherals.GPIO41, button_config),
-        back: Input::new(esp_peripherals.GPIO8, button_config),
-        ok: Input::new(esp_peripherals.GPIO0, button_config),
+        up: Input::new(peripherals.GPIO38, button_config),
+        down: Input::new(peripherals.GPIO39, button_config),
+        left: Input::new(peripherals.GPIO40, button_config),
+        right: Input::new(peripherals.GPIO41, button_config),
+        back: Input::new(peripherals.GPIO8, button_config),
+        ok: Input::new(peripherals.GPIO0, button_config),
     };
 
     display_shit(&mut secondaries[0], "foo 1");
@@ -174,11 +138,8 @@ async fn main(spawner: Spawner) {
     };
 
     log::info!("Setup complete, entering main loop");
-    spawner.spawn(navigation::run(inputs, outputs, peripherals).expect("run task failed"));
-    spawner.spawn(
-        background_tasks::nfc_scanner(nfc_driver, peripherals).expect("nfc scanner task failed"),
-    );
-    core::future::pending::<()>().await
+    spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
+    spawner.spawn(background_tasks::nfc_scanner(nfc_driver).expect("nfc scanner task failed"));
 }
 
 fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
@@ -190,17 +151,3 @@ fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
         .unwrap();
     oled.flush().unwrap();
 }
-
-fn retry<T, U, F: FnMut(T) -> Result<U, T>>(repetitions: u32, input: T, mut action: F) -> U {
-    let mut initial_state = input;
-    for iteration in 0..repetitions {
-        log::debug!("Trying to initialize. Retries: {iteration}");
-
-        match action(initial_state) {
-            Ok(success) => return success,
-            Err(recovered_input) => initial_state = recovered_input,
-        }
-    }
-
-    panic!("Init failed after {repetitions} retries.")
-}

src/card/decoder.rs

@@ -1,23 +1,22 @@
 use core::fmt::Display;
 
-use crate::card::model::RawCard;
+use crate::card::model::NfcPayload;
 use alloc::string::{String, ToString};
 
-pub fn split_nfc_hex(payload: &[u8]) -> Option<RawCard> {
+pub fn split_nfc_hex(payload: &[u8]) -> Option<NfcPayload<'_>> {
     if payload.len() < 0x35A {
         return None;
     }
 
-    Some(RawCard {
-        event_encoding: payload[0..2].try_into().ok()?,
+    Some(NfcPayload {
+        event_encoding: &payload[0..2],
         card_type: payload[2],
-        card_uuid: payload[3..5].try_into().ok()?,
-        _reserved: payload[5..9].try_into().ok()?,
-        sprite: payload[9..0x2DB].try_into().ok()?,
-        packed_card_text: payload[0x2DB..0x311].try_into().ok()?,
-        secret: payload[0x311..0x329].try_into().ok()?,
-        _opaque_trailer: payload[0x329..0x35A].try_into().ok()?,
-        _padding: Default::default(),
+        card_uuid: &payload[3..5],
+        _reserved: &payload[5..9],
+        sprite: &payload[9..0x2DB],
+        packed_card_text: &payload[0x2DB..0x311],
+        secret: &payload[0x311..0x329],
+        _opaque_trailer: &payload[0x329..0x35A],
     })
 }
 

src/card/model.rs

@@ -6,24 +6,18 @@ use num_enum::FromPrimitive;
 use crate::card::decoder::{Events, decode_known_event, decode_packed_card_text, decode_secret};
 use embedded_graphics::pixelcolor::{Rgb565, Rgb888};
 
-use binary_serde::BinarySerde;
-
-#[derive(Debug, BinarySerde, PartialEq, Eq, Clone, Copy)]
-#[repr(C)]
-pub struct RawCard {
-    pub event_encoding: [u8; 2],
+#[derive(Debug, Clone, Copy)]
+pub struct NfcPayload<'a> {
+    pub event_encoding: &'a [u8],
     pub card_type: u8,
-    pub card_uuid: [u8; 2],
-    pub _reserved: [u8; 4],
-    pub sprite: [u8; 722],
-    pub packed_card_text: [u8; 54],
-    pub secret: [u8; 24],
-    pub _opaque_trailer: [u8; 49],
-    pub _padding: [u8; 2],
+    pub card_uuid: &'a [u8],
+    pub _reserved: &'a [u8],
+    pub sprite: &'a [u8],
+    pub packed_card_text: &'a [u8],
+    pub secret: &'a [u8],
+    pub _opaque_trailer: &'a [u8],
 }
 
-static_assertions::const_assert!(RawCard::SERIALIZED_SIZE.is_multiple_of(4));
-
 #[derive(Debug, Clone, Eq, PartialEq, FromPrimitive)]
 #[repr(u8)]
 pub enum CardType {
@@ -228,7 +222,7 @@ pub struct Sprite {
 
 #[derive(Debug, Clone)]
 pub struct Card {
-    pub uuid: u32,
+    pub uuid: String,
     pub event: Events,
     pub cardtype: CardType,
     pub name: String,
@@ -241,19 +235,17 @@ pub struct Card {
     pub sprite: Sprite,
 }
 
-impl TryFrom<RawCard> for Card {
+impl<'a> TryFrom<NfcPayload<'a>> for Card {
     type Error = &'static str;
 
-    fn try_from(raw_card: RawCard) -> Result<Self, Self::Error> {
-        let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16
-            | (u16::from_ne_bytes(raw_card.card_uuid) as u32);
-
-        let event = decode_known_event(&raw_card.event_encoding);
-        let cardtype = CardType::from(raw_card.card_type);
-        let (name, trait1, trait2, trait3) = decode_packed_card_text(&raw_card.packed_card_text);
-        let secret = decode_secret(&raw_card.secret);
+    fn try_from(payload: NfcPayload<'a>) -> Result<Self, Self::Error> {
+        let uuid: String = "empty for now".into(); //str::from_utf8(payload.card_uuid).unwrap().into();
+        let event = decode_known_event(payload.event_encoding);
+        let cardtype = CardType::from(payload.card_type);
+        let (name, trait1, trait2, trait3) = decode_packed_card_text(payload.packed_card_text);
+        let secret = decode_secret(payload.secret);
         let sprite = Sprite {
-            data: raw_card.sprite.to_vec(),
+            data: payload.sprite.to_vec(),
         };
         Ok(Self {
             uuid,

src/drivers/i2c_bus.rs

@@ -1,3 +1,4 @@
+use alloc::boxed::Box;
 use embedded_hal_bus::i2c::AtomicDevice;
 use embedded_hal_bus::util::AtomicCell;
 use esp_hal::gpio::interconnect::PeripheralInput;
@@ -20,19 +21,18 @@ where
     SCL: PeripheralOutput<'a> + PeripheralInput<'a>,
     SDA: PeripheralOutput<'a> + PeripheralInput<'a>,
 {
-    pub fn build(self) -> Result<AtomicCell<InnerI2cBus<'a>>, Self> {
+    pub fn build(self) -> I2cBus<'a> {
         let config = Config::default().with_frequency(esp_hal::time::Rate::from_khz(400));
-        match I2c::new(self.i2c_peripheral, config) {
-            Ok(bus) => {
-                let i2c = bus.with_sda(self.sda).with_scl(self.scl);
-                log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
-                Ok(AtomicCell::new(i2c))
-            }
+        let i2c = match I2c::new(self.i2c_peripheral, config) {
+            Ok(bus) => bus.with_sda(self.sda).with_scl(self.scl),
             Err(e) => {
                 log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
-                unimplemented!("Partial move makes it impossible to retry.");
-                // Err(self)
+                panic!("Shared I2C bus initialization failed");
             }
-        }
+        };
+        let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
+        log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
+
+        shared_i2c
     }
 }

src/drivers/primary_lcd.rs

@@ -1,6 +1,3 @@
-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;
@@ -9,27 +6,10 @@ use embedded_hal_bus::spi::AtomicDevice;
 use embedded_hal_bus::util::AtomicCell;
 use esp_hal::delay::Delay;
 use esp_hal::gpio::Output;
-use ili9341::{DisplayError, DisplaySize240x320, Ili9341, Orientation};
+use ili9341::{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/drivers/spi_bus.rs

@@ -135,7 +135,7 @@ where
     RES2: OutputPin + 'static,
     DC: OutputPin + 'static,
 {
-    pub fn build(self) -> Result<(PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]), Self> {
+    pub fn build(self) -> (PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]) {
         let spi = Spi::new(
             self.spi_peripheral,
             SpiConfig::default()
@@ -178,7 +178,7 @@ where
         }
         .build();
 
-        Ok((primary, secondaries))
+        (primary, secondaries)
     }
 }
 

src/drivers/tertiary_lcd.rs

@@ -15,20 +15,19 @@ pub struct TertiaryDisplayPinConfiguration<'a> {
 }
 
 impl<'a> TertiaryDisplayPinConfiguration<'a> {
-    pub fn build(self) -> Result<TertiaryDisplay<'a>, Self> {
+    pub fn build(self) -> TertiaryDisplay<'a> {
         let device = AtomicDevice::new(self.i2c);
         let mut lcd = CharacterDisplayPCF8574T::new(device, LcdDisplayType::Lcd16x2, Delay::new());
         match lcd.init() {
             Ok(()) => {
                 log::info!("I2C tertiary LCD initialized on PCF8574T at address 0x27");
-                Ok(TertiaryDisplay {
+                TertiaryDisplay {
                     display: lcd,
                     charset: create_custom_char_set!(),
-                })
+                }
             }
             Err(e) => {
-                log::error!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
-                Err(self)
+                panic!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
             }
         }
     }
@@ -408,3 +407,4 @@ pub const BOX: CharMap = [
 ];
 
 pub const EXAMPLE: CustomCharset = create_custom_char_set!(HEART, BOX, EMPTY);
+

src/lib.rs

@@ -1,5 +1,4 @@
 #![no_std]
-#![feature(vec_into_chunks)]
 
 extern crate alloc;
 
@@ -10,5 +9,5 @@ pub mod drivers;
 pub mod logging;
 pub mod navigation;
 pub mod network;
-pub mod peripherals;
+pub mod storage;
 pub mod views;

src/navigation/navigation.rs

@@ -1,15 +1,9 @@
-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;
@@ -33,49 +27,16 @@ pub struct NewState {
 }
 
 pub trait Navigable {
-    fn display(
-        &self,
-        outputs: &mut Outputs,
-        peripherals: &Peripherals,
-    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send;
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + 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, 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();
-    }
-
+pub async fn run(mut inputs: Inputs, mut outputs: Outputs) {
     log::info!("starting navigation");
 
     let mut state = NavigationState::new();
-    if let Err(error) = state
-        .screens
-        .last()
-        .unwrap()
-        .display(&mut outputs, peripherals)
-        .await
-    {
-        display_error(error.to_string(), &mut state, &mut outputs, &peripherals).await;
-    };
+    state.screens.last().unwrap().display(&mut outputs).await;
 
     loop {
         let selection = select(
@@ -121,15 +82,7 @@ pub async fn run(mut inputs: Inputs, mut outputs: Outputs, peripherals: &'static
         state.screens.push(new_state.view);
 
         if action != Action::Timer || new_state.redraw {
-            if let Err(error) = state
-                .screens
-                .last()
-                .unwrap()
-                .display(&mut outputs, peripherals)
-                .await
-            {
-                display_error(error.to_string(), &mut state, &mut outputs, &peripherals).await;
-            }
+            state.screens.last().unwrap().display(&mut outputs).await;
         }
 
         Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)).await;

src/peripherals.rs

@@ -1,11 +0,0 @@
-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,32 +0,0 @@
-pub struct MemoryRegion {
-    pub offset: u32,
-    pub size: usize,
-}
-
-impl MemoryRegion {
-    pub const fn new(offset: u32, size: usize) -> Self {
-        assert!(offset.is_multiple_of(4), "Flash requires 4 bytes alignment");
-        assert!(size.is_multiple_of(4), "Flash requires 4 bytes alignment");
-        Self { offset, size }
-    }
-
-    pub const fn end(&self) -> usize {
-        self.offset as usize + self.size
-    }
-}
-
-pub const MAX_FLASH: usize = 16 * 1024 * 1024;
-
-pub const MAGIC_REGION: MemoryRegion = MemoryRegion::new(0, 4);
-
-pub const SETTINGS_REGION: MemoryRegion = MemoryRegion::new(MAGIC_REGION.end() as u32, 1024);
-
-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,235 +0,0 @@
-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::peripherals::storage::flash_store::{FlashStore, FlashStoreError};
-
-use crate::peripherals::storage::{CARDSTORE_REGION, MemoryRegion};
-
-const MAX_CARDS: usize = 20000;
-
-pub const COUNT_REGION: MemoryRegion = MemoryRegion::new(CARDSTORE_REGION.offset, size_of::<u32>());
-
-const ALLOCATION_TABLE_REGION: MemoryRegion = MemoryRegion::new(
-    COUNT_REGION.end() as u32,
-    MAX_CARDS * AllocationTableEntry::SERIALIZED_SIZE,
-);
-
-const CARDS_REGION: MemoryRegion = MemoryRegion::new(
-    ALLOCATION_TABLE_REGION.end() as u32,
-    CARDSTORE_REGION.size - ALLOCATION_TABLE_REGION.end(),
-);
-
-#[derive(Debug, BinarySerde, PartialEq, Eq, Clone)]
-#[repr(C)]
-pub struct AllocationTableEntry {
-    uuid: u32,
-    // this is the numeric offset of the AllocationTableEntry
-    // as well as the card entry in flash memory
-    // size_of::<AllocationTableEntry>() * offset
-    // size_of::<RawCard>() * offset
-    offset: u32,
-
-    creation_date: u64,
-    last_read_date: u64,
-
-    // how often a card has been read by nfc
-    read_count: u32,
-
-    deleted: bool,
-
-    reserved: [u64; 4],
-    _padding: [u8; 3],
-}
-
-static_assertions::const_assert!(AllocationTableEntry::SERIALIZED_SIZE.is_multiple_of(4));
-
-impl AllocationTableEntry {
-    fn new(uuid: u32, offset: u32, timestamp: u64) -> Self {
-        Self {
-            uuid,
-            offset,
-            creation_date: timestamp,
-            last_read_date: timestamp,
-            read_count: 0,
-            deleted: true,
-            reserved: Default::default(),
-            _padding: Default::default(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum CardStoreError {
-    Store(FlashStoreError),
-    CorruptedEntry(DeserializeError),
-    NoEntry(u32),
-}
-
-impl Error for 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)
-    }
-}
-
-impl From<DeserializeError> for CardStoreError {
-    fn from(error: DeserializeError) -> CardStoreError {
-        CardStoreError::CorruptedEntry(error)
-    }
-}
-
-pub struct CardStore {
-    store: &'static FlashStore,
-    count: u32,
-    pub allocation_table: BTreeMap<u32, AllocationTableEntry>,
-}
-
-impl CardStore {
-    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).await?;
-
-        let count: u32 = u32::from_ne_bytes(count_bytes);
-
-        log::info!("Found {count} cards in flash.");
-
-        let mut allocation_table_entries: Vec<u8> =
-            Vec::with_capacity(AllocationTableEntry::SERIALIZED_SIZE * count as usize);
-
-        store
-            .read(
-                ALLOCATION_TABLE_REGION.offset,
-                &mut allocation_table_entries,
-            )
-            .await?;
-
-        let chunks =
-            allocation_table_entries.into_chunks::<{ AllocationTableEntry::SERIALIZED_SIZE }>();
-
-        let mut allocation_table = BTreeMap::<u32, AllocationTableEntry>::new();
-        for chunk in chunks {
-            let allocation_table_entry =
-                AllocationTableEntry::binary_deserialize(chunk.as_ref(), Endianness::Little)?;
-            allocation_table.insert(allocation_table_entry.uuid, allocation_table_entry);
-        }
-
-        Ok(Self {
-            store,
-            count,
-            allocation_table,
-        })
-    }
-
-    pub async fn get_card_by_uuid(&self, uuid: u32) -> Result<RawCard, CardStoreError> {
-        let entry = self
-            .allocation_table
-            .get(&uuid)
-            .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).await?;
-
-        Ok(RawCard::binary_deserialize(
-            raw_card.as_ref(),
-            Endianness::Little,
-        )?)
-    }
-
-    pub async fn save_raw_card(
-        &mut self,
-        raw_card: RawCard,
-        timestamp: u64,
-    ) -> Result<(), CardStoreError> {
-        let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16
-            | (u16::from_ne_bytes(raw_card.card_uuid) as u32);
-        log::info!("Saving card with uuid {:x}", uuid);
-
-        // check if we already got the card
-        // if not find the next deleted entry,
-        // if none create a new one at the end
-        let (entry, is_new) = match self.allocation_table.get_mut(&uuid) {
-            Some(entry) => {
-                log::debug!("old entry");
-                (entry, false)
-            }
-            None => match self
-                .allocation_table
-                .values_mut()
-                .find(|entry| entry.deleted)
-            {
-                Some(entry) => {
-                    log::debug!("deleted entry");
-                    (entry, true)
-                }
-                None => {
-                    log::debug!("new entry");
-                    let entry = AllocationTableEntry::new(uuid, self.count + 1, timestamp);
-                    self.allocation_table.insert(uuid, entry);
-                    (
-                        self.allocation_table
-                            .get_mut(&uuid)
-                            .expect("entry was just inserted"),
-                        true,
-                    )
-                }
-            },
-        };
-
-        // only write card data if it is new. else it is already written in flash
-        if is_new {
-            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(
-                    CARDS_REGION.offset + entry.offset * RawCard::SERIALIZED_SIZE as u32,
-                    &mut serialized_card,
-                )
-                .await?;
-        } else {
-            entry.last_read_date = timestamp;
-            entry.read_count += 1;
-        }
-
-        entry.deleted = false;
-
-        log::debug!("writing AllocationTableEntry to flash");
-        let mut serialized_entry: [u8; AllocationTableEntry::SERIALIZED_SIZE] =
-            [0; AllocationTableEntry::SERIALIZED_SIZE];
-        entry.binary_serialize(&mut serialized_entry, Endianness::Little);
-        self.store
-            .write_erase(
-                ALLOCATION_TABLE_REGION.offset
-                    + 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())
-            .await?;
-        Ok(())
-    }
-}

src/peripherals/storage/flash_store.rs

@@ -1,108 +0,0 @@
-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::peripherals::storage::MAGIC_REGION;
-
-#[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 FlashStore {
-    pub storage: Mutex<FlashStorage<'static>>,
-}
-
-impl FlashStore {
-    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];
-        storage.read(FLASH_ADDR + MAGIC_REGION.offset, &mut magic)?;
-        log::debug!("Magic bytes are {magic:?}");
-
-        if Self::has_magic_bytes(&mut storage)? {
-            log::info!("Skipped flash initialization, magic bytes already present.");
-        } else {
-            log::info!("Initializing flash because no magic bytes found.");
-            Self::initialize_flash(&mut storage)?;
-        }
-
-        Ok(Self {
-            storage: Mutex::new(storage),
-        })
-    }
-
-    pub async fn read(&self, offset: u32, bytes: &mut [u8]) -> Result<(), FlashStoreError> {
-        self.storage.lock().await.read(FLASH_ADDR + offset, bytes)?;
-        Ok(())
-    }
-
-    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
-            .lock()
-            .await
-            .write(FLASH_ADDR + offset, bytes)?;
-        Ok(())
-    }
-
-    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()
-        );
-        let mut lock = self.storage.lock().await;
-        lock.erase(FLASH_ADDR + offset, FLASH_ADDR + bytes.len() as u32)?;
-        lock.write(FLASH_ADDR + offset, bytes)?;
-        Ok(())
-    }
-
-    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:?}");
-
-        Ok(u32::from_ne_bytes(magic) == FLASH_INITIALIZE_MAGIC)
-    }
-
-    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)?;
-        storage.write(
-            FLASH_ADDR + MAGIC_REGION.offset,
-            &FLASH_INITIALIZE_MAGIC.to_ne_bytes(),
-        )?;
-
-        if Self::has_magic_bytes(storage)? {
-            Ok(())
-        } else {
-            Err(FlashStoreError(FlashStorageError::Other(
-                FLASH_INITIALIZE_MAGIC as i32,
-            )))
-        }
-    }
-}

src/peripherals/storage/store.rs

@@ -1,7 +0,0 @@
-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/storage.rs

@@ -0,0 +1,2 @@
+pub mod dex_db;
+pub mod nvs;

src/storage/dex_db.rs

@@ -0,0 +1 @@
+// Storage dex_db module

src/storage/nvs.rs

@@ -0,0 +1 @@
+// Storage nvs module

src/views.rs

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

src/views/card_view.rs

@@ -1,11 +1,7 @@
 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;
@@ -29,16 +25,10 @@ pub struct CardView {
 }
 
 impl Navigable for CardView {
-    fn display(
-        &self,
-        outputs: &mut Outputs,
-        _: &Peripherals,
-    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
         async move {
             let display = &mut outputs.primary_display;
-            display
-                .clear(Rgb565::BLACK)
-                .map_err(PrimaryDisplayError::from)?;
+            display.clear(Rgb565::BLACK).unwrap();
 
             let background = Rectangle::new(Point::new(0, 0), Size::new(240, 320));
             let bg_color = self.card.cardtype.clone().into();
@@ -52,60 +42,59 @@ impl Navigable for CardView {
                 style,
             )
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
             Text::new(
                 &format!("Type: {}", self.card.cardtype),
                 Point::new(20, 250),
                 style,
             )
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
             Text::new(
                 &format!("Event: {}", self.card.event),
                 Point::new(20, 260),
                 style,
             )
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
             Text::new(
                 &format!("UUID: {}", self.card.uuid),
                 Point::new(20, 270),
                 style,
             )
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
             Text::new(
                 &format!("Trait1: {}", self.card.trait1),
                 Point::new(20, 280),
                 style,
             )
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
             Text::new(
                 &format!("Trait2: {}", self.card.trait2),
                 Point::new(20, 290),
                 style,
             )
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
             Text::new(
                 &format!("Trait3: {}", self.card.trait3),
                 Point::new(20, 300),
                 style,
             )
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
             Text::new(
                 &format!("Secret: {}", self.card.secret),
                 Point::new(20, 310),
                 style,
             )
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
 
             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

@@ -1,94 +0,0 @@
-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,106 +0,0 @@
-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 alloc::boxed::Box;
-use core::error;
-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,
-        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?;
-
-            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 {
-        async move {
-            let Action::Button(input) = input else {
-                // Skip timer inputs
-                return NewState {
-                    view: View::FlashInfo(self.clone()),
-                    replace_view: true,
-                    redraw: false,
-                };
-            };
-
-            let new_menu = match input {
-                _ => View::FlashInfo(self.clone()),
-            };
-
-            NewState {
-                replace_view: matches!(new_menu, View::FlashInfo(_)),
-                view: new_menu,
-                redraw: true,
-            }
-        }
-    }
-}

src/views/journal_view.rs

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

src/views/main_menu.rs

@@ -1,8 +1,4 @@
-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::*};
@@ -26,26 +22,16 @@ pub struct MainMenu {
 }
 
 impl Navigable for MainMenu {
-    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();
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        let display = &mut outputs.primary_display;
+        display.clear(Rgb565::BLACK).unwrap();
 
-            menu_item::show(display, "Scan card", 0, self.selected)
-                .map_err(PrimaryDisplayError::from)?;
-            menu_item::show(display, "Last card", 1, 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)?;
+        menu_item::show(display, "Scan card", 0, self.selected);
+        menu_item::show(display, "Last card", 1, self.selected);
+        menu_item::show(display, "Journal", 2, self.selected);
+        menu_item::show(display, "Settings", 3, self.selected);
 
-            Ok(())
-        }
+        core::future::ready(())
     }
 
     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) -> Result<(), D::Error>
+pub fn show<D>(display: &mut D, name: &str, position: i32, selected: i32)
 where
     D: DrawTarget<Color = Rgb565>,
     D::Error: core::fmt::Debug,
@@ -24,6 +24,6 @@ where
             style
         },
     )
-    .draw(display)?;
-    Ok(())
+    .draw(display)
+    .unwrap();
 }

src/views/scan_menu.rs

@@ -1,11 +1,7 @@
-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;
@@ -37,61 +33,54 @@ pub struct ScanMenu {
 }
 
 impl Navigable for ScanMenu {
-    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;
-            let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
-            display
-                .clear(Rgb565::BLACK)
-                .map_err(PrimaryDisplayError::from)?;
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        let display = &mut outputs.primary_display;
+        let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+        display.clear(Rgb565::BLACK).unwrap();
 
-            let display_area = display.bounding_box();
+        let display_area = display.bounding_box();
 
-            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)
+        Text::new("Scanning...", Point::new(20, 30), style)
             .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+            .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)
-                .map_err(PrimaryDisplayError::from)?;
-            Ok(())
-        }
+        // 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();
+
+        // 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,18 +1,11 @@
-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;
+use crate::views::{menu_item, view::View};
 
 use embedded_graphics::pixelcolor::Rgb565;
 use embedded_graphics::prelude::RgbColor;
 use embedded_graphics_core::draw_target::DrawTarget;
-
-pub const MAX_SELECTED: i32 = 2;
+pub const MAX_SELECTED: i8 = 2;
 
 #[derive(Debug, Clone)]
 pub struct SettingsMenu {
@@ -20,63 +13,21 @@ pub struct SettingsMenu {
 }
 
 impl Navigable for SettingsMenu {
-    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();
-            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 display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        let display = &mut outputs.primary_display;
+        display.clear(Rgb565::BLACK).unwrap();
+        menu_item::show(display, "System Inforation", 0, self.selected);
+        menu_item::show(display, "Wifi Information", 1, self.selected);
+
+        core::future::ready(())
     }
 
     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::Settings(self.clone()),
-                    replace_view: true,
-                    redraw: false,
-                };
-            };
-
-            let new_menu = match input {
-                ButtonAction::Up => {
-                    let new_selected = if (self.selected - 1) < 0 {
-                        MAX_SELECTED - 1
-                    } else {
-                        self.selected - 1
-                    };
-                    View::Settings(SettingsMenu {
-                        selected: new_selected,
-                    })
-                }
-                ButtonAction::Down => {
-                    let new_selected = self.selected.wrapping_add(1) % MAX_SELECTED;
-                    View::Settings(SettingsMenu {
-                        selected: new_selected,
-                    })
-                }
-                ButtonAction::Ok => match self.selected {
-                    2 => View::FlashInfo(FlashInfoView {}),
-                    _ => View::Settings(self.clone()),
-                },
-                _ => View::Settings(self.clone()),
-            };
-
             NewState {
-                replace_view: matches!(new_menu, View::Settings(_)),
-                view: new_menu,
-                redraw: true,
+                view: View::Settings(SettingsMenu { selected: 0 }),
+                replace_view: true,
+                redraw: !matches!(input, Action::Timer),
             }
         }
     }

src/views/view.rs

@@ -1,43 +1,30 @@
 use crate::navigation::outputs::Outputs;
-use crate::peripherals::Peripherals;
 use crate::views::card_view::CardView;
 use crate::views::{
-    error_view::ErrorView, flash_info_view::FlashInfoView, journal_view::JournalView,
-    main_menu::MainMenu, scan_menu::ScanMenu, settings_menu::SettingsMenu,
+    journal_view::JournalView, 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),
     Journal(JournalView),
     Card(CardView),
-    FlashInfo(FlashInfoView),
 }
 
 impl Navigable for View {
-    fn display(
-        &self,
-        outputs: &mut Outputs,
-        peripherals: &Peripherals,
-    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
         async move {
             match self {
-                View::Error(error_view) => error_view.display(outputs, peripherals).await,
-                View::Main(main_menu) => main_menu.display(outputs, peripherals).await,
-                View::Scan(scan_menu) => scan_menu.display(outputs, peripherals).await,
-                View::Settings(settings_menu) => settings_menu.display(outputs, peripherals).await,
-                View::Journal(journal_view) => journal_view.display(outputs, peripherals).await,
-                View::Card(card_view) => card_view.display(outputs, peripherals).await,
-                View::FlashInfo(flash_info_view) => {
-                    flash_info_view.display(outputs, peripherals).await
-                }
+                View::Main(main_menu) => main_menu.display(outputs).await,
+                View::Scan(scan_menu) => scan_menu.display(outputs).await,
+                View::Settings(settings_menu) => settings_menu.display(outputs).await,
+                View::Journal(journal_view) => journal_view.display(outputs).await,
+                View::Card(card_view) => card_view.display(outputs).await,
             }
         }
     }
@@ -48,13 +35,11 @@ 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,
                 View::Journal(journal_view) => journal_view.handle_input(input).await,
                 View::Card(card_view) => card_view.handle_input(input).await,
-                View::FlashInfo(flash_info_view) => flash_info_view.handle_input(input).await,
             }
         }
     }