Recover from init fail

Cargo.lock

@@ -53,6 +53,12 @@ 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"
@@ -73,9 +79,9 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
 [[package]]
 name = "base64"
-version = "0.22.1"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "base64-simd"
@@ -96,6 +102,29 @@ 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"
@@ -318,7 +347,8 @@ dependencies = [
 name = "creaturedex"
 version = "0.1.0"
 dependencies = [
- "base64 0.22.1",
+ "base64 0.23.1",
+ "binary_serde",
  "ch1115",
  "critical-section",
  "display-interface-spi",
@@ -332,18 +362,20 @@ dependencies = [
  "embedded-hal-async",
  "embedded-hal-bus",
  "embedded-io 0.7.1",
+ "embedded-storage",
  "esp-alloc",
  "esp-bootloader-esp-idf",
  "esp-hal",
  "esp-hal-wifimanager",
  "esp-println",
  "esp-rtos",
+ "esp-storage",
  "i2c-character-display",
  "ili9341",
  "log",
- "ndef",
  "num_enum",
  "pn532",
+ "static_assertions",
 ]
 
 [[package]]
@@ -592,26 +624,6 @@ dependencies = [
  "syn 2.0.119",
 ]
 
-[[package]]
-name = "derive_more"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
-dependencies = [
- "derive_more-impl",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -1701,9 +1713,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "i2c-character-display"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86a620ec16541e28c0e52ce21cd23d734a5d7efaae3d609b2a58694b0ef67739"
+checksum = "6170902cbfd6e5855a1fa8a75dc68991bb98220c24135a5cf23ce74d32ddcccf"
 dependencies = [
  "bitfield 0.17.0",
  "embedded-hal 1.0.0",
@@ -2034,17 +2046,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d5439c4ad607c3c23abf66de8c8bf57ba8adcd1f129e699851a6e43935d339d"
 
-[[package]]
-name = "ndef"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39081400340c14a9fcbb0122c311aca4e34ec2d19e3136613638ae7e2a362dbc"
-dependencies = [
- "derive_more",
- "heapless 0.8.0",
- "rustversion",
-]
-
 [[package]]
 name = "nonmax"
 version = "0.5.5"
@@ -2828,6 +2829,12 @@ 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"
@@ -3305,6 +3312,26 @@ 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

@@ -9,7 +9,11 @@ name = "creaturedex"
 path = "./src/bin/main.rs"
 
 [dependencies]
-esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
+esp-hal = { version = "~1.1.0", features = [
+  "esp32s3",
+  "log-04",
+  "unstable",
+] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
 
 esp-rtos = { version = "0.3.0", features = [
   "embassy",
@@ -24,8 +28,7 @@ log                    = "0.4.27"
 
 critical-section = "1.2.0"
 embedded-io = "0.7.1"
-embassy-executor = { version = "0.10.0", features = [
-] }
+embassy-executor = { version = "0.10.0", features = [] }
 embassy-time = { version = "0.5.1", default-features = false }
 embassy-futures = "0.1.2"
 esp-alloc = "0.10.0"
@@ -40,14 +43,20 @@ embedded-hal = "1.0.0"
 embedded-hal-bus = "0.3.0"
 embedded-graphics = "0.8.2"
 embedded-graphics-core = "0.4.1"
-base64 = { version = "0.22", default-features = false, features = ["alloc"] }
+base64 = { version = "0.23.1", default-features = false, features = ["alloc"] }
 pn532 = "0.5.0"
-ndef = "0.5.0"
 num_enum = { version = "0.7.6", default-features = false }
 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 }
+
+[build-dependencies]
+log = "0.4.27"
 
 
 [patch.crates-io]

build.rs

@@ -1,4 +1,5 @@
 fn main() {
+    generate_filter_snippet();
     linker_be_nice();
     // make sure linkall.x is the last linker script (otherwise might cause problems with flip-link)
     println!("cargo:rustc-link-arg=-Tlinkall.x");
@@ -68,3 +69,165 @@ fn linker_be_nice() {
         std::env::current_exe().unwrap().display()
     );
 }
+
+// Taken over from esp_println because impossible to just extend their existing env logger.
+// https://github.com/esp-rs/esp-hal/blob/8fa6d7e985e724d6ad998e34307429b0920da370/esp-println/build.rs
+fn generate_filter_snippet() {
+    use log::LevelFilter;
+    use std::{env, path::Path};
+
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+    let dest_path = Path::new(&out_dir).join("log_filter.rs");
+
+    let filter = env::var("ESP_LOG");
+    let snippet = if let Ok(filter) = filter {
+        let res = parse_spec(&filter);
+
+        if !res.errors.is_empty() {
+            panic!("Error parsing `ESP_LOG`: {:?}", res.errors);
+        } else {
+            let max = res
+                .directives
+                .iter()
+                .map(|v| v.level)
+                .max()
+                .unwrap_or(LevelFilter::Off);
+            let max = match max {
+                LevelFilter::Off => "Off",
+                LevelFilter::Error => "Error",
+                LevelFilter::Warn => "Warn",
+                LevelFilter::Info => "Info",
+                LevelFilter::Debug => "Debug",
+                LevelFilter::Trace => "Trace",
+            };
+
+            let mut snippet = String::new();
+
+            snippet.push_str(&format!(
+                "pub(crate) const FILTER_MAX: log::LevelFilter = log::LevelFilter::{max};"
+            ));
+
+            snippet
+                .push_str("pub(crate) fn is_enabled(level: log::Level, _target: &str) -> bool {");
+
+            let mut global_level = None;
+            for directive in res.directives {
+                let level = match directive.level {
+                    LevelFilter::Off => "Off",
+                    LevelFilter::Error => "Error",
+                    LevelFilter::Warn => "Warn",
+                    LevelFilter::Info => "Info",
+                    LevelFilter::Debug => "Debug",
+                    LevelFilter::Trace => "Trace",
+                };
+
+                if let Some(name) = directive.name {
+                    // If a prefix matches, don't continue to the next directive
+                    snippet.push_str(&format!(
+                        "if _target.starts_with(\"{name}\") {{ return level <= log::LevelFilter::{level}; }}"
+                    ));
+                } else {
+                    if global_level.is_some() {
+                        panic!("Multiple global log levels specified in `ESP_LOG`");
+                    }
+                    global_level = Some(level);
+                }
+            }
+
+            // Place the fallback rule at the end
+            if let Some(level) = global_level {
+                snippet.push_str(&format!("level <= log::LevelFilter::{level}"));
+            } else {
+                snippet.push_str(" false");
+            }
+            snippet.push('}');
+            snippet
+        }
+    } else {
+        "pub(crate) const FILTER_MAX: log::LevelFilter = log::LevelFilter::Off; pub(crate) fn is_enabled(_level: log::Level, _target: &str) -> bool { true }".to_string()
+    };
+
+    std::fs::write(&dest_path, &snippet).unwrap();
+}
+
+#[derive(Default, Debug)]
+struct ParseResult {
+    pub(crate) directives: Vec<Directive>,
+    pub(crate) errors: Vec<String>,
+}
+
+impl ParseResult {
+    fn add_directive(&mut self, directive: Directive) {
+        self.directives.push(directive);
+    }
+
+    fn add_error(&mut self, message: String) {
+        self.errors.push(message);
+    }
+}
+
+#[derive(Debug)]
+struct Directive {
+    pub(crate) name: Option<String>,
+    pub(crate) level: log::LevelFilter,
+}
+
+/// Parse a logging specification string (e.g:
+/// `crate1,crate2::mod3,crate3::x=error/foo`) and return a vector with log
+/// directives.
+fn parse_spec(spec: &str) -> ParseResult {
+    use log::LevelFilter;
+
+    let mut result = ParseResult::default();
+
+    let mut parts = spec.split('/');
+    let mods = parts.next();
+
+    if let Some(m) = mods {
+        for s in m.split(',').map(|ss| ss.trim()) {
+            if s.is_empty() {
+                continue;
+            }
+            let mut parts = s.split('=');
+            let (log_level, name) =
+                match (parts.next(), parts.next().map(|s| s.trim()), parts.next()) {
+                    (Some(part0), None, None) => {
+                        // if the single argument is a log-level string or number,
+                        // treat that as a global fallback
+                        match part0.parse() {
+                            Ok(num) => (num, None),
+                            Err(_) => (LevelFilter::max(), Some(part0)),
+                        }
+                    }
+                    (Some(part0), Some(""), None) => (LevelFilter::max(), Some(part0)),
+                    (Some(part0), Some(part1), None) => {
+                        if let Ok(num) = part1.parse() {
+                            (num, Some(part0))
+                        } else {
+                            result.add_error(format!("invalid logging spec '{part1}'"));
+                            continue;
+                        }
+                    }
+                    _ => {
+                        result.add_error(format!("invalid logging spec '{s}'"));
+                        continue;
+                    }
+                };
+
+            result.add_directive(Directive {
+                name: name.map(|s| s.to_owned()),
+                level: log_level,
+            });
+        }
+    }
+
+    // Sort by length so that the most specific prefixes come first
+    result
+        .directives
+        .sort_by(|a, b| match (a.name.as_ref(), b.name.as_ref()) {
+            (Some(a), Some(b)) => b.len().cmp(&a.len()),
+            _ => std::cmp::Ordering::Equal,
+        });
+
+    result
+}

src/background_tasks.rs

@@ -0,0 +1,3 @@
+mod nfc;
+
+pub use nfc::nfc_scanner;

src/background_tasks/nfc.rs

@@ -0,0 +1,61 @@
+use crate::storage::cardstore::CardStore;
+use embedded_hal_bus::i2c::AtomicDevice;
+use esp_hal::rtc_cntl::Rtc;
+use esp_hal::{Blocking, i2c::master::I2c, time::Instant};
+
+use crate::{
+    card::{decoder::split_nfc_hex, model::Card},
+    drivers::nfc_pn532::NfcPn532Driver,
+    navigation::navigation::CARD_DATA,
+};
+
+#[embassy_executor::task]
+#[allow(
+    clippy::large_stack_frames,
+    reason = "ignoring this for now because it still works"
+)]
+pub async fn nfc_scanner(
+    mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>,
+    mut card_store: CardStore,
+    rtc: Rtc<'static>,
+) {
+    loop {
+        while CARD_DATA.lock().await.is_none() {
+            let start = Instant::now();
+            match nfc_driver.read_card_data().await {
+                Ok(card_data) => {
+                    let Some(split_data) = split_nfc_hex(&card_data) else {
+                        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 card_store.save_raw_card(split_data, rtc.current_time_us()) {
+                        Ok(()) => {}
+                        Err(error) => {
+                            log::error!("Error storing card in flash: {:?}", error)
+                        }
+                    }
+
+                    let elapsed_ms = start.elapsed().as_millis();
+                    log::info!(
+                        "NFC read duration: {} ms, card data length: {}",
+                        elapsed_ms,
+                        card_data.len()
+                    );
+                }
+                Err(_) => {
+                    log::info!("No NFC card found");
+                }
+            }
+        }
+        embassy_time::Timer::after(embassy_time::Duration::from_millis(1000)).await;
+    }
+}

src/bin/main.rs

@@ -7,17 +7,20 @@
 )]
 #![deny(clippy::large_stack_frames)]
 
-use alloc::boxed::Box;
-use creaturedex::card::decoder::split_nfc_hex;
-use creaturedex::card::model::Card;
-use creaturedex::display::shared_bus::{DualSecondaryDisplay, init_dual_displays};
-use creaturedex::display::tertiary_lcd::{init_tertiary_lcd, write_wrapped};
+use creaturedex::background_tasks;
+use creaturedex::drivers::i2c_bus::I2cBusPinConfiguration;
 use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
+use creaturedex::drivers::secondary_oled::SecondaryDisplay;
+use creaturedex::drivers::spi_bus;
+use creaturedex::drivers::tertiary_lcd::{
+    BOX, EMPTY, EXAMPLE, HEART, TertiaryDisplay, TertiaryDisplayPinConfiguration,
+};
 use creaturedex::navigation::inputs::Inputs;
-use creaturedex::navigation::navigation::{self, CARD_DATA};
-use creaturedex::network::wifi::setup_wifi;
+use creaturedex::navigation::navigation::{self};
+use creaturedex::navigation::outputs::Outputs;
+use creaturedex::storage::cardstore::CardStore;
+use creaturedex::storage::store::Store;
 use embassy_executor::Spawner;
-use embassy_time::Instant;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::{
     mono_font::{MonoTextStyle, ascii::FONT_6X10},
@@ -25,14 +28,13 @@ use embedded_graphics::{
     text::Text,
 };
 use embedded_hal_bus::i2c::AtomicDevice;
-use embedded_hal_bus::util::AtomicCell;
-use esp_hal::Blocking;
 use esp_hal::clock::CpuClock;
-use esp_hal::gpio::{Input, InputConfig, Level, Output, OutputConfig, Pull};
-use esp_hal::i2c::master::{Config as I2cConfig, I2c};
+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);
@@ -53,7 +55,7 @@ esp_bootloader_esp_idf::esp_app_desc!();
 )]
 #[esp_rtos::main]
 async fn main(spawner: Spawner) {
-    esp_println::logger::init_logger_from_env();
+    creaturedex::logging::init();
 
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
     let peripherals = esp_hal::init(config);
@@ -65,50 +67,57 @@ async fn main(spawner: Spawner) {
     let timg0 = TimerGroup::new(peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
 
-    let (display, oled) = Box::leak(Box::new(init_dual_displays(
-        peripherals.SPI2,
-        peripherals.GPIO36, // sck
-        peripherals.GPIO35, // mosi
-        peripherals.GPIO37, // miso
-        peripherals.GPIO11, // primary cs
-        peripherals.GPIO13, // oled cs
-        peripherals.GPIO10, // primary reset
-        peripherals.GPIO47, // secondary reset
-        peripherals.GPIO12, // shared dc
-    )));
-
-    let _secondary_oled_cs_2 = Output::new(
-        peripherals.GPIO14,
-        Level::High,
-        OutputConfig::default(),
-    );
-    let _secondary_oled_cs_3 = Output::new(
-        peripherals.GPIO21,
-        Level::High,
-        OutputConfig::default(),
+    let (primary, mut secondaries) = retry(
+        5,
+        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,
+        },
+        spi_bus::DisplayPinConfiguration::build,
     );
 
-    let config = I2cConfig::default().with_frequency(esp_hal::time::Rate::from_khz(400));
-    let i2c = match I2c::new(peripherals.I2C0, config) {
-        Ok(bus) => bus
-            .with_sda(peripherals.GPIO17)
-            .with_scl(peripherals.GPIO18),
-        Err(e) => {
-            log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
-            panic!("Shared I2C bus initialization failed");
-        }
+    // Initialize the shared I2C bus using the refactored i2c_bus module.
+    let shared_i2c = {
+        use alloc::boxed::Box;
+        let bus = retry(5, I2cBusPinConfiguration {
+            i2c_peripheral: peripherals.I2C0,
+            scl: peripherals.GPIO18,
+            sda: peripherals.GPIO17,
+        }, I2cBusPinConfiguration::build);
+        Box::leak(Box::new(bus))
     };
-    let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
-    log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
 
-    let mut lcd = init_tertiary_lcd(AtomicDevice::new(shared_i2c));
-    if let Err(_) = write_wrapped(&mut lcd, "Testing more than 16 chars what happens now?") {
+    let mut lcd: TertiaryDisplay = retry(
+        5,
+        TertiaryDisplayPinConfiguration { i2c: shared_i2c },
+        TertiaryDisplayPinConfiguration::build,
+    );
+    lcd.load_charset(EXAMPLE).unwrap();
+    let h = EXAMPLE[HEART];
+    let e = EXAMPLE[EMPTY];
+    let b = EXAMPLE[BOX];
+    if let Err(e) = lcd.write(&alloc::format!(
+        "Custom symbols: {h}{e}{b} And more stuff to wrap and cut off please."
+    )) {
         log::error!(
-            "Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses"
+            "Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses: {e}"
         );
     }
 
-    setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
+    let store = Store::new(peripherals.FLASH).expect("Could not initialize Flash Store");
+    let cardstore = CardStore::new(store).expect("Could not initialize Card Store");
+
+    let rtc = Rtc::new(peripherals.LPWR);
+    //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() {
@@ -127,52 +136,50 @@ async fn main(spawner: Spawner) {
         ok: Input::new(peripherals.GPIO0, button_config),
     };
 
-    display_shit(oled);
+    display_shit(&mut secondaries[0], "foo 1");
+    display_shit(&mut secondaries[1], "bar 1");
+    display_shit(&mut secondaries[2], "baz 1");
+
+    let outputs = {
+        let [sec_1, sec_2, sec_3] = secondaries;
+        Outputs {
+            primary_display: primary,
+            secondary_display_1: sec_1,
+            secondary_display_2: sec_2,
+            secondary_display_3: sec_3,
+            tertiary_display: lcd,
+            _led_a: (),
+        }
+    };
 
     log::info!("Setup complete, entering main loop");
-    spawner.spawn(navigation::run(inputs, display).expect("run task failed"));
-    spawner.spawn(nfc_driver_task(nfc_driver).expect("nfc driver task failed"));
-}
-
-#[embassy_executor::task]
-async fn nfc_driver_task(
-    mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>,
-) {
-    loop {
-        while CARD_DATA.lock().await.is_none() {
-            let start = Instant::now();
-            match nfc_driver.read_card_data().await {
-                Ok(card_data) => {
-                    let Some(split_data) = split_nfc_hex(&card_data) else {
-                        log::error!("Failed to split NFC card data");
-                        continue;
-                    };
-                    CARD_DATA
-                        .lock()
-                        .await
-                        .replace(Card::try_from(split_data).unwrap());
-                    let elapsed_ms = start.elapsed().as_millis();
-                    log::info!(
-                        "NFC read duration: {} ms, card data length: {}",
-                        elapsed_ms,
-                        card_data.len()
+    spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
+    spawner.spawn(
+        background_tasks::nfc_scanner(nfc_driver, cardstore, rtc).expect("nfc scanner task failed"),
     );
-                }
-                Err(_) => {
-                    log::info!("No NFC card found");
-                }
-            }
-        }
-        embassy_time::Timer::after(embassy_time::Duration::from_millis(1000)).await;
-    }
+    core::future::pending::<()>().await
 }
 
-fn display_shit(oled: &mut DualSecondaryDisplay<'static>) {
+fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
     oled.clear().unwrap();
 
     let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
-    Text::new("Hello OLED", Point::new(10, 20), text_style)
+    Text::new(text, Point::new(10, 20), text_style)
         .draw(oled)
         .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,22 +1,23 @@
 use core::fmt::Display;
 
-use crate::card::model::NfcPayload;
+use crate::card::model::RawCard;
 use alloc::string::{String, ToString};
 
-pub fn split_nfc_hex(payload: &[u8]) -> Option<NfcPayload<'_>> {
+pub fn split_nfc_hex(payload: &[u8]) -> Option<RawCard> {
     if payload.len() < 0x35A {
         return None;
     }
 
-    Some(NfcPayload {
-        event_encoding: &payload[0..2],
+    Some(RawCard {
+        event_encoding: payload[0..2].try_into().ok()?,
         card_type: payload[2],
-        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],
+        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(),
     })
 }
 

src/card/model.rs

@@ -6,18 +6,24 @@ use num_enum::FromPrimitive;
 use crate::card::decoder::{Events, decode_known_event, decode_packed_card_text, decode_secret};
 use embedded_graphics::pixelcolor::{Rgb565, Rgb888};
 
-#[derive(Debug, Clone, Copy)]
-pub struct NfcPayload<'a> {
-    pub event_encoding: &'a [u8],
+use binary_serde::BinarySerde;
+
+#[derive(Debug, BinarySerde, PartialEq, Eq, Clone, Copy)]
+#[repr(C)]
+pub struct RawCard {
+    pub event_encoding: [u8; 2],
     pub card_type: u8,
-    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],
+    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],
 }
 
+static_assertions::const_assert!(RawCard::SERIALIZED_SIZE.is_multiple_of(4));
+
 #[derive(Debug, Clone, Eq, PartialEq, FromPrimitive)]
 #[repr(u8)]
 pub enum CardType {
@@ -48,9 +54,9 @@ impl Display for CardType {
 }
 
 pub type PrimaryColor = Rgb565;
-impl Into<PrimaryColor> for CardType {
-    fn into(self) -> PrimaryColor {
-        match self {
+impl From<CardType> for PrimaryColor {
+    fn from(val: CardType) -> Self {
+        match val {
             CardType::Default => Rgb888::new(0xD8, 0x68, 0x30).into(),
             CardType::Blueprint => Rgb888::new(0x6D, 0x81, 0xFF).into(),
             CardType::CYBER => Rgb888::new(0xFF, 0xFF, 0x04).into(),
@@ -64,9 +70,9 @@ impl Into<PrimaryColor> for CardType {
 }
 
 pub type Palette = [Rgb565; 16];
-impl Into<Palette> for CardType {
-    fn into(self) -> Palette {
-        match self {
+impl From<CardType> for Palette {
+    fn from(val: CardType) -> Self {
+        match val {
             CardType::Default => [
                 Rgb888::new(31, 23, 35).into(),
                 Rgb888::new(60, 47, 82).into(),
@@ -222,7 +228,7 @@ pub struct Sprite {
 
 #[derive(Debug, Clone)]
 pub struct Card {
-    pub uuid: String,
+    pub uuid: u32,
     pub event: Events,
     pub cardtype: CardType,
     pub name: String,
@@ -235,17 +241,19 @@ pub struct Card {
     pub sprite: Sprite,
 }
 
-impl<'a> TryFrom<NfcPayload<'a>> for Card {
+impl TryFrom<RawCard> for Card {
     type Error = &'static str;
 
-    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);
+    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);
         let sprite = Sprite {
-            data: payload.sprite.to_vec(),
+            data: raw_card.sprite.to_vec(),
         };
         Ok(Self {
             uuid,

src/display.rs

@@ -1,5 +1 @@
-pub mod primary_lcd;
-pub mod secondary_oled;
-pub mod shared_bus;
 pub mod sprite;
-pub mod tertiary_lcd;

src/display/primary_lcd.rs

@@ -1,43 +0,0 @@
-use display_interface_spi::SPIInterface;
-use embedded_graphics::draw_target::DrawTarget;
-use embedded_graphics::pixelcolor::Rgb565;
-use embedded_graphics::prelude::RgbColor;
-use embedded_hal::digital::OutputPin as EhOutputPin;
-use embedded_hal_bus::spi::AtomicDevice;
-use embedded_hal_bus::util::AtomicCell;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
-use ili9341::{DisplaySize240x320, Ili9341, Orientation};
-
-pub type PrimaryLcdDisplay<'a, BUS, DC, RES> =
-    Ili9341<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RES>;
-
-pub fn init_primary_lcd_on_bus<'a, BUS, CS, RES, DC>(
-    spi_bus: &'a AtomicCell<BUS>,
-    cs: CS,
-    reset: RES,
-    dc: DC,
-    delay: &mut Delay,
-) -> PrimaryLcdDisplay<'a, BUS, DC, RES>
-where
-    BUS: embedded_hal::spi::SpiBus,
-    CS: OutputPin + 'static,
-    RES: EhOutputPin,
-    DC: EhOutputPin,
-{
-    let cs_pin = Output::new(cs, Level::High, OutputConfig::default());
-    let spi_dev = AtomicDevice::new(spi_bus, cs_pin, *delay).unwrap();
-    let iface = SPIInterface::new(spi_dev, dc);
-
-    let mut display = Ili9341::new(
-        iface,
-        reset,
-        delay,
-        Orientation::Portrait,
-        DisplaySize240x320,
-    )
-    .unwrap();
-
-    display.clear(Rgb565::BLACK).unwrap();
-    display
-}

src/display/secondary_oled.rs

@@ -1,34 +0,0 @@
-use ch1115::{Ch1115, Size128x64};
-use display_interface_spi::SPIInterface;
-use embedded_hal::digital::OutputPin as EhOutputPin;
-use embedded_hal_bus::spi::AtomicDevice;
-use embedded_hal_bus::util::AtomicCell;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
-
-pub type SecondaryOledDisplay<'a, BUS, RST, DC> =
-    Ch1115<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RST, Size128x64>;
-
-pub fn init_secondary_oled_on_bus<'a, BUS, CS, RES, DC>(
-    spi_bus: &'a AtomicCell<BUS>,
-    cs: CS,
-    res: RES,
-    dc: DC,
-    delay: &mut Delay,
-) -> SecondaryOledDisplay<'a, BUS, RES, DC>
-where
-    BUS: embedded_hal::spi::SpiBus,
-    CS: OutputPin + 'static,
-    RES: EhOutputPin,
-    DC: EhOutputPin,
-{
-    let cs_pin = Output::new(cs, Level::High, OutputConfig::default());
-    let spi_dev = AtomicDevice::new(spi_bus, cs_pin, *delay).unwrap();
-    let interface = SPIInterface::new(spi_dev, dc);
-
-    let mut display = Ch1115::new(interface, res, Size128x64);
-
-    display.init(&mut Delay::new()).unwrap();
-
-    display
-}

src/display/shared_bus.rs

@@ -1,113 +0,0 @@
-use alloc::boxed::Box;
-use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use embedded_hal::digital::ErrorType;
-use embedded_hal::digital::OutputPin as EhOutputPin;
-use embedded_hal_bus::util::AtomicCell;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::interconnect::{PeripheralInput, PeripheralOutput};
-use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
-use esp_hal::spi::Mode;
-use esp_hal::spi::master::{Config as SpiConfig, Spi};
-use esp_hal::time::Rate;
-
-use crate::display::secondary_oled::{SecondaryOledDisplay, init_secondary_oled_on_bus};
-use crate::display::primary_lcd::{PrimaryLcdDisplay, init_primary_lcd_on_bus};
-
-use core::cell::RefCell;
-use embassy_sync::blocking_mutex::Mutex as BlockingMutex;
-
-#[derive(Clone)]
-pub struct SharedPin<'a, P> {
-    mutex: &'a BlockingMutex<CriticalSectionRawMutex, RefCell<P>>,
-}
-
-impl<'a, P> SharedPin<'a, P> {
-    pub fn new(mutex: &'a BlockingMutex<CriticalSectionRawMutex, RefCell<P>>) -> Self {
-        Self { mutex }
-    }
-
-    pub fn pre_wrap(pin: P) -> &'static BlockingMutex<CriticalSectionRawMutex, RefCell<P>> {
-        let mutexed = BlockingMutex::new(RefCell::new(pin));
-        Box::leak(Box::new(mutexed))
-    }
-}
-
-impl<'a, P: EhOutputPin> ErrorType for SharedPin<'a, P> {
-    type Error = P::Error;
-}
-
-impl<'a, P: EhOutputPin> EhOutputPin for SharedPin<'a, P> {
-    fn set_low(&mut self) -> Result<(), Self::Error> {
-        self.mutex.lock(|p| p.borrow_mut().set_low())
-    }
-
-    fn set_high(&mut self) -> Result<(), Self::Error> {
-        self.mutex.lock(|p| p.borrow_mut().set_high())
-    }
-}
-
-pub type DisplaySpiBus = Spi<'static, esp_hal::Blocking>;
-pub type DualPrimaryDisplay<'a> =
-    PrimaryLcdDisplay<'a, DisplaySpiBus, SharedPin<'a, Output<'a>>, SharedPin<'a, Output<'a>>>;
-pub type DualSecondaryDisplay<'a> =
-    SecondaryOledDisplay<'a, DisplaySpiBus, SharedPin<'a, Output<'a>>, SharedPin<'a, Output<'a>>>;
-
-pub fn init_dual_displays<SPI, SCK, MOSI, MISO, CS1, CS2, RES1, RES2, DC>(
-    spi_peripheral: SPI,
-    sck: SCK,
-    mosi: MOSI,
-    miso: MISO,
-    cs_primary: CS1,
-    cs_secondary: CS2,
-    reset_primary: RES1,
-    reset_secondary: RES2,
-    dc_pin: DC,
-) -> (DualPrimaryDisplay<'static>, DualSecondaryDisplay<'static>)
-where
-    SPI: esp_hal::spi::master::Instance + 'static,
-    SCK: PeripheralOutput<'static>,
-    MOSI: PeripheralOutput<'static>,
-    MISO: PeripheralInput<'static>,
-    CS1: OutputPin + 'static,
-    CS2: OutputPin + 'static,
-    RES1: OutputPin + 'static,
-    RES2: OutputPin + 'static,
-    DC: OutputPin + 'static,
-{
-    let spi = Spi::new(
-        spi_peripheral,
-        SpiConfig::default()
-            .with_frequency(Rate::from_khz(20_000))
-            .with_mode(Mode::_0),
-    )
-    .unwrap()
-    .with_sck(sck)
-    .with_mosi(mosi)
-    .with_miso(miso);
-
-    let bus_static: &'static AtomicCell<_> = Box::leak(Box::new(AtomicCell::new(spi)));
-    let reset_primary_static =
-        SharedPin::pre_wrap(Output::new(reset_primary, Level::High, OutputConfig::default()));
-    let reset_secondary_static =
-        SharedPin::pre_wrap(Output::new(reset_secondary, Level::High, OutputConfig::default()));
-    let dc_static = SharedPin::pre_wrap(Output::new(dc_pin, Level::High, OutputConfig::default()));
-    let mut delay = Delay::new();
-
-    let primary = init_primary_lcd_on_bus(
-        bus_static,
-        cs_primary,
-        SharedPin::new(reset_primary_static),
-        SharedPin::new(dc_static),
-        &mut delay,
-    );
-
-    let secondary = init_secondary_oled_on_bus(
-        bus_static,
-        cs_secondary,
-        SharedPin::new(reset_secondary_static),
-        SharedPin::new(dc_static),
-        &mut delay,
-    );
-
-    (primary, secondary)
-}

src/display/sprite.rs

@@ -47,10 +47,7 @@ where
             let width = u32::try_from(end_x - start_x).unwrap();
             let height = u32::try_from(end_y - start_y).unwrap();
 
-            let area = Rectangle::new(
-                Point::new(start_x.try_into().unwrap(), start_y.try_into().unwrap()),
-                Size::new(width, height),
-            );
+            let area = Rectangle::new(Point::new(start_x, start_y), Size::new(width, height));
 
             let _ = ili9341.fill_solid(&area, color);
         }

src/display/tertiary_lcd.rs

@@ -1,100 +0,0 @@
-use embedded_hal::i2c::I2c;
-use esp_hal::delay::Delay;
-use i2c_character_display::{CharacterDisplayPCF8574T, LcdDisplayType};
-use log::error;
-
-pub type TertiaryLcd<I2C> = CharacterDisplayPCF8574T<I2C, Delay>;
-
-pub fn init_tertiary_lcd<I2C>(i2c: I2C) -> TertiaryLcd<I2C>
-where
-    I2C: I2c,
-{
-    let mut lcd = CharacterDisplayPCF8574T::new(i2c, LcdDisplayType::Lcd16x2, Delay::new());
-    match lcd.init() {
-        Ok(()) => {
-            log::info!("I2C tertiary LCD initialized on PCF8574T at address 0x27");
-            lcd
-        }
-        Err(_) => {
-            error!(
-                "I2C tertiary LCD init failed on PCF8574T at address 0x27; check bus wiring, power, and device address"
-            );
-            panic!("tertiary LCD initialization failed");
-        }
-    }
-}
-
-pub fn write_line<I2C>(
-    lcd: &mut TertiaryLcd<I2C>,
-    line: u8,
-    text: &str,
-) -> Result<(), i2c_character_display::CharacterDisplayError<I2C>>
-where
-    I2C: I2c,
-{
-    if let Err(e) = lcd.set_cursor(0, line) {
-        error!("I2C LCD cursor move failed on line {line}; bus or device may be unavailable");
-        return Err(e);
-    }
-    if let Err(e) = lcd.print(text) {
-        error!(
-            "I2C LCD print failed on line {line}; payload length={} and device may be busy or disconnected",
-            text.len()
-        );
-        return Err(e);
-    }
-    Ok(())
-}
-
-pub fn write_wrapped<I2C>(
-    lcd: &mut TertiaryLcd<I2C>,
-    text: &str,
-) -> Result<(), i2c_character_display::CharacterDisplayError<I2C>>
-where
-    I2C: I2c,
-{
-    const DISPLAY_WIDTH: usize = 16;
-    const DISPLAY_ROWS: usize = 2;
-
-    if let Err(e) = lcd.clear() {
-        error!(
-            "I2C LCD clear failed before wrapped write; check the shared bus and display response"
-        );
-        return Err(e);
-    }
-
-    let mut offset = 0;
-    for row in 0..DISPLAY_ROWS {
-        let remaining = &text[offset..];
-        if remaining.is_empty() {
-            return Ok(());
-        }
-
-        let chunk = if remaining.len() > DISPLAY_WIDTH {
-            &remaining[..DISPLAY_WIDTH]
-        } else {
-            remaining
-        };
-
-        if let Err(e) = lcd.set_cursor(0, row as u8) {
-            error!(
-                "I2C LCD cursor move failed while writing wrapped row {row}; bus may be busy or device unresponsive"
-            );
-            return Err(e);
-        }
-        if let Err(e) = lcd.print(chunk) {
-            error!(
-                "I2C LCD wrapped write failed on row {row}; chunk length={} and text may exceed display width",
-                chunk.len()
-            );
-            return Err(e);
-        }
-        offset += chunk.len();
-
-        if offset >= text.len() {
-            return Ok(());
-        }
-    }
-
-    Ok(())
-}

src/drivers.rs

@@ -1 +1,6 @@
+pub mod i2c_bus;
 pub mod nfc_pn532;
+pub mod primary_lcd;
+pub mod secondary_oled;
+pub mod spi_bus;
+pub mod tertiary_lcd;

src/drivers/i2c_bus.rs

@@ -0,0 +1,38 @@
+use embedded_hal_bus::i2c::AtomicDevice;
+use embedded_hal_bus::util::AtomicCell;
+use esp_hal::gpio::interconnect::PeripheralInput;
+use esp_hal::i2c::master::Config;
+use esp_hal::{gpio::interconnect::PeripheralOutput, i2c::master::I2c};
+
+type InnerI2cBus<'a> = esp_hal::i2c::master::I2c<'a, esp_hal::Blocking>;
+pub type I2cBus<'a> = &'a AtomicCell<InnerI2cBus<'a>>;
+pub type I2cDevice<'a> = AtomicDevice<'a, esp_hal::i2c::master::I2c<'a, esp_hal::Blocking>>;
+
+pub struct I2cBusPinConfiguration<I2C, SCL, SDA> {
+    pub i2c_peripheral: I2C,
+    pub scl: SCL,
+    pub sda: SDA,
+}
+
+impl<'a, I2C, SCL, SDA> I2cBusPinConfiguration<I2C, SCL, SDA>
+where
+    I2C: esp_hal::i2c::master::Instance + 'a,
+    SCL: PeripheralOutput<'a> + PeripheralInput<'a>,
+    SDA: PeripheralOutput<'a> + PeripheralInput<'a>,
+{
+    pub fn build(self) -> Result<AtomicCell<InnerI2cBus<'a>>, Self> {
+        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))
+            }
+            Err(e) => {
+                log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
+                unimplemented!("Partial move makes it impossible to retry.");
+                // Err(self)
+            }
+        }
+    }
+}

src/drivers/nfc_pn532.rs

@@ -1,4 +1,5 @@
 use alloc::vec::Vec;
+use core::error::Error;
 use embedded_hal::i2c::I2c;
 use log::{error, info};
 use pn532::i2c::I2CInterface;
@@ -8,6 +9,7 @@ use pn532::{Pn532, Request};
 pub type Pn532Device<I2C> = Pn532<I2CInterface<I2C>, (), 34>;
 
 pub const PAGES_PER_READ: usize = 4;
+pub const BYTES_PER_READ: usize = PAGES_PER_READ * 4;
 
 /// PN532 NFC reader driver.
 pub struct NfcPn532Driver<I2C>
@@ -17,6 +19,144 @@ where
     pn532: Pn532Device<I2C>,
 }
 
+#[derive(Debug, Clone)]
+struct PageParseError<const N: usize> {
+    iteration: u8,
+    bytes: [u8; N],
+    status_code: Option<CommandResult>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct CommandResult {
+    /// # WrErr
+    /// Set to logic 1, when data is written into the FIFO by the 80C51 during the AutoColl command or MFAuthent command or
+    /// if data is written into the FIFO by the 80C51 during the time between sending the last bit on the RF interface and
+    /// receiving the last bit on the RF interface.
+    write_error: bool,
+    /// # TempErr
+    /// Set to logic 1, if the internal temperature sensor detects overheating. In this case the antenna drivers are switched off automatically.
+    overheating: bool,
+    /// # RFErr
+    /// Set to logic 1, if in active communication mode the counterpart does not switch on the RF field in time as defined in NFCIP-1 standard.
+    /// Note: RFErr is only used in active communication mode. The bit RxFraming or the bit TxFraming has to be set to 01h to enable
+    /// this functionality.
+    rf_timeout: bool,
+    /// # BufferOvfl
+    /// Set to logic 1, if the 80C51 or if the internal state machine (e.g. receiver) tries to write data into the FIFO buffer
+    /// although the FIFO buffer is already full.
+    buffer_overflow: bool,
+    /// # CollErr
+    /// Set to logic 1, if a bit-collision is detected. It is set to logic 0 automatically at receiver start phase.
+    /// This flag is only valid during the bitwise anticollision at 106 kbit/s. During communication schemes at 212 and 424 kbit/s
+    /// this flag is always set to logic 0.
+    bit_collision: bool,
+    /// # CRCErr
+    /// Set to logic 1, if RxCRCEn in CIU_RxMode register is set to logic 1 and the CRC calculation fails. It is set to logic 0 automatically
+    /// at receiver start-up phase.
+    crc_error: bool,
+    /// # ParityErr
+    /// Set to logic 1, if the parity check has failed. It is set to logic 0 automatically at receiver start-up phase.
+    /// Only valid for ISO/IEC 14443A/MIFARE or NFCIP-1 communication at 106 kbit/s.
+    parity_error: bool,
+    /// # ProtocollErr
+    /// Set to logic 1, if one out of the following cases occurs:
+    /// - Set to logic 1 if the SOF is incorrect. It is set to logic 0 automatically at receiver start-up phase.
+    ///   The bit is only valid for 106 kbit in Active and Passive Communication mode.
+    /// - If bit DetectSync in CIU_Mode register is set to logic 1 during FeliCa communication or Active Communication
+    ///   with transfer speeds higher than 106 kbit, ProtocolErr is set to logic 1 in case of a byte length violation.
+    /// - During the AutoColl command, ProtocolErr is set to logic 1, if the Initiator bit in CIU_Control register is set to logic 1.
+    /// - During the MFAuthent Command, ProtocolErr is set to logic 1, if the number of bytes received in one data stream is incorrect.
+    /// - Set to logic 1, if the Miller Decoder detects 2 pauses below the minimum time according to the ISO/IEC 14443A definitions.
+    protocol_error: bool,
+}
+
+impl CommandResult {
+    pub fn is_error(&self) -> bool {
+        self.write_error
+            || self.overheating
+            || self.rf_timeout
+            || self.buffer_overflow
+            || self.bit_collision
+            || self.crc_error
+            || self.parity_error
+            || self.protocol_error
+    }
+}
+
+impl From<u8> for CommandResult {
+    fn from(value: u8) -> Self {
+        let mask = |bit| 1u8 << bit;
+        let take_bit = |bit| (value & mask(bit)) != 0u8;
+
+        Self {
+            write_error: take_bit(7),
+            overheating: take_bit(6),
+            rf_timeout: take_bit(5),
+            buffer_overflow: take_bit(4),
+            bit_collision: take_bit(3),
+            crc_error: take_bit(2),
+            parity_error: take_bit(1),
+            protocol_error: take_bit(0),
+        }
+    }
+}
+
+impl core::fmt::Display for CommandResult {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if !self.is_error() {
+            return write!(f, "ok");
+        }
+
+        write!(f, "error: ")?;
+
+        let errors = [
+            (self.write_error, "write_error(7)"),
+            (self.overheating, "overheating(6)"),
+            (self.rf_timeout, "rf_timeout(5)"),
+            (self.buffer_overflow, "buffer_overflow(4)"),
+            (self.bit_collision, "bit_collision(3)"),
+            (self.crc_error, "crc_error(2)"),
+            (self.parity_error, "parity_error(1)"),
+            (self.protocol_error, "protocol_error(0)"),
+        ]
+        .into_iter()
+        .filter_map(|(active, name)| active.then_some(name));
+
+        let mut first = true;
+        for error in errors {
+            let separator = if !first { ", " } else { "" };
+            write!(f, "{separator}{error}")?;
+            first = false;
+        }
+
+        Ok(())
+    }
+}
+
+impl Error for CommandResult {}
+
+impl<const N: usize> Error for PageParseError<N> {}
+
+impl<const N: usize> core::fmt::Display for PageParseError<N> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let PageParseError {
+            iteration,
+            bytes,
+            status_code,
+        } = self;
+        match status_code {
+            Some(code) => write!(
+                f,
+                "NFC pages parse error in iteration {iteration} with {code}: {bytes:02x?}"
+            ),
+            None => write!(
+                f,
+                "No data available for NFC page in iteration {iteration}: {bytes:02x?}"
+            ),
+        }
+    }
+}
+
 impl<I2C> NfcPn532Driver<I2C>
 where
     I2C: I2c,
@@ -40,7 +180,7 @@ where
         }
     }
 
-    pub async fn poll_target(&mut self) -> Result<(), ()> {
+    pub async fn poll_target(&mut self) -> Result<(), &'static str> {
         match self
             .pn532
             .process_async(&Request::INLIST_ONE_ISO_A_TARGET, 23)
@@ -51,26 +191,31 @@ where
                 Ok(())
             }
             Err(e) => {
-                info!("No NFC card found on shared I2C bus: {e:?}");
-                Err(())
+                info!("Failed to poll NFC target: {e:?}");
+                Err("Failed to poll NFC target")
             }
         }
     }
 
-    pub fn parse_nfc_page(iteration: u8, bytes: &[u8]) -> Result<[u8; PAGES_PER_READ * 4], ()> {
-        let success = bytes.first().is_some_and(|x| *x == 0);
-        if success {
-            let slice_len = bytes.len().min(PAGES_PER_READ * 4 + 1);
-            let mut arr = [0; PAGES_PER_READ * 4];
+    fn parse_nfc_page(
+        iteration: u8,
+        bytes: &[u8],
+    ) -> Result<[u8; BYTES_PER_READ], PageParseError<BYTES_PER_READ>> {
+        let slice_len = bytes.len().min(BYTES_PER_READ + 1);
+        let mut arr = [0; BYTES_PER_READ];
         arr[..slice_len - 1].copy_from_slice(&bytes[1..slice_len]);
-            Ok(arr)
-        } else {
-            info!("err  {iteration}: {:02x?}", bytes);
-            Err(())
+
+        match bytes.first() {
+            Some(0x00) => Ok(arr),
+            error => Err(PageParseError {
+                iteration,
+                bytes: arr,
+                status_code: error.copied().map(Into::into),
+            }),
         }
     }
 
-    pub async fn read_card_data(&mut self) -> Result<Vec<u8>, ()> {
+    pub async fn read_card_data(&mut self) -> Result<Vec<u8>, &'static str> {
         if let Err(e) = self.poll_target().await {
             error!("PN532 I2C target poll failed before reading card data: {e:?}");
             return Err(e);
@@ -79,18 +224,31 @@ where
         let mut data: Vec<u8> = Vec::with_capacity(858);
 
         for i in (0x0B..=230).step_by(PAGES_PER_READ) {
-            let mut parse_result = Err(());
-            while parse_result.is_err() {
-                let Ok(result) = self
+            let bytes = loop {
+                let read = self
                     .pn532
-                    .process_async(&Request::ntag_read(i), PAGES_PER_READ * 4 + 1)
-                    .await
-                else {
+                    .process_async(&Request::ntag_read(i), BYTES_PER_READ + 1)
+                    .await;
+
+                let bytes = match read {
+                    Ok(bytes) => bytes,
+                    Err(e) => {
+                        error!("Reading page {i} failed: {e:?}");
                         continue;
-                };
-                parse_result = Self::parse_nfc_page(i, result);
                     }
-            let bytes = parse_result.unwrap();
+                };
+
+                match Self::parse_nfc_page(i, bytes) {
+                    Ok(data) => break data,
+                    Err(e) => {
+                        error!("Parsing page failed: {e}");
+                        if e.status_code.is_some_and(|e| e.protocol_error) {
+                            // After protocol error, all subsequent reads will fail, so we can stop trying to read more pages.
+                            return Err("Failed to parse NFC page");
+                        }
+                    }
+                }
+            };
             let bytes = if i == 0x0B { &bytes[1..] } else { &bytes };
             data.extend(bytes);
         }

src/drivers/primary_lcd.rs

@@ -0,0 +1,42 @@
+use display_interface_spi::SPIInterface;
+use embedded_graphics::draw_target::DrawTarget;
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+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 crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput};
+
+type GenericPrimaryDisplay<'a, BUS, DC, RES> =
+    Ili9341<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RES>;
+pub type PrimaryDisplay<'a> =
+    GenericPrimaryDisplay<'a, DisplaySpiBus, SharedOutput<'a>, Output<'a>>;
+
+pub struct PrimaryDisplayPinConfiguration<'a> {
+    pub spi_bus: &'a AtomicCell<DisplaySpiBus>,
+    pub cs: Output<'a>,
+    pub reset: Output<'a>,
+    pub dc: SharedOutput<'a>,
+}
+
+impl<'a> PrimaryDisplayPinConfiguration<'a> {
+    pub fn build(self) -> PrimaryDisplay<'a> {
+        let spi_dev = AtomicDevice::new(self.spi_bus, self.cs, Delay::new()).unwrap();
+        let iface = SPIInterface::new(spi_dev, self.dc);
+
+        let mut display = Ili9341::new(
+            iface,
+            self.reset,
+            &mut Delay::new(),
+            Orientation::Portrait,
+            DisplaySize240x320,
+        )
+        .unwrap();
+
+        display.clear(Rgb565::BLACK).unwrap();
+        display
+    }
+}

src/drivers/secondary_oled.rs

@@ -0,0 +1,59 @@
+use alloc::format;
+use ch1115::{Ch1115, Size128x64};
+use display_interface_spi::SPIInterface;
+use embedded_hal_bus::spi::AtomicDevice;
+use embedded_hal_bus::util::AtomicCell;
+use esp_hal::delay::Delay;
+use esp_hal::gpio::Output;
+
+use crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput, SharedReset};
+
+pub type GenericSecondaryDisplay<'a, BUS, RST, DC> =
+    Ch1115<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RST, Size128x64>;
+pub type SecondaryDisplay<'a> =
+    GenericSecondaryDisplay<'a, DisplaySpiBus, SharedReset<'a>, SharedOutput<'a>>;
+
+pub struct SecondaryDisplayPinConfiguration<'a> {
+    pub spi_bus: &'a AtomicCell<DisplaySpiBus>,
+    pub cs_pins: [Output<'a>; 3],
+    pub res: SharedReset<'a>,
+    pub dc: SharedOutput<'a>,
+}
+
+impl<'a> SecondaryDisplayPinConfiguration<'a> {
+    pub fn build(self) -> [SecondaryDisplay<'a>; 3] {
+        let mut displays = self.cs_pins.map(|cs| {
+            let spi_dev = AtomicDevice::new(self.spi_bus, cs, Delay::new()).unwrap();
+            let interface = SPIInterface::new(spi_dev, self.dc.clone());
+
+            Ch1115::new(interface, self.res.clone(), Size128x64)
+        });
+
+        init_single_reset(&mut displays, self.res);
+
+        displays
+    }
+}
+
+fn init_single_reset<'a: 'b, 'b>(
+    displays: impl IntoIterator<Item = &'b mut SecondaryDisplay<'a>>,
+    shared_reset: SharedReset<'a>,
+) {
+    let mut displays = displays.into_iter().peekable();
+
+    // Reset all secondaries via shared reset
+    let Some(any_display) = displays.peek_mut() else {
+        // no display to initialize
+        return;
+    };
+    any_display.hard_reset(&mut Delay::new()).unwrap();
+
+    shared_reset.disable(true);
+
+    for (i, display) in displays.enumerate() {
+        display
+            .init(&mut Delay::new())
+            .map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
+            .unwrap();
+    }
+}

src/drivers/spi_bus.rs

@@ -0,0 +1,187 @@
+use alloc::boxed::Box;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embedded_hal::digital::ErrorType;
+use embedded_hal::digital::OutputPin as EhOutputPin;
+use embedded_hal_bus::util::AtomicCell;
+use esp_hal::gpio::interconnect::{PeripheralInput, PeripheralOutput};
+use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
+use esp_hal::spi::Mode;
+use esp_hal::spi::master::{Config as SpiConfig, Spi};
+use esp_hal::time::Rate;
+
+use crate::drivers::primary_lcd::PrimaryDisplay;
+use crate::drivers::primary_lcd::PrimaryDisplayPinConfiguration;
+use crate::drivers::secondary_oled::SecondaryDisplay;
+use crate::drivers::secondary_oled::SecondaryDisplayPinConfiguration;
+
+use core::cell::RefCell;
+use embassy_sync::blocking_mutex::Mutex as BlockingMutex;
+
+pub struct SharedPin<'a, P> {
+    mutex: &'a BlockingMutex<CriticalSectionRawMutex, RefCell<P>>,
+}
+
+impl<'a, P> Clone for SharedPin<'a, P> {
+    fn clone(&self) -> Self {
+        Self { mutex: self.mutex }
+    }
+}
+
+impl<'a, P> SharedPin<'a, P> {
+    pub fn new(pin: P) -> Self {
+        let mutexed = BlockingMutex::new(RefCell::new(pin));
+        let mutex = Box::leak(Box::new(mutexed));
+        Self { mutex }
+    }
+}
+
+impl<'a, P: EhOutputPin> ErrorType for SharedPin<'a, P> {
+    type Error = P::Error;
+}
+
+impl<'a, P: EhOutputPin> EhOutputPin for SharedPin<'a, P> {
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        self.mutex.lock(|p| p.borrow_mut().set_low())
+    }
+
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        self.mutex.lock(|p| p.borrow_mut().set_high())
+    }
+}
+
+pub struct SharedResetPin<'a, P> {
+    mutex: &'a BlockingMutex<CriticalSectionRawMutex, RefCell<(P, bool)>>,
+}
+
+impl<'a, P> SharedResetPin<'a, P> {
+    pub fn new(pin: P, disabled: bool) -> Self {
+        let mutexed = BlockingMutex::new(RefCell::new((pin, disabled)));
+        let mutex = Box::leak(Box::new(mutexed));
+        Self { mutex }
+    }
+
+    pub fn disable(&self, disabled: bool) {
+        self.mutex.lock(|p| {
+            p.borrow_mut().1 = disabled;
+        });
+        if disabled {
+            log::debug!("Reset pin disabled (masked). No more resets now.");
+        } else {
+            log::debug!("Reset pin enabled (unmasked). Reset now possible.");
+        }
+    }
+}
+
+impl<'a, P> Clone for SharedResetPin<'a, P> {
+    fn clone(&self) -> Self {
+        Self { mutex: self.mutex }
+    }
+}
+
+impl<'a, P: EhOutputPin> ErrorType for SharedResetPin<'a, P> {
+    type Error = P::Error;
+}
+
+impl<'a, P: EhOutputPin> EhOutputPin for SharedResetPin<'a, P> {
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        self.mutex.lock(|p| {
+            let mut guard = p.borrow_mut();
+            let disabled = guard.1;
+            let pin = &mut guard.0;
+            if !disabled { pin.set_low() } else { Ok(()) }
+        })
+    }
+
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        self.mutex.lock(|p| {
+            let mut guard = p.borrow_mut();
+            let disabled = guard.1;
+            let pin = &mut guard.0;
+            if !disabled { pin.set_high() } else { Ok(()) }
+        })
+    }
+}
+
+pub type SharedOutput<'a> = SharedPin<'a, Output<'a>>;
+pub type SharedReset<'a> = SharedResetPin<'a, Output<'a>>;
+pub type DisplaySpiBus = Spi<'static, esp_hal::Blocking>;
+
+pub struct DisplayPinConfiguration<SPI, SCK, MOSI, MISO, CS0, CS1, CS2, CS3, RES1, RES2, DC> {
+    pub spi_peripheral: SPI,
+    pub sck: SCK,
+    pub mosi: MOSI,
+    pub miso: MISO,
+    pub cs_primary: CS0,
+    pub cs_secondary_1: CS1,
+    pub cs_secondary_2: CS2,
+    pub cs_secondary_3: CS3,
+    pub reset_primary: RES1,
+    pub reset_secondary: RES2,
+    pub dc_pin: DC,
+}
+
+impl<SPI, SCK, MOSI, MISO, CS0, CS1, CS2, CS3, RES1, RES2, DC>
+    DisplayPinConfiguration<SPI, SCK, MOSI, MISO, CS0, CS1, CS2, CS3, RES1, RES2, DC>
+where
+    SPI: esp_hal::spi::master::Instance + 'static,
+    SCK: PeripheralOutput<'static>,
+    MOSI: PeripheralOutput<'static>,
+    MISO: PeripheralInput<'static>,
+    CS0: OutputPin + 'static,
+    CS1: OutputPin + 'static,
+    CS2: OutputPin + 'static,
+    CS3: OutputPin + 'static,
+    RES1: OutputPin + 'static,
+    RES2: OutputPin + 'static,
+    DC: OutputPin + 'static,
+{
+    pub fn build(self) -> Result<(PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]), Self> {
+        let spi = Spi::new(
+            self.spi_peripheral,
+            SpiConfig::default()
+                .with_frequency(Rate::from_khz(20_000))
+                .with_mode(Mode::_0),
+        )
+        .unwrap()
+        .with_sck(self.sck)
+        .with_mosi(self.mosi)
+        .with_miso(self.miso);
+
+        let bus_static: &'static AtomicCell<_> = Box::leak(Box::new(AtomicCell::new(spi)));
+        let reset_secondary = SharedResetPin::new(
+            Output::new(self.reset_secondary, Level::High, OutputConfig::default()),
+            false,
+        );
+        let dc = SharedPin::new(Output::new(
+            self.dc_pin,
+            Level::High,
+            OutputConfig::default(),
+        ));
+
+        let primary = PrimaryDisplayPinConfiguration {
+            spi_bus: bus_static,
+            cs: low_active(self.cs_primary),
+            reset: low_active(self.reset_primary),
+            dc: dc.clone(),
+        }
+        .build();
+
+        let secondaries = SecondaryDisplayPinConfiguration {
+            spi_bus: bus_static,
+            cs_pins: [
+                low_active(self.cs_secondary_1),
+                low_active(self.cs_secondary_2),
+                low_active(self.cs_secondary_3),
+            ],
+            res: reset_secondary,
+            dc,
+        }
+        .build();
+
+        Ok((primary, secondaries))
+    }
+}
+
+fn low_active<'a, CS: OutputPin + 'a>(pin: CS) -> Output<'a> {
+    Output::new(pin, Level::High, OutputConfig::default())
+}

