vibe-code wokwi display ch1115 integration

.gitignore

@@ -32,3 +32,6 @@ creaturedex.wiki/
 *.zip
 *.lck
 schematics/.history/
+
+wokwi/wokwi-api.h
+wokwi/ch1115.chip.wasm

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"
@@ -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"
@@ -319,9 +348,9 @@ name = "creaturedex"
 version = "0.1.0"
 dependencies = [
  "base64 0.23.1",
+ "binary_serde",
  "ch1115",
  "critical-section",
- "display-interface",
  "display-interface-spi",
  "embassy-executor",
  "embassy-futures",
@@ -333,18 +362,21 @@ dependencies = [
  "embedded-hal-async",
  "embedded-hal-bus",
  "embedded-io 0.7.1",
+ "embedded-storage",
+ "embedded-text",
  "esp-alloc",
  "esp-bootloader-esp-idf",
  "esp-hal",
  "esp-hal-wifimanager",
  "esp-println",
  "esp-rtos",
+ "esp-storage",
  "i2c-character-display",
  "ili9341",
  "log",
  "num_enum",
  "pn532",
- "ssd1306",
+ "static_assertions",
 ]
 
 [[package]]
@@ -609,17 +641,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ba2aab1ef3793e6f7804162debb5ac5edb93b3d650fbcc5aeb72fcd0e6c03a0"
 
-[[package]]
-name = "display-interface-i2c"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d964fa85bbbb5a6ecd06e58699407ac5dc3e3ad72dac0ab7e6b0d00a1cd262d"
-dependencies = [
- "display-interface",
- "embedded-hal 1.0.0",
- "embedded-hal-async",
-]
-
 [[package]]
 name = "display-interface-spi"
 version = "0.5.0"
@@ -1029,6 +1050,17 @@ dependencies = [
  "embedded-storage",
 ]
 
+[[package]]
+name = "embedded-text"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cf5c72c52db2f7dbe4a9c1ed81cd21301e8d66311b194fa41c04fb4f71843ba"
+dependencies = [
+ "az",
+ "embedded-graphics",
+ "object-chain",
+]
+
 [[package]]
 name = "enumset"
 version = "1.1.14"
@@ -1955,19 +1987,6 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
-[[package]]
-name = "maybe-async-cfg"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e083394889336bc66a4eaf1011ffbfa74893e910f902a9f271fa624c61e1b2"
-dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "pulldown-cmark",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "memchr"
 version = "2.8.3"
@@ -2123,6 +2142,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "object-chain"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41af26158b0f5530f7b79955006c2727cd23d0d8e7c3109dc316db0a919784dd"
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -2716,30 +2741,6 @@ dependencies = [
  "toml_edit",
 ]
 
-[[package]]
-name = "proc-macro-error"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
-dependencies = [
- "proc-macro-error-attr",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
-dependencies = [
- "proc-macro2",
- "quote",
- "version_check",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.107"
@@ -2769,17 +2770,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "pulldown-cmark"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "679341d22c78c6c649893cbd6c3278dcbe9fc4faa62fea3a9296ae2b50c14625"
-dependencies = [
- "bitflags 2.13.1",
- "memchr",
- "unicase",
-]
-
 [[package]]
 name = "quote"
 version = "1.0.47"
@@ -2857,6 +2847,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"
@@ -3194,20 +3190,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0f368519fc6c85fc1afdb769fb5a51123f6158013e143656e25a3485a0d401c"
 
-[[package]]
-name = "ssd1306"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ea6aac2d078bbc71d9b8ac3f657335311f3b6625e9a1a96ccc29f5abfa77c56"
-dependencies = [
- "display-interface",
- "display-interface-i2c",
- "display-interface-spi",
- "embedded-graphics-core",
- "embedded-hal 1.0.0",
- "maybe-async-cfg",
-]
-
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -3348,6 +3330,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"
@@ -3475,12 +3477,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e87a2ed6b42ec5e28cc3b94c09982969e9227600b2e3dcbc1db927a84c06bd69"
 
-[[package]]
-name = "unicase"
-version = "2.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
-
 [[package]]
 name = "unicode-id-start"
 version = "1.4.0"

Cargo.toml

@@ -1,15 +1,19 @@
 [package]
-edition      = "2024"
+edition = "2024"
-name         = "creaturedex"
+name = "creaturedex"
 rust-version = "1.88"
-version      = "0.1.0"
+version = "0.1.0"
 
 [[bin]]
 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",
@@ -20,12 +24,11 @@ esp-rtos = { version = "0.3.0", features = [
 ] }
 
 esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32s3", "log-04"] }
-log                    = "0.4.27"
+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"
@@ -35,7 +38,6 @@ esp-hal-wifimanager = { git = "https://github.com/InvisibleUSA/esp-hal-wifimanag
 ] }
 esp-println = { version = "0.17.0", features = ["esp32s3", "log-04"] }
 display-interface-spi = "0.5.0"
-display-interface = "*"
 ili9341 = "0.6.0"
 embedded-hal = "1.0.0"
 embedded-hal-bus = "0.3.0"
@@ -48,7 +50,14 @@ embassy-sync = "0.8.0"
 embedded-hal-async = "1.0.0"
 i2c-character-display = "0.5.1"
 ch1115 = { version = "0.1.2", features = ["graphics"] }
-ssd1306 = { version = "0.10.0", features = [] }
+esp-storage = "0.9.0"
+embedded-storage = "0.3.1"
+binary_serde = "1.0.25"
+static_assertions = { version = "1.1.0", default-features = false }
+embedded-text = "0.7.3"
+
+[build-dependencies]
+log = "0.4.27"
 
 
 [patch.crates-io]
@@ -66,10 +75,10 @@ opt-level = 3
 debug = 0
 
 [profile.release]
-codegen-units = 1     # LLVM can perform better optimizations using a single thread
+codegen-units = 1 # LLVM can perform better optimizations using a single thread
-debug         = 2     # prefer slower builds but better debugging experience
+debug = 2         # prefer slower builds but better debugging experience
-lto           = 'fat'
+lto = 'fat'
-opt-level     = 's'
+opt-level = 's'
 
 [features]
 default = []

build.rs

@@ -1,4 +1,6 @@
 fn main() {
+    generate_filter_snippet();
+    compile_custom_wokwi_components();
     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 +70,187 @@ fn linker_be_nice() {
         std::env::current_exe().unwrap().display()
     );
 }
+
+fn compile_custom_wokwi_components() {
+    use std::process::Command;
+
+    if std::env::var("CARGO_FEATURE_WOKWI").is_ok() {
+        println!("cargo:rerun-if-changed=wokwi/ch1115.chip.c");
+        println!("cargo:rerun-if-changed=wokwi/ch1115.chip.json");
+        println!("cargo:rerun-if-changed=wokwi/Makefile");
+
+        let status = Command::new("make")
+            .current_dir("wokwi")
+            .status()
+            .expect("Failed to execute make command. Is 'make' installed?");
+
+        if !status.success() {
+            panic!(
+                "Wokwi custom chip compilation failed with status: {}",
+                status
+            );
+        }
+    }
+}
+
+// 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
+}

diagram.json

@@ -59,19 +59,23 @@
       "top": -291.2,
       "left": -167.2,
       "attrs": { "pins": "i2c" }
-    }
+    },
+    { "type": "chip-ch1115", "id": "chip1", "top": 509.82, "left": -4.8, "attrs": {} },
+    { "type": "chip-ch1115", "id": "chip2", "top": 625.02, "left": -4.8, "attrs": {} },
+    { "type": "chip-ch1115", "id": "chip3", "top": 394.62, "left": -4.8, "attrs": {} },
+    { "type": "wokwi-vcc", "id": "vcc1", "top": 39.16, "left": 316.8, "attrs": {} }
   ],
   "connections": [
     [ "esp1:TX", "$serialMonitor:RX", "", [] ],
     [ "esp1:RX", "$serialMonitor:TX", "", [] ],
     [ "lcd1:VCC", "esp1:3V3", "red", [ "v19.2", "h-57.6", "v-105.6", "h-124.95" ] ],
     [ "lcd1:GND", "esp1:GND.2", "black", [ "v28.8", "h-76.8", "v-76.8" ] ],
-    [ "lcd1:CS", "esp1:11", "orange", [ "v0" ] ],
+    [ "lcd1:CS", "esp1:11", "orange", [ "v259.2", "h-729.6", "v-95.82" ] ],
-    [ "lcd1:D/C", "esp1:12", "gold", [ "v0" ] ],
+    [ "lcd1:D/C", "esp1:12", "gold", [ "v278.4", "h-729.6", "v-105.42" ] ],
     [ "lcd1:RESET", "esp1:10", "brown", [ "v0" ] ],
-    [ "lcd1:MOSI", "esp1:35", "violet", [ "v105.6", "h-124.8", "v-144" ] ],
+    [ "lcd1:MOSI", "esp1:35", "violet", [ "v124.8", "h-124.8", "v0.18" ] ],
     [ "lcd1:SCK", "esp1:36", "white", [ "v115.2", "h-144", "v-86.4" ] ],
-    [ "esp1:37", "lcd1:MISO", "magenta", [ "h57.6", "v105.6", "h172.8" ] ],
+    [ "esp1:37", "lcd1:MISO", "magenta", [ "h57.6", "v-0.18", "h594.94" ] ],
     [ "btn-up:2.l", "esp1:38", "purple", [ "h-9.6", "v19.4" ] ],
     [ "btn-up:1.l", "esp1:GND.2", "black", [ "h0" ] ],
     [ "btn-down:1.l", "esp1:GND.2", "black", [ "h0" ] ],
@@ -87,7 +91,31 @@
     [ "lcd2:GND", "esp1:GND.2", "black", [ "h0" ] ],
     [ "lcd2:VCC", "esp1:3V3.1", "red", [ "h0" ] ],
     [ "lcd2:SDA", "esp1:17", "green", [ "h-134.4", "v413" ] ],
-    [ "lcd2:SCL", "esp1:18", "green", [ "h-124.8", "v38.7" ] ]
+    [ "lcd2:SCL", "esp1:18", "green", [ "h-124.8", "v38.7" ] ],
+    [ "chip2:RES", "chip1:RES", "gray", [ "h-28.8", "v-115.2" ] ],
+    [ "chip1:RES", "chip3:RES", "gray", [ "h-28.8", "v-67.2" ] ],
+    [ "chip2:GND", "chip1:GND", "black", [ "h-48", "v-115.2" ] ],
+    [ "chip1:GND", "chip3:GND", "black", [ "h-48", "v-115.2" ] ],
+    [ "chip2:VCC", "chip1:VCC", "red", [ "h-38.4", "v-115.2" ] ],
+    [ "chip3:VCC", "chip1:VCC", "red", [ "h-38.4", "v115.2" ] ],
+    [ "chip2:DC", "chip1:DC", "gold", [ "h46.84", "v-115.2" ] ],
+    [ "chip1:DC", "chip3:DC", "gold", [ "h46.84", "v-115.2" ] ],
+    [ "chip2:SCL", "chip1:SCL", "white", [ "h56.44", "v-115.2" ] ],
+    [ "chip1:SCL", "chip3:SCL", "white", [ "h56.44", "v-115.2" ] ],
+    [ "chip3:SDA", "chip1:SDA", "violet", [ "h-1.16", "h67.2", "v57.6" ] ],
+    [ "chip1:SDA", "chip2:SDA", "violet", [ "h66.04", "v115.2" ] ],
+    [ "esp1:35", "chip3:SDA", "violet", [ "h364.53", "v153.42" ] ],
+    [ "chip3:SCL", "esp1:36", "white", [ "h56.44", "v-172.62" ] ],
+    [ "esp1:12", "chip3:DC", "gold", [ "h-29.12", "v105.42", "h460.8", "v67.2" ] ],
+    [ "esp1:GND.4", "chip3:GND", "black", [ "h18.93", "v19.02", "h105.6", "v48" ] ],
+    [ "esp1:3V3.1", "chip3:VCC", "red", [ "h-57.92", "v259.02" ] ],
+    [ "lcd1:VCC", "vcc1:VCC", "red", [ "v67.2", "h-48" ] ],
+    [ "lcd1:LED", "vcc1:VCC", "red", [ "v67.2", "h-144.01" ] ],
+    [ "lcd1:RST", "esp1:10", "gray", [ "v268.8", "h-729.6", "v-115.02" ] ],
+    [ "esp1:47", "chip3:RES", "gray", [ "h28.53", "v182.22" ] ],
+    [ "chip3:CS", "esp1:13", "blue", [ "h-278.4", "v-153.42" ] ],
+    [ "esp1:14", "chip1:CS", "magenta", [ "h-9.92", "v259.02" ] ],
+    [ "esp1:21", "chip2:CS", "#8f4814", [ "h95.73", "v316.62" ] ]
   ],
   "dependencies": {}
 }