src/drivers/tertiary_lcd.rs

@@ -0,0 +1,410 @@
+use embedded_hal_bus::i2c::AtomicDevice;
+use esp_hal::delay::Delay;
+use i2c_character_display::{CharacterDisplayPCF8574T, LcdDisplayType};
+use log::error;
+
+use crate::create_custom_char_set;
+use crate::drivers::i2c_bus::{I2cBus, I2cDevice};
+
+type GenericTertiaryDisplay<I2C> = CharacterDisplayPCF8574T<I2C, Delay>;
+type TertiaryDisplayRaw<'a> = GenericTertiaryDisplay<I2cDevice<'a>>;
+pub type TertiaryDisplayError<'a> = i2c_character_display::CharacterDisplayError<I2cDevice<'a>>;
+
+pub struct TertiaryDisplayPinConfiguration<'a> {
+    pub i2c: I2cBus<'a>,
+}
+
+impl<'a> TertiaryDisplayPinConfiguration<'a> {
+    pub fn build(self) -> Result<TertiaryDisplay<'a>, Self> {
+        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 {
+                    display: lcd,
+                    charset: create_custom_char_set!(),
+                })
+            }
+            Err(e) => {
+                log::error!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
+                Err(self)
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum TertiaryDisplayWriteError<'a> {
+    Display(TertiaryDisplayError<'a>),
+    Format(LinesError),
+}
+
+impl<'a> From<TertiaryDisplayError<'a>> for TertiaryDisplayWriteError<'a> {
+    fn from(value: TertiaryDisplayError<'a>) -> Self {
+        Self::Display(value)
+    }
+}
+
+impl From<LinesError> for TertiaryDisplayWriteError<'_> {
+    fn from(value: LinesError) -> Self {
+        Self::Format(value)
+    }
+}
+
+impl<'a> core::fmt::Display for TertiaryDisplayWriteError<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Display(e) => write!(f, "display error: {e}"),
+            Self::Format(e) => write!(f, "format error: {e}"),
+        }
+    }
+}
+
+pub struct TertiaryDisplay<'a> {
+    display: TertiaryDisplayRaw<'a>,
+    charset: CustomCharset,
+}
+
+impl<'a> TertiaryDisplay<'a> {
+    pub const WIDTH: usize = 16;
+    pub const ROWS: usize = 2;
+
+    pub fn inner_mut(&mut self) -> &mut TertiaryDisplayRaw<'a> {
+        &mut self.display
+    }
+
+    pub fn load_charset(&mut self, charset: CustomCharset) -> Result<(), TertiaryDisplayError<'a>> {
+        self.charset = charset;
+        for (index, charmap) in self
+            .charset
+            .set
+            .into_iter()
+            .enumerate()
+            .take(self.charset.len)
+        {
+            self.display
+                .create_char(index as u8, charmap)
+                .inspect_err(|e| error!("I2C Custom character {index} init failed: {e}"))?;
+        }
+        Ok(())
+    }
+
+    pub fn clear(&mut self) -> Result<(), TertiaryDisplayError<'a>> {
+        if let Err(e) = self.display.clear() {
+            error!("I2C LCD clear failed; bus may be busy or device unresponsive");
+            return Err(e);
+        }
+        Ok(())
+    }
+
+    /// Writes text to the LCD. Normal strings wrap by default but this can be controlled
+    /// via explicit [`Lines::checked`].
+    pub fn write<'b, L: Into<Lines<'b>>>(
+        &mut self,
+        text: L,
+    ) -> Result<(), TertiaryDisplayWriteError<'a>> {
+        let lines = text.into();
+
+        // Use original to get correct position in original string
+        lines
+            .original
+            .iter()
+            .try_for_each(|text| Lines::invalid_chars(text, Some(&self.charset)))?;
+
+        let lines = lines.into_result()?;
+
+        self.display
+            .clear()
+            .inspect_err(|e| error!("I2C LCD clear failed before wrapped write: {e}"))?;
+
+        for (row, line) in lines.into_iter().enumerate() {
+            self.display.set_cursor(0, row as u8).inspect_err(|e| {
+                error!("I2C LCD cursor move failed while writing wrapped row {row}: {e}")
+            })?;
+
+            self.display
+                .print(line)
+                .inspect_err(|e| error!("I2C LCD wrapped write failed on row {row}: {e}"))?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum LinesError {
+    ColumnOverflow { line: u8, columns: usize },
+    LineOverflow,
+    InvalidChar { position: usize, symbol: char },
+}
+
+impl core::fmt::Display for LinesError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::ColumnOverflow { line, columns } => {
+                write!(
+                    f,
+                    "text too long for line {line}: {columns} > {}",
+                    TertiaryDisplay::WIDTH
+                )
+            }
+            Self::LineOverflow => write!(f, "text has too many lines"),
+            Self::InvalidChar { position, symbol } => {
+                write!(f, "Invalid character {symbol} at offset {position}")
+            }
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct Lines<'a> {
+    pub lines: Result<[&'a str; TertiaryDisplay::ROWS], LinesError>,
+    /// Unmodified original string. Only first entry is populated unless constructed with [`by_line`]
+    pub original: [&'a str; TertiaryDisplay::ROWS],
+}
+
+impl<'a> Lines<'a> {
+    pub fn into_result(self) -> Result<[&'a str; TertiaryDisplay::ROWS], LinesError> {
+        self.lines
+    }
+
+    /// Validates that the text contains only non-control ASCII characters,
+    /// newlines, and contiguous custom characters up to `charset.len`.
+    /// If `charset` is `None`, allow any custom char up to and including maximum.
+    pub fn invalid_chars(text: &str, charset: Option<&CustomCharset>) -> Result<(), LinesError> {
+        for (pos, c) in text.char_indices() {
+            let is_standard_valid = c == '\n' || (' '..='~').contains(&c);
+
+            if is_standard_valid {
+                continue;
+            }
+
+            let first_invalid_custom_char =
+                charset.map(|c| c.len).unwrap_or(CUSTOM_CHAR_COUNT.into());
+
+            if (c as usize) >= first_invalid_custom_char {
+                return Err(LinesError::InvalidChar {
+                    position: pos,
+                    symbol: c,
+                });
+            }
+        }
+        Ok(())
+    }
+
+    /// Checks pre-split lines strictly for length and valid characters.
+    pub fn by_line(lines: [&'a str; TertiaryDisplay::ROWS]) -> Self {
+        let this = |res| Self {
+            lines: res,
+            original: lines,
+        };
+
+        for line in lines.iter() {
+            if let Err(e) = Self::invalid_chars(line, None) {
+                return this(Err(e));
+            }
+        }
+
+        for (i, line) in lines.iter().enumerate() {
+            if line.len() > TertiaryDisplay::WIDTH {
+                return this(Err(LinesError::ColumnOverflow {
+                    line: i as u8,
+                    columns: line.len(),
+                }));
+            }
+        }
+
+        this(Ok(lines))
+    }
+
+    /// Strictly checks an input string.
+    /// Fails if there are invalid chars, too many newlines, or if any segment exceeds WIDTH.
+    pub fn checked(input: &'a str) -> Self {
+        let this = |res| Self {
+            lines: res,
+            original: [input, ""],
+        };
+
+        if let Err(e) = Self::invalid_chars(input, None) {
+            return this(Err(e));
+        }
+
+        let mut out = [""; TertiaryDisplay::ROWS];
+        let mut parts = input.split('\n');
+
+        for (i, out) in out.iter_mut().enumerate() {
+            if let Some(part) = parts.next() {
+                if part.len() > TertiaryDisplay::WIDTH {
+                    return this(Err(LinesError::ColumnOverflow {
+                        line: i as u8,
+                        columns: part.len(),
+                    }));
+                }
+                *out = part;
+            }
+        }
+
+        if parts.next().is_some() {
+            return this(Err(LinesError::LineOverflow));
+        }
+
+        this(Ok(out))
+    }
+
+    /// Wraps text automatically at `WIDTH` or at newlines.
+    /// Discards (clamps) any leftover text that exceeds `ROWS`.
+    /// Fails immediately if invalid characters are present.
+    pub fn clamped(input: &'a str) -> Self {
+        let this = |res| Self {
+            lines: res,
+            original: [input, ""],
+        };
+        if let Err(e) = Self::invalid_chars(input, None) {
+            return this(Err(e));
+        }
+
+        let mut out = [""; TertiaryDisplay::ROWS];
+        let mut remaining = input;
+
+        for out in out.iter_mut() {
+            if remaining.is_empty() {
+                break;
+            }
+
+            let (segment, rest) = Self::next_segment(remaining, TertiaryDisplay::WIDTH);
+            *out = segment;
+            remaining = rest;
+        }
+
+        this(Ok(out))
+    }
+
+    /// Helper function to slice an ASCII string up to `max_width`
+    /// or until the next newline, whichever comes first.
+    fn next_segment(s: &str, max_width: usize) -> (&str, &str) {
+        let nl_pos = s.find('\n');
+
+        let split_pos = match nl_pos {
+            Some(pos) if pos <= max_width => pos,
+            _ => core::cmp::min(s.len(), max_width),
+        };
+
+        let segment = &s[..split_pos];
+        let mut rest = &s[split_pos..];
+
+        if let Some(stripped) = rest.strip_prefix('\n') {
+            rest = stripped;
+        }
+
+        (segment, rest)
+    }
+}
+
+impl<'a> From<&'a str> for Lines<'a> {
+    fn from(value: &'a str) -> Self {
+        Self::clamped(value)
+    }
+}
+
+impl<'a> From<&'a alloc::string::String> for Lines<'a> {
+    fn from(value: &'a alloc::string::String) -> Self {
+        Self::clamped(value)
+    }
+}
+
+/// 5x8 pixel charmap. Each set bit is a black pixel.
+pub type CharMap = [u8; 8];
+pub struct CustomCharset {
+    set: [CharMap; CUSTOM_CHAR_COUNT as usize],
+    len: usize,
+}
+
+impl core::ops::Index<CharMap> for CustomCharset {
+    type Output = &'static str;
+
+    fn index(&self, map: CharMap) -> &Self::Output {
+        let encoded = self.set[..self.len]
+            .iter()
+            .position(|&m| m == map)
+            .expect("Unknown char map in this set.");
+
+        match encoded {
+            0 => &"\x00",
+            1 => &"\x01",
+            2 => &"\x02",
+            3 => &"\x03",
+            4 => &"\x04",
+            5 => &"\x05",
+            6 => &"\x06",
+            7 => &"\x07",
+            8 => &"\x08",
+            9 => &"\x09",
+            10 => &"\x0A",
+            11 => &"\x0B",
+            12 => &"\x0C",
+            13 => &"\x0D",
+            14 => &"\x0E",
+            15 => &"\x0F",
+            pos => unreachable!(
+                "More than {CUSTOM_CHAR_COUNT} (=max) elements in array? Found element at {pos}."
+            ),
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! create_custom_char_set {
+    () => {{
+        CustomCharset { set: [EMPTY; CUSTOM_CHAR_COUNT as usize], len: 0 }
+    }};
+    ($($char:expr),+ $(,)?) => {{
+        // Count how many characters were passed using macro repetition length
+        const LEN: usize = [$(stringify!($char)),+].len();
+
+        // Ensure we don't exceed the defined maximum capacity
+        const _: () = assert!(
+            LEN <= CUSTOM_CHAR_COUNT as usize,
+            "Too many characters provided for CUSTOM_CHAR_COUNT"
+        );
+
+        // Build a fixed-size array populated with the provided characters,
+        // and pad the rest with empty CharMaps (zeros) to fit CUSTOM_CHAR_COUNT.
+        const SET: [CharMap; CUSTOM_CHAR_COUNT as usize] = {
+            let mut buffer = [[0u8; 8]; CUSTOM_CHAR_COUNT as usize];
+            let input = [$($char),*];
+            let mut i = 0;
+            while i < input.len() {
+                buffer[i] = input[i];
+                i += 1;
+            }
+            buffer
+        };
+
+        CustomCharset {
+            set: SET,
+            len: LEN,
+        }
+    }};
+}
+
+pub const CUSTOM_CHAR_COUNT: u8 = 16;
+
+pub const HEART: CharMap = [
+    0b00000, // Top row
+    0b01010, //  * *
+    0b11111, // *****
+    0b11111, // *****
+    0b01110, //  ***
+    0b00100, //   *
+    0b00000, // Bottom row
+    0b00000, // Cursor line (usually left blank)
+];
+
+pub const EMPTY: CharMap = [0; 8];
+pub const BOX: CharMap = [
+    0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111,
+    0b00000, // Cursor line (usually left blank)
+];
+
+pub const EXAMPLE: CustomCharset = create_custom_char_set!(HEART, BOX, EMPTY);

src/lib.rs

@@ -1,10 +1,13 @@
 #![no_std]
+#![feature(vec_into_chunks)]
 
 extern crate alloc;
 
+pub mod background_tasks;
 pub mod card;
 pub mod display;
 pub mod drivers;
+pub mod logging;
 pub mod navigation;
 pub mod network;
 pub mod storage;

src/logging.rs

@@ -0,0 +1,83 @@
+mod logging_config {
+    include!(concat!(env!("OUT_DIR"), "/log_filter.rs"));
+}
+
+struct EnvLogger;
+
+impl log::Log for EnvLogger {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        let level = metadata.level();
+        let target = metadata.target();
+        logging_config::is_enabled(level, target)
+    }
+
+    fn log(&self, record: &log::Record) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+
+        // print with color? default to true if env var unset or set but empty.
+        let with_color = 1
+            == option_env!("ESP_LOG_COLOR")
+                .unwrap_or("1")
+                .parse()
+                .unwrap_or(1);
+        let (color, reset) = if with_color {
+            const RESET: &str = "\u{001B}[0m";
+            const RED: &str = "\u{001B}[31m";
+            const GREEN: &str = "\u{001B}[32m";
+            const YELLOW: &str = "\u{001B}[33m";
+            const BLUE: &str = "\u{001B}[34m";
+            const CYAN: &str = "\u{001B}[35m";
+
+            let color = match record.level() {
+                log::Level::Error => RED,
+                log::Level::Warn => YELLOW,
+                log::Level::Info => GREEN,
+                log::Level::Debug => BLUE,
+                log::Level::Trace => CYAN,
+            };
+            let reset = RESET;
+            (color, reset)
+        } else {
+            ("", "")
+        };
+
+        let [now_s, now_ms] = {
+            let now = esp_hal::time::Instant::now()
+                .duration_since_epoch()
+                .as_millis();
+
+            [now / 1000, now % 1000]
+        };
+
+        let level = match record.level() {
+            log::Level::Error => "E",
+            log::Level::Warn => "W",
+            log::Level::Info => "I",
+            log::Level::Debug => "D",
+            log::Level::Trace => "T",
+        };
+        let args = record.args();
+        let line = record.line().unwrap_or(0);
+        let target = record.target();
+        let module = record.module_path().unwrap_or("???");
+
+        let (module, divider) = if module == target {
+            ("", "")
+        } else {
+            (module, " ")
+        };
+
+        esp_println::println!(
+            "{color}{now_s:>4}.{now_ms:03}s {level} {target}{divider}{module}:{line} - {args}{reset}"
+        );
+    }
+
+    fn flush(&self) {}
+}
+
+pub fn init() {
+    log::set_logger(&EnvLogger).expect("Failed to init logger.");
+    log::set_max_level(logging_config::FILTER_MAX);
+}

src/navigation.rs

@@ -1,3 +1,4 @@
 pub mod inputs;
 pub mod navigation;
+pub mod outputs;
 pub mod state;

src/navigation/navigation.rs

@@ -1,15 +1,13 @@
 use crate::card::model::Card;
-use crate::display::shared_bus::DualPrimaryDisplay;
 use crate::navigation::inputs::ButtonAction;
 use crate::navigation::inputs::Inputs;
+use crate::navigation::outputs::Outputs;
 use crate::navigation::state::NavigationState;
 use crate::views::view::View;
 
 use embassy_futures::select::{Either, select};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_time::{Duration, Timer};
-use embedded_graphics::draw_target::DrawTarget;
-use embedded_graphics::pixelcolor::Rgb565;
 
 pub type Mutex<T> = embassy_sync::mutex::Mutex<CriticalSectionRawMutex, T>;
 pub type Signal<T> = embassy_sync::signal::Signal<CriticalSectionRawMutex, T>;
@@ -29,19 +27,16 @@ pub struct NewState {
 }
 
 pub trait Navigable {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565> + Send,
-        D::Error: core::fmt::Debug;
+    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, display: &'static mut DualPrimaryDisplay<'static>) {
+pub async fn run(mut inputs: Inputs, mut outputs: Outputs) {
     log::info!("starting navigation");
 
     let mut state = NavigationState::new();
-    state.screens.last().unwrap().display(display).await;
+    state.screens.last().unwrap().display(&mut outputs).await;
 
     loop {
         let selection = select(
@@ -87,7 +82,7 @@ pub async fn run(mut inputs: Inputs, display: &'static mut DualPrimaryDisplay<'s
         state.screens.push(new_state.view);
 
         if action != Action::Timer || new_state.redraw {
-            state.screens.last().unwrap().display(display).await;
+            state.screens.last().unwrap().display(&mut outputs).await;
         }
 
         Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)).await;

src/navigation/outputs.rs

@@ -0,0 +1,27 @@
+use embedded_graphics::{
+    draw_target::DrawTarget as _,
+    pixelcolor::{Rgb565, RgbColor as _},
+};
+
+use crate::drivers::{
+    primary_lcd::PrimaryDisplay, secondary_oled::SecondaryDisplay, tertiary_lcd::TertiaryDisplay,
+};
+
+pub struct Outputs {
+    pub primary_display: PrimaryDisplay<'static>,
+    pub secondary_display_1: SecondaryDisplay<'static>,
+    pub secondary_display_2: SecondaryDisplay<'static>,
+    pub secondary_display_3: SecondaryDisplay<'static>,
+    pub tertiary_display: TertiaryDisplay<'static>,
+    pub _led_a: (),
+}
+
+impl Outputs {
+    pub fn clear_screens(&mut self) {
+        self.primary_display.clear(Rgb565::BLACK).unwrap();
+        self.secondary_display_1.clear().unwrap();
+        // self.secondary_display_2.clear().unwrap();
+        // self.secondary_display_3.clear().unwrap();
+        self.tertiary_display.clear().unwrap();
+    }
+}

src/navigation/state.rs

@@ -24,16 +24,16 @@ impl NavigationState {
         match &self.screens.len() {
             0 => {
                 log::info!("No screens to go back to");
-                return self.screens.last().unwrap();
+                self.screens.last().unwrap()
             }
             1 => {
                 log::info!("Only one screen on stack, cannot go back");
-                return self.screens.last().unwrap();
+                self.screens.last().unwrap()
             }
             _ => {
                 log::info!("Going back to previous screen");
                 self.screens.pop();
-                return self.screens.last().unwrap();
+                self.screens.last().unwrap()
             }
         }
     }

src/storage.rs

@@ -1,2 +1,31 @@
-pub mod dex_db;
-pub mod nvs;
+pub struct MemoryRegion {
+    offset: u32,
+    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
+    }
+}
+
+const MAX_FLASH: usize = 16 * 1024 * 1024;
+
+const MAGIC_REGION: MemoryRegion = MemoryRegion::new(0, 4);
+
+const SETTINGS_REGION: MemoryRegion = MemoryRegion::new(MAGIC_REGION.end() as u32, 1024);
+
+const CARDSTORE_REGION: MemoryRegion = MemoryRegion::new(
+    SETTINGS_REGION.end() as u32,
+    MAX_FLASH - SETTINGS_REGION.end(),
+);
+
+pub mod cardstore;
+pub mod settings;
+pub mod store;

src/storage/cardstore.rs

@@ -0,0 +1,214 @@
+use alloc::collections::BTreeMap;
+use alloc::vec::Vec;
+
+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::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(StoreError),
+    CorruptedEntry(DeserializeError),
+    NoEntry,
+}
+
+impl From<StoreError> for CardStoreError {
+    fn from(error: StoreError) -> CardStoreError {
+        CardStoreError::Store(error)
+    }
+}
+
+impl From<DeserializeError> for CardStoreError {
+    fn from(error: DeserializeError) -> CardStoreError {
+        CardStoreError::CorruptedEntry(error)
+    }
+}
+
+pub struct CardStore {
+    store: Store,
+    count: u32,
+    pub allocation_table: BTreeMap<u32, AllocationTableEntry>,
+}
+
+impl CardStore {
+    pub fn new(mut store: Store) -> Result<Self, CardStoreError> {
+        let mut count_bytes: [u8; COUNT_REGION.size] = [0; COUNT_REGION.size];
+
+        store.read(COUNT_REGION.offset, &mut count_bytes)?;
+
+        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,
+        )?;
+
+        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 fn get_card_by_uuid(&mut self, uuid: u32) -> Result<RawCard, CardStoreError> {
+        let entry = self
+            .allocation_table
+            .get(&uuid)
+            .ok_or(CardStoreError::NoEntry)?;
+
+        let mut raw_card: [u8; size_of::<RawCard>()] = [0; size_of::<RawCard>()];
+        self.store.read(entry.offset, &mut raw_card)?;
+
+        Ok(RawCard::binary_deserialize(
+            raw_card.as_ref(),
+            Endianness::Little,
+        )?)
+    }
+
+    pub 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,
+            )?;
+        } 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,
+        )?;
+
+        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())?;
+        Ok(())
+    }
+}

src/storage/dex_db.rs

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

src/storage/nvs.rs

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

src/storage/store.rs

@@ -0,0 +1,78 @@
+use embedded_storage::nor_flash::NorFlash;
+use embedded_storage::nor_flash::ReadNorFlash;
+use esp_storage::{FlashStorage, FlashStorageError};
+
+use crate::storage::MAGIC_REGION;
+
+pub type StoreError = FlashStorageError;
+
+const FLASH_ADDR: u32 = 0x9000;
+
+const INITIALIZATION_SIZE: usize = 0x1000;
+const FLASH_INITIALIZE_MAGIC: u32 = 0xde6de6de;
+
+pub struct Store {
+    pub storage: FlashStorage<'static>,
+}
+
+impl Store {
+    pub fn new(flash: esp_hal::peripherals::FLASH<'static>) -> Result<Self, StoreError> {
+        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 })
+    }
+
+    pub fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
+        self.storage.read(FLASH_ADDR + offset, bytes)
+    }
+
+    pub fn write(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
+        log::debug!("Writing {} bytes at offset 0x{offset:08x}", bytes.len());
+        self.storage.write(FLASH_ADDR + offset, bytes)
+    }
+
+    pub fn write_erase(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
+        log::debug!(
+            "Erasing and Writing {} bytes at offset 0x{offset:08x}",
+            bytes.len()
+        );
+        self.storage
+            .erase(FLASH_ADDR + offset, FLASH_ADDR + bytes.len() as u32)?;
+        self.storage.write(FLASH_ADDR + offset, bytes)
+    }
+
+    pub fn has_magic_bytes(storage: &mut FlashStorage) -> Result<bool, StoreError> {
+        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<(), StoreError> {
+        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(StoreError::Other(FLASH_INITIALIZE_MAGIC as i32))
+        }
+    }
+}