model/common.scad

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

src/background_tasks/nfc.rs

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

src/bin/main.rs

@@ -7,18 +7,24 @@
 )]
 #![deny(clippy::large_stack_frames)]
 
+use alloc::boxed::Box;
 use creaturedex::background_tasks;
 use creaturedex::drivers::i2c_bus::I2cBusPinConfiguration;
 use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
+use creaturedex::drivers::primary_lcd::PrimaryDisplay;
 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::navigation::Mutex;
 use creaturedex::navigation::inputs::Inputs;
 use creaturedex::navigation::navigation::{self};
 use creaturedex::navigation::outputs::Outputs;
-use creaturedex::network::wifi::setup_wifi;
+use creaturedex::peripherals::Peripherals;
+use creaturedex::peripherals::storage::cardstore::CardStore;
+use creaturedex::peripherals::storage::flash_store::FlashStore;
+use creaturedex::peripherals::storage::store::Store;
 use embassy_executor::Spawner;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::{
@@ -32,6 +38,8 @@ 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);
@@ -52,55 +60,86 @@ 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);
+    let esp_peripherals = esp_hal::init(config);
 
     esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: HEAP_SIZE);
 
     let sw_interrupt =
-        esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
+        esp_hal::interrupt::software::SoftwareInterruptControl::new(esp_peripherals.SW_INTERRUPT);
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
+    let timg0 = TimerGroup::new(esp_peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
 
-    let (primary, mut secondaries) = spi_bus::DisplayPinConfiguration {
+    let (mut primary, mut secondaries) = retry(
-        spi_peripheral: peripherals.SPI2,
+        5,
-        sck: peripherals.GPIO36,
+        spi_bus::DisplayPinConfiguration {
-        mosi: peripherals.GPIO35,
+            spi_peripheral: esp_peripherals.SPI2,
-        miso: peripherals.GPIO37,
+            sck: esp_peripherals.GPIO36,
-        cs_primary: peripherals.GPIO11,
+            mosi: esp_peripherals.GPIO35,
-        cs_secondary_1: peripherals.GPIO13,
+            miso: esp_peripherals.GPIO37,
-        cs_secondary_2: peripherals.GPIO14,
+            cs_primary: esp_peripherals.GPIO11,
-        cs_secondary_3: peripherals.GPIO21,
+            cs_secondary_1: esp_peripherals.GPIO13,
-        reset_primary: peripherals.GPIO10,
+            cs_secondary_2: esp_peripherals.GPIO14,
-        reset_secondary: peripherals.GPIO47,
+            cs_secondary_3: esp_peripherals.GPIO21,
-        dc_pin: peripherals.GPIO12,
+            reset_primary: esp_peripherals.GPIO10,
-    }
+            reset_secondary: esp_peripherals.GPIO47,
-    .build();
+            dc_pin: esp_peripherals.GPIO12,
+        },
+        spi_bus::DisplayPinConfiguration::build,
+    );
 
     // Initialize the shared I2C bus using the refactored i2c_bus module.
     let shared_i2c = {
-        let config = I2cBusPinConfiguration {
+        let bus = retry(
-            i2c_peripheral: peripherals.I2C0,
+            5,
-            scl: peripherals.GPIO18,
+            I2cBusPinConfiguration {
-            sda: peripherals.GPIO17,
+                i2c_peripheral: esp_peripherals.I2C0,
-        };
+                scl: esp_peripherals.GPIO18,
-        config.build()
+                sda: esp_peripherals.GPIO17,
+            },
+            I2cBusPinConfiguration::build,
+        );
+        Box::leak(Box::new(bus))
     };
 
-    let mut lcd: TertiaryDisplay = TertiaryDisplayPinConfiguration { i2c: shared_i2c }.build();
+    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.")) {
+    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: {e}"
         );
     }
 