src/views.rs

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

src/views/card_view.rs

@@ -1,5 +1,6 @@
 use crate::display::sprite::render_sprite_onto_ili9341;
 use crate::navigation::navigation::NewState;
+use crate::navigation::outputs::Outputs;
 use alloc::format;
 use embedded_graphics::mono_font::MonoTextStyle;
 use embedded_graphics::mono_font::ascii::FONT_6X10;
@@ -24,11 +25,9 @@ pub struct CardView {
 }
 
 impl Navigable for CardView {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
-    {
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        async move {
+            let display = &mut outputs.primary_display;
             display.clear(Rgb565::BLACK).unwrap();
 
             let background = Rectangle::new(Point::new(0, 0), Size::new(240, 320));
@@ -96,8 +95,7 @@ impl Navigable for CardView {
 
             let palette: Palette = self.card.cardtype.clone().into();
             render_sprite_onto_ili9341(display, self.card.sprite.data.as_slice(), &palette);
-
-        core::future::ready(())
+        }
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/flash_info_view.rs

@@ -0,0 +1,49 @@
+use crate::navigation::inputs::ButtonAction;
+use crate::navigation::navigation::Action;
+use crate::navigation::navigation::Navigable;
+use crate::navigation::navigation::NewState;
+use crate::navigation::outputs::Outputs;
+use crate::views::view::View;
+use embedded_graphics::mono_font::MonoTextStyle;
+use embedded_graphics::mono_font::ascii::FONT_10X20;
+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;
+
+#[derive(Debug, Clone)]
+pub struct FlashInfoView {}
+
+impl Navigable for FlashInfoView {
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+        Text::new("Flash Initialized: {:?}", Point::new(40, 40), style);
+
+        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::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

@@ -8,7 +8,10 @@ use embedded_graphics_core::draw_target::DrawTarget;
 
 use crate::{
     card::model::Card,
-    navigation::navigation::{Action, Navigable, NewState},
+    navigation::{
+        navigation::{Action, Navigable, NewState},
+        outputs::Outputs,
+    },
     views::view::View,
 };
 
@@ -19,14 +22,10 @@ pub struct JournalView {
 }
 
 impl Navigable for JournalView {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
-    {
-        display.clear(Rgb565::BLACK).unwrap();
-
-        core::future::ready(())
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        async move {
+            outputs.primary_display.clear(Rgb565::BLACK).unwrap();
+        }
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/main_menu.rs

@@ -4,6 +4,7 @@ use crate::card::model::Card;
 use crate::card::{decoder::split_nfc_hex, mock::*};
 
 use crate::navigation::inputs::ButtonAction;
+use crate::navigation::outputs::Outputs;
 use crate::views::card_view::CardView;
 use crate::views::journal_view::JournalView;
 use crate::views::{menu_item, settings_menu::SettingsMenu, view::View};
@@ -21,11 +22,8 @@ pub struct MainMenu {
 }
 
 impl Navigable for MainMenu {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
-    {
+    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);

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<'a, D>(display: &mut D, name: &str, position: i32, selected: i32)
+pub fn show<D>(display: &mut D, name: &str, position: i32, selected: i32)
 where
     D: DrawTarget<Color = Rgb565>,
     D::Error: core::fmt::Debug,

src/views/scan_menu.rs

@@ -1,10 +1,12 @@
 use crate::navigation::inputs::ButtonAction;
 use crate::navigation::navigation::CARD_DATA;
 use crate::navigation::navigation::NewState;
+use crate::navigation::outputs::Outputs;
 
 use alloc::format;
 use embedded_graphics::Drawable;
 use embedded_graphics::geometry::AngleUnit as _;
+use embedded_graphics::geometry::Dimensions as _;
 use embedded_graphics::geometry::Size;
 use embedded_graphics::mono_font::MonoTextStyle;
 use embedded_graphics::mono_font::ascii::FONT_10X20;
@@ -31,11 +33,8 @@ pub struct ScanMenu {
 }
 
 impl Navigable for ScanMenu {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
-    {
+    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();
 

src/views/settings_menu.rs

@@ -1,10 +1,14 @@
 use crate::navigation::navigation::{Action, Navigable, NewState};
-use crate::views::{menu_item, view::View};
+use crate::navigation::outputs::Outputs;
+use crate::views::{flash_info_view::FlashInfoView, menu_item, view::View};
+
+use crate::navigation::inputs::ButtonAction;
 
 use embedded_graphics::pixelcolor::Rgb565;
 use embedded_graphics::prelude::RgbColor;
 use embedded_graphics_core::draw_target::DrawTarget;
-pub const MAX_SELECTED: i8 = 2;
+
+pub const MAX_SELECTED: i32 = 2;
 
 #[derive(Debug, Clone)]
 pub struct SettingsMenu {
@@ -12,24 +16,55 @@ pub struct SettingsMenu {
 }
 
 impl Navigable for SettingsMenu {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
-    {
+    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);
+        menu_item::show(display, "Flash Information", 2, self.selected);
 
         core::future::ready(())
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
         async move {
-            NewState {
-                view: View::Settings(SettingsMenu { selected: 0 }),
+            let Action::Button(input) = input else {
+                // Skip timer inputs
+                return NewState {
+                    view: View::Settings(self.clone()),
                     replace_view: true,
-                redraw: !matches!(input, Action::Timer),
+                    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,
             }
         }
     }

src/views/view.rs

@@ -1,10 +1,8 @@
-use embedded_graphics::draw_target::DrawTarget;
-use embedded_graphics::pixelcolor::Rgb565;
-
+use crate::navigation::outputs::Outputs;
 use crate::views::card_view::CardView;
 use crate::views::{
-    journal_view::JournalView, main_menu::MainMenu, scan_menu::ScanMenu,
-    settings_menu::SettingsMenu,
+    flash_info_view::FlashInfoView, journal_view::JournalView, main_menu::MainMenu,
+    scan_menu::ScanMenu, settings_menu::SettingsMenu,
 };
 
 use crate::navigation::navigation::{Navigable, NewState};
@@ -16,21 +14,19 @@ pub enum View {
     Settings(SettingsMenu),
     Journal(JournalView),
     Card(CardView),
+    FlashInfo(FlashInfoView),
 }
 
 impl Navigable for View {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565> + Send,
-        D::Error: core::fmt::Debug,
-    {
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
         async move {
             match self {
-                View::Main(main_menu) => main_menu.display(display).await,
-                View::Scan(scan_menu) => scan_menu.display(display).await,
-                View::Settings(settings_menu) => settings_menu.display(display).await,
-                View::Journal(journal_view) => journal_view.display(display).await,
-                View::Card(card_view) => card_view.display(display).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,
+                View::FlashInfo(flash_info_view) => flash_info_view.display(outputs).await,
             }
         }
     }
@@ -46,6 +42,7 @@ impl Navigable for View {
                 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,
             }
         }
     }