-    setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
+    let flash_store = Box::leak(Box::new(
+        FlashStore::new(esp_peripherals.FLASH).expect("Could not initialize Flash Store"),
+    ));
+
+    let card_store = CardStore::new(flash_store)
+        .await
+        .expect("Could not initialize Card Store");
+
+    let store = Store {
+        flash_store,
+        card_store,
+    };
+    let rtc = Rtc::new(esp_peripherals.LPWR);
+    //setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
+
+    let peripherals = Box::leak(Box::new(Peripherals {
+        store: Mutex::new(store),
+        rtc,
+    }));
 
     let mut nfc_driver = NfcPn532Driver::new(AtomicDevice::new(shared_i2c));
     if nfc_driver.configure_sam().await.is_ok() {
@@ -111,17 +150,18 @@ async fn main(spawner: Spawner) {
 
     let button_config = InputConfig::default().with_pull(Pull::Up);
     let inputs = Inputs {
-        up: Input::new(peripherals.GPIO38, button_config),
+        up: Input::new(esp_peripherals.GPIO38, button_config),
-        down: Input::new(peripherals.GPIO39, button_config),
+        down: Input::new(esp_peripherals.GPIO39, button_config),
-        left: Input::new(peripherals.GPIO40, button_config),
+        left: Input::new(esp_peripherals.GPIO40, button_config),
-        right: Input::new(peripherals.GPIO41, button_config),
+        right: Input::new(esp_peripherals.GPIO41, button_config),
-        back: Input::new(peripherals.GPIO8, button_config),
+        back: Input::new(esp_peripherals.GPIO8, button_config),
-        ok: Input::new(peripherals.GPIO0, button_config),
+        ok: Input::new(esp_peripherals.GPIO0, button_config),
     };
 
     display_shit(&mut secondaries[0], "foo 1");
     display_shit(&mut secondaries[1], "bar 1");
     display_shit(&mut secondaries[2], "baz 1");
+    display_shit_prim(&mut primary, "Hello World");
 
     let outputs = {
         let [sec_1, sec_2, sec_3] = secondaries;
@@ -136,12 +176,15 @@ async fn main(spawner: Spawner) {
     };
 
     log::info!("Setup complete, entering main loop");
-    spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
+    spawner.spawn(navigation::run(inputs, outputs, peripherals).expect("run task failed"));
-    spawner.spawn(background_tasks::nfc_scanner(nfc_driver).expect("nfc scanner task failed"));
+    spawner.spawn(
+        background_tasks::nfc_scanner(nfc_driver, peripherals).expect("nfc scanner task failed"),
+    );
+    core::future::pending::<()>().await
 }
 
 fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
-    oled.clear(BinaryColor::Off).unwrap();
+    oled.clear().unwrap();
 
     let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
     Text::new(text, Point::new(10, 20), text_style)
@@ -149,3 +192,27 @@ fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
         .unwrap();
     oled.flush().unwrap();
 }
+
+fn display_shit_prim(main: &mut PrimaryDisplay<'static>, text: &str) {
+    use embedded_graphics::pixelcolor::Rgb565;
+    main.clear(Rgb565::BLACK).unwrap();
+
+    let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
+    Text::new(text, Point::new(10, 20), text_style)
+        .draw(main)
+        .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 {
+    Some(RawCard {
-        event_encoding: &payload[0..2],
+        event_encoding: payload[0..2].try_into().ok()?,
         card_type: payload[2],
-        card_uuid: &payload[3..5],
+        card_uuid: payload[3..5].try_into().ok()?,
-        _reserved: &payload[5..9],
+        _reserved: payload[5..9].try_into().ok()?,
-        sprite: &payload[9..0x2DB],
+        sprite: payload[9..0x2DB].try_into().ok()?,
-        packed_card_text: &payload[0x2DB..0x311],
+        packed_card_text: payload[0x2DB..0x311].try_into().ok()?,
-        secret: &payload[0x311..0x329],
+        secret: payload[0x311..0x329].try_into().ok()?,
-        _opaque_trailer: &payload[0x329..0x35A],
+        _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)]
+use binary_serde::BinarySerde;
-pub struct NfcPayload<'a> {
+
-    pub event_encoding: &'a [u8],
+#[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 card_uuid: [u8; 2],
-    pub _reserved: &'a [u8],
+    pub _reserved: [u8; 4],
-    pub sprite: &'a [u8],
+    pub sprite: [u8; 722],
-    pub packed_card_text: &'a [u8],
+    pub packed_card_text: [u8; 54],
-    pub secret: &'a [u8],
+    pub secret: [u8; 24],
-    pub _opaque_trailer: &'a [u8],
+    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 {
@@ -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> {
+    fn try_from(raw_card: RawCard) -> Result<Self, Self::Error> {
-        let uuid: String = "empty for now".into(); //str::from_utf8(payload.card_uuid).unwrap().into();
+        let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16
-        let event = decode_known_event(payload.event_encoding);
+            | (u16::from_ne_bytes(raw_card.card_uuid) as u32);
-        let cardtype = CardType::from(payload.card_type);
+
-        let (name, trait1, trait2, trait3) = decode_packed_card_text(payload.packed_card_text);
+        let event = decode_known_event(&raw_card.event_encoding);
-        let secret = decode_secret(payload.secret);
+        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/drivers/i2c_bus.rs

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

src/drivers/primary_lcd.rs

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

src/drivers/secondary_oled.rs

@@ -1,6 +1,6 @@
-use alloc::{format, string::String};
+use alloc::format;
+use ch1115::{Ch1115, Size128x64};
 use display_interface_spi::SPIInterface;
-use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_hal_bus::spi::AtomicDevice;
 use embedded_hal_bus::util::AtomicCell;
 use esp_hal::delay::Delay;
@@ -8,72 +8,10 @@ use esp_hal::gpio::Output;
 
 use crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput, SharedReset};
 
-pub struct SecondaryDisplay<'a>(
+pub type GenericSecondaryDisplay<'a, BUS, RST, DC> =
-    #[cfg(feature = "wokwi")] ssd1306_aliases::SecondaryDisplay<'a>,
+    Ch1115<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RST, Size128x64>;
-    #[cfg(not(feature = "wokwi"))] ch1115_aliases::SecondaryDisplay<'a>,
+pub type SecondaryDisplay<'a> =
-);
+    GenericSecondaryDisplay<'a, DisplaySpiBus, SharedReset<'a>, SharedOutput<'a>>;
-
-impl<'a> SecondaryDisplay<'a> {
-    pub fn flush(&mut self) -> Result<(), String> {
-        #[cfg(not(feature = "wokwi"))]
-        return self.0.flush().map_err(|e| format!("{e:?}"));
-        #[cfg(feature = "wokwi")]
-        return Ok(());
-    }
-}
-
-impl<'a> embedded_graphics::geometry::Dimensions for SecondaryDisplay<'a> {
-    fn bounding_box(&self) -> embedded_graphics::primitives::Rectangle {
-        self.0.bounding_box()
-    }
-}
-
-impl<'a> embedded_graphics::draw_target::DrawTarget for SecondaryDisplay<'a> {
-    type Color = BinaryColor;
-
-    type Error = String;
-
-    fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
-    where
-        I: IntoIterator<Item = embedded_graphics::prelude::Pixel<Self::Color>>,
-    {
-        self.0.draw_iter(pixels).map_err(|e| format!("{e:?}"))
-    }
-
-    fn fill_contiguous<I>(
-        &mut self,
-        area: &embedded_graphics::primitives::Rectangle,
-        colors: I,
-    ) -> Result<(), Self::Error>
-    where
-        I: IntoIterator<Item = Self::Color>,
-    {
-        self.0
-            .fill_contiguous(area, colors)
-            .map_err(|e| format!("{e:?}"))
-    }
-
-    fn fill_solid(
-        &mut self,
-        area: &embedded_graphics::primitives::Rectangle,
-        color: Self::Color,
-    ) -> Result<(), Self::Error> {
-        self.0.fill_solid(area, color).map_err(|e| format!("{e:?}"))
-    }
-
-    fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error> {
-        #[cfg(feature = "wokwi")]
-        return self.0.clear(color).map_err(|e| format!("{e:?}"));
-
-        #[cfg(not(feature = "wokwi"))]
-        {
-            let _ = color;
-            self.0.clear().map_err(|e| format!("{e:?}"))
-        }
-    }
-}
-
-pub const SECONDARY_DISPLAY_COUNT: usize = 3;
 
 pub struct SecondaryDisplayPinConfiguration<'a> {
     pub spi_bus: &'a AtomicCell<DisplaySpiBus>,
@@ -83,112 +21,39 @@ pub struct SecondaryDisplayPinConfiguration<'a> {
 }
 
 impl<'a> SecondaryDisplayPinConfiguration<'a> {
-    pub fn build(self) -> [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
+    pub fn build(self) -> [SecondaryDisplay<'a>; 3] {
-        #[cfg(feature = "wokwi")]
+        let mut displays = self.cs_pins.map(|cs| {
-        type Displays<'b> = [ssd1306_aliases::SecondaryDisplay<'b>; SECONDARY_DISPLAY_COUNT];
+            let spi_dev = AtomicDevice::new(self.spi_bus, cs, Delay::new()).unwrap();
-        #[cfg(not(feature = "wokwi"))]
+            let interface = SPIInterface::new(spi_dev, self.dc.clone());
-        type Displays<'b> = [ch1115_aliases::SecondaryDisplay<'b>; SECONDARY_DISPLAY_COUNT];
 
-        let reset_pin = self.res.clone();
+            Ch1115::new(interface, self.res.clone(), Size128x64)
-        let mut displays = Displays::new(self);
+        });
-        displays.reset(reset_pin);
 
-        displays.map(SecondaryDisplay)
+        init_single_reset(&mut displays, self.res);
+
+        displays
     }
 }
 
-trait MultiDisplay<'a> {
+fn init_single_reset<'a: 'b, 'b>(
-    fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self;
+    displays: impl IntoIterator<Item = &'b mut SecondaryDisplay<'a>>,
-    fn reset(&mut self, shared_reset: SharedReset<'a>);
+    shared_reset: SharedReset<'a>,
-}
+) {
+    let mut displays = displays.into_iter().peekable();
 
-mod ch1115_aliases {
+    // Reset all secondaries via shared reset
-    use super::*;
+    let Some(any_display) = displays.peek_mut() else {
-    use ch1115::{Ch1115, Size128x64};
+        // no display to initialize
-
+        return;
-    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>>;
-
-    impl<'a> MultiDisplay<'a> for [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
-        fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self {
-            config.cs_pins.map(|cs| {
-                let spi_dev = AtomicDevice::new(config.spi_bus, cs, Delay::new()).unwrap();
-                let interface = SPIInterface::new(spi_dev, config.dc.clone());
-
-                SecondaryDisplay::new(interface, config.res.clone(), Size128x64)
-            })
-        }
-
-        fn reset(&mut self, shared_reset: SharedReset<'a>) {
-            let mut displays = self.iter_mut().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();
-            }
-        }
-    }
-}
-
-mod ssd1306_aliases {
-    use super::*;
-    use ssd1306::{
-        Ssd1306, mode::BufferedGraphicsMode, rotation::DisplayRotation, size::DisplaySize128x64,
     };
+    any_display.hard_reset(&mut Delay::new()).unwrap();
 
-    type GenericSecondaryDisplay<'a, BUS, DC> = Ssd1306<
+    shared_reset.disable(true);
-        SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>,
-        DisplaySize128x64,
-        BufferedGraphicsMode<DisplaySize128x64>,
-    >;
-    pub type SecondaryDisplay<'a> = GenericSecondaryDisplay<'a, DisplaySpiBus, SharedOutput<'a>>;
 
-    impl<'a> MultiDisplay<'a> for [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
+    for (i, display) in displays.enumerate() {
-        fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self {
+        display
-            config.cs_pins.map(|cs| {
+            .init(&mut Delay::new())
-                let spi_dev = AtomicDevice::new(config.spi_bus, cs, Delay::new()).unwrap();
+            .map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
-                let interface = SPIInterface::new(spi_dev, config.dc.clone());
+            .unwrap();
-
-                Ssd1306::new(interface, DisplaySize128x64, DisplayRotation::Rotate0)
-                    .into_buffered_graphics_mode()
-            })
-        }
-
-        fn reset(&mut self, mut shared_reset: SharedReset<'a>) {
-            use ssd1306::mode::DisplayConfig as _;
-
-            let mut displays = self.iter_mut().peekable();
-
-            // Reset all secondaries via shared reset
-            let Some(any_display) = displays.peek_mut() else {
-                // no display to initialize
-                return;
-            };
-            any_display
-                .reset(&mut shared_reset, &mut Delay::new())
-                .unwrap();
-
-            shared_reset.disable(true);
-
-            for (i, display) in displays.enumerate() {
-                display
-                    .init()
-                    .map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
-                    .unwrap();
-            }
-        }
     }
 }

src/drivers/spi_bus.rs

@@ -135,7 +135,7 @@ where
     RES2: OutputPin + 'static,
     DC: OutputPin + 'static,
 {
-    pub fn build(self) -> (PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]) {
+    pub fn build(self) -> Result<(PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]), Self> {
         let spi = Spi::new(
             self.spi_peripheral,
             SpiConfig::default()
@@ -158,14 +158,7 @@ where
             OutputConfig::default(),
         ));
 
-        let primary = PrimaryDisplayPinConfiguration {
+        // Secondary displays must come first or they don't work in wokwi for some reason.
-            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: [
@@ -174,11 +167,19 @@ where
                 low_active(self.cs_secondary_3),
             ],
             res: reset_secondary,
+            dc: dc.clone(),
+        }
+        .build();
+        
+        let primary = PrimaryDisplayPinConfiguration {
+            spi_bus: bus_static,
+            cs: low_active(self.cs_primary),
+            reset: low_active(self.reset_primary),
             dc,
         }
         .build();
 
-        (primary, secondaries)
+        Ok((primary, secondaries))
     }
 }
 

src/drivers/tertiary_lcd.rs

@@ -15,19 +15,20 @@ pub struct TertiaryDisplayPinConfiguration<'a> {
 }
 
 impl<'a> TertiaryDisplayPinConfiguration<'a> {
-    pub fn build(self) -> TertiaryDisplay<'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");
-                TertiaryDisplay {
+                Ok(TertiaryDisplay {
                     display: lcd,
                     charset: create_custom_char_set!(),
-                }
+                })
             }
             Err(e) => {
-                panic!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
+                log::error!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
+                Err(self)
             }
         }
     }
@@ -407,4 +408,3 @@ pub const BOX: CharMap = [
 ];
 
 pub const EXAMPLE: CustomCharset = create_custom_char_set!(HEART, BOX, EMPTY);
-

src/lib.rs

@@ -1,4 +1,5 @@
 #![no_std]
+#![feature(vec_into_chunks)]
 
 extern crate alloc;
 
@@ -6,7 +7,8 @@ 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;
+pub mod peripherals;
 pub mod views;

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/navigation.rs

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

src/navigation/outputs.rs

@@ -1,5 +1,6 @@
 use embedded_graphics::{
-    draw_target::DrawTarget as _, pixelcolor::{BinaryColor, Rgb565, RgbColor as _},
+    draw_target::DrawTarget as _,
+    pixelcolor::{Rgb565, RgbColor as _},
 };
 
 use crate::drivers::{
@@ -18,9 +19,9 @@ pub struct Outputs {
 impl Outputs {
     pub fn clear_screens(&mut self) {
         self.primary_display.clear(Rgb565::BLACK).unwrap();
-        self.secondary_display_1.clear(BinaryColor::Off).unwrap();
+        self.secondary_display_1.clear().unwrap();
-        self.secondary_display_2.clear(BinaryColor::Off).unwrap();
+        // self.secondary_display_2.clear().unwrap();
-        self.secondary_display_3.clear(BinaryColor::Off).unwrap();
+        // self.secondary_display_3.clear().unwrap();
         self.tertiary_display.clear().unwrap();
     }
 }

src/peripherals.rs

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

src/peripherals/storage.rs

@@ -0,0 +1,32 @@
+pub struct MemoryRegion {
+    pub offset: u32,
+    pub size: usize,
+}
+
+impl MemoryRegion {
+    pub const fn new(offset: u32, size: usize) -> Self {
+        assert!(offset.is_multiple_of(4), "Flash requires 4 bytes alignment");
+        assert!(size.is_multiple_of(4), "Flash requires 4 bytes alignment");
+        Self { offset, size }
+    }
+
+    pub const fn end(&self) -> usize {
+        self.offset as usize + self.size
+    }
+}
+
+pub const MAX_FLASH: usize = 16 * 1024 * 1024;
+
+pub const MAGIC_REGION: MemoryRegion = MemoryRegion::new(0, 4);
+
+pub const SETTINGS_REGION: MemoryRegion = MemoryRegion::new(MAGIC_REGION.end() as u32, 1024);
+
+pub const CARDSTORE_REGION: MemoryRegion = MemoryRegion::new(
+    SETTINGS_REGION.end() as u32,
+    MAX_FLASH - SETTINGS_REGION.end(),
+);
+
+pub mod cardstore;
+pub mod flash_store;
+pub mod settings;
+pub mod store;

src/peripherals/storage/cardstore.rs

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

src/peripherals/storage/flash_store.rs

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

src/peripherals/storage/store.rs

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

src/storage.rs

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

src/storage/dex_db.rs

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

src/storage/nvs.rs

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

src/views.rs

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

src/views/card_view.rs

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

src/views/error_view.rs

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

src/views/flash_info_view.rs

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

src/views/journal_view.rs

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

src/views/main_menu.rs

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

src/views/menu_item.rs

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

src/views/scan_menu.rs

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

src/views/settings_menu.rs

@@ -1,11 +1,18 @@
+use crate::drivers::primary_lcd::PrimaryDisplayError;
 use crate::navigation::navigation::{Action, Navigable, NewState};
 use crate::navigation::outputs::Outputs;
-use crate::views::{menu_item, view::View};
+use crate::peripherals::Peripherals;
+use crate::views::{flash_info_view::FlashInfoView, menu_item, view::View};
+use alloc::boxed::Box;
+use core::error;
+
+use crate::navigation::inputs::ButtonAction;
 
 use 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 {
@@ -13,21 +20,63 @@ pub struct SettingsMenu {
 }
 
 impl Navigable for SettingsMenu {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+    fn display(
-        let display = &mut outputs.primary_display;
+        &self,
-        display.clear(Rgb565::BLACK).unwrap();
+        outputs: &mut Outputs,
-        menu_item::show(display, "System Inforation", 0, self.selected);
+        _: &Peripherals,
-        menu_item::show(display, "Wifi Information", 1, self.selected);
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
-
+        async move {
-        core::future::ready(())
+            let display = &mut outputs.primary_display;
+            display.clear(Rgb565::BLACK).unwrap();
+            menu_item::show(display, "System Inforation", 0, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Wifi Information", 1, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Flash Information", 2, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            Ok(())
+        }
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
         async move {
+            let Action::Button(input) = input else {
+                // Skip timer inputs
+                return NewState {
+                    view: View::Settings(self.clone()),
+                    replace_view: true,
+                    redraw: false,
+                };
+            };
+
+            let new_menu = match input {
+                ButtonAction::Up => {
+                    let new_selected = if (self.selected - 1) < 0 {
+                        MAX_SELECTED - 1
+                    } else {
+                        self.selected - 1
+                    };
+                    View::Settings(SettingsMenu {
+                        selected: new_selected,
+                    })
+                }
+                ButtonAction::Down => {
+                    let new_selected = self.selected.wrapping_add(1) % MAX_SELECTED;
+                    View::Settings(SettingsMenu {
+                        selected: new_selected,
+                    })
+                }
+                ButtonAction::Ok => match self.selected {
+                    2 => View::FlashInfo(FlashInfoView {}),
+                    _ => View::Settings(self.clone()),
+                },
+                _ => View::Settings(self.clone()),
+            };
+
             NewState {
-                view: View::Settings(SettingsMenu { selected: 0 }),
+                replace_view: matches!(new_menu, View::Settings(_)),
-                replace_view: true,
+                view: new_menu,
-                redraw: !matches!(input, Action::Timer),
+                redraw: true,
             }
         }
     }

src/views/view.rs

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

wokwi.toml

@@ -3,3 +3,7 @@ version = 1
 gdbServerPort = 3333
 elf = "target/xtensa-esp32s3-none-elf/debug/creaturedex"
 firmware = "target/xtensa-esp32s3-none-elf/debug/creaturedex"
+
+[[chip]]
+name = 'ch1115' 
+binary = 'wokwi/ch1115.chip.wasm'

wokwi/Makefile

@@ -0,0 +1,36 @@
+.PHONY: all auto native docker clean
+
+# Configuration
+SRC = ch1115.chip.c
+OUT = ch1115.chip.wasm
+
+# Check if wokwi-cli exists in PATH
+WOKWI_CLI := $(shell command -v wokwi-cli 2> /dev/null)
+
+HOST_UID := $(shell id -u)
+HOST_GID := $(shell id -g)
+
+# Default target runs the auto-detection
+all: auto
+
+auto:
+ifeq ($(WOKWI_CLI),)
+	@echo "wokwi-cli not found in PATH. Falling back to Docker build..."
+	$(MAKE) docker
+else
+	@echo "Found wokwi-cli at $(WOKWI_CLI). Using native build..."
+	$(MAKE) native
+endif
+
+native:
+	wokwi-cli chip compile $(SRC) -o $(OUT)
+
+docker:
+	docker run --rm -v $(CURDIR):/workspace -w /workspace ubuntu:latest \
+		bash -c "apt-get update && apt-get install -y --no-install-recommends curl ca-certificates && \
+		curl -L https://wokwi.com/ci/install.sh | sh && \
+		~/.wokwi/bin/wokwi-cli chip compile $(SRC) -o $(OUT) && \
+		chown $(HOST_UID):$(HOST_GID) $(OUT)"
+
+clean:
+	rm -f $(OUT)

wokwi/ch1115.chip.c

@@ -0,0 +1,86 @@
+#include "wokwi-api.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+typedef struct {
+  pin_t cs, dc, res;
+  spi_dev_t spi;
+  buffer_t fb;
+  uint32_t width, height;
+  uint8_t spi_buffer[1];
+  uint8_t page;
+  uint8_t col;
+} chip_state_t;
+
+// Forward declarations
+static void on_cs_change(void *user_data, pin_t pin, uint32_t value);
+static void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count);
+
+void chip_init(void) {
+  printf("Initing CH1115 chip\n");
+  fflush(stdout);
+
+  chip_state_t *chip = malloc(sizeof(chip_state_t));
+  chip->fb = framebuffer_init(&chip->width, &chip->height);
+  
+  chip->cs = pin_init("CS", INPUT_PULLUP);
+  chip->dc = pin_init("DC", INPUT);
+  chip->res = pin_init("RES", INPUT_PULLUP);
+
+  const spi_config_t spi_cfg = {
+    .sck = pin_init("SCL", INPUT),
+    .mosi = pin_init("SDA", INPUT),
+    .miso = NO_PIN,
+    .mode = 0,
+    .done = chip_spi_done,
+    .user_data = chip,
+  };
+  chip->spi = spi_init(&spi_cfg);
+
+  const pin_watch_config_t cs_watch = {
+    .edge = BOTH,
+    .pin_change = on_cs_change,
+    .user_data = chip,
+  };
+  pin_watch(chip->cs, &cs_watch);
+}
+
+static void on_cs_change(void *user_data, pin_t pin, uint32_t value) {
+  chip_state_t *chip = (chip_state_t*)user_data;
+  if (value == LOW) {
+    // Start receiving 1 byte at a time
+    spi_start(chip->spi, chip->spi_buffer, 1);
+  } else {
+    spi_stop(chip->spi);
+  }
+}
+
+static void chip_spi_done(void *user_data, uint8_t *buffer, uint32_t count) {
+  chip_state_t *chip = (chip_state_t*)user_data;
+  if (!count) return;
+
+  uint8_t val = buffer[0];
+  bool is_data = pin_read(chip->dc) == HIGH;
+
+  if (is_data) {
+    // Write 8 vertical pixels to the Wokwi RGBA Framebuffer
+    for (int i = 0; i < 8; i++) {
+      // 0xFFFFFFFF = White, 0x000000FF = Black
+      uint32_t color = (val & (1 << i)) ? 0xFFFFFFFF : 0x000000FF; 
+      uint32_t y = (chip->page * 8) + i;
+      uint32_t offset = (y * chip->width + chip->col) * 4;
+      buffer_write(chip->fb, offset, &color, 4);
+    }
+    chip->col++; // Auto-increment column
+  } else {
+    // CH1115 Core Commands
+    if ((val & 0xB0) == 0xB0) chip->page = val & 0x0F; // Set Page Start
+    else if ((val & 0xF0) == 0x00) chip->col = (chip->col & 0xF0) | (val & 0x0F); // Lower Col
+    else if ((val & 0xF0) == 0x10) chip->col = (chip->col & 0x0F) | ((val & 0x0F) << 4); // Upper Col
+  }
+
+  // Continue receiving if CS is still active
+  if (pin_read(chip->cs) == LOW) {
+    spi_start(chip->spi, chip->spi_buffer, 1);
+  }
+}

wokwi/ch1115.chip.json

@@ -0,0 +1,9 @@
+{
+  "name": "CH1115 OLED",
+  "author": "ede1998",
+  "pins": ["VCC", "GND", "CS", "RES", "DC", "SCL", "SDA"],
+  "display": {
+    "width": 128,
+    "height": 64
+  }
+}