wifi: fix issue with initialization

tertiary display: implement feature flag to disable
common: remove debug from cargo config, use ESP_LOG="creaturedex:debug"

.cargo/config.toml

@@ -1,15 +1,14 @@
-[target.xtensa-esp32-none-elf]
+[target.xtensa-esp32s3-none-elf]
-runner = "espflash flash --monitor --chip esp32"
+runner = "espflash flash --monitor --chip esp32s3"
 
 [env]
 ESP_LOG = "info"
+WM_CONN = '{"ssid": "Wokwi-GUEST", "psk": "", "data": {}}'
 
 [build]
-rustflags = [
+rustflags = ["-C", "link-arg=-nostartfiles"]
-  "-C", "link-arg=-nostartfiles",
-]
 
-target = "xtensa-esp32-none-elf"
+target = "xtensa-esp32s3-none-elf"
 
 [unstable]
 build-std = ["alloc", "core"]

.envrc

@@ -1 +0,0 @@
-use nix;

.gitignore

@@ -24,3 +24,14 @@ target/
 
 # Ignore .DS_Store file in mac
 **/.DS_Store
+
+# Ignore checked out wiki
+creaturedex.wiki/
+
+# KiCad
+*.zip
+*.lck
+schematics/.history/
+
+wokwi/wokwi-api.h
+wokwi/ch1115.chip.wasm

Cargo.toml

@@ -9,60 +9,84 @@ name = "creaturedex"
 path = "./src/bin/main.rs"
 
 [dependencies]
-esp-hal = { version = "~1.1.0", features = ["esp32", "log-04", "unstable"] }
+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",
   "esp-alloc",
   "esp-radio",
-  "esp32",
+  "esp32s3",
   "log-04",
 ] }
 
-esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32", "log-04"] }
+esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32s3", "log-04"] }
 log = "0.4.27"
 
 critical-section = "1.2.0"
 embedded-io = "0.7.1"
+embassy-executor = { version = "0.10.0", features = ["trace", "metadata-name"] }
+embassy-time = { version = "0.5.1", default-features = false }
+embassy-futures = "0.1.2"
 esp-alloc = "0.10.0"
-esp-println = { version = "0.17.0", features = ["esp32", "log-04"] }
+esp-println = { version = "0.17.0", features = ["esp32s3", "log-04"] }
-esp-radio = { version = "0.18.0", features = [
-  "esp-alloc",
-  "esp32",
-  "log-04",
-  "unstable",
-  "wifi",
-] }
-smoltcp = { version = "0.13.0", default-features = false, features = [
-  "log",
-  "medium-ethernet",
-  "multicast",
-  "proto-dhcpv4",
-  "proto-dns",
-  "proto-ipv4",
-  "socket-dns",
-  "socket-icmp",
-  "socket-raw",
-  "socket-tcp",
-  "socket-udp",
-] }
 display-interface-spi = "0.5.0"
 ili9341 = "0.6.0"
 embedded-hal = "1.0.0"
 embedded-hal-bus = "0.3.0"
 embedded-graphics = "0.8.2"
 embedded-graphics-core = "0.4.1"
+base64 = { version = "0.23.1", default-features = false, features = ["alloc"] }
 pn532 = "0.5.0"
-ndef = { version = "0.5.0", path = "./ndef-rs" }
+num_enum = { version = "0.7.6", default-features = false }
+embassy-sync = "0.7.2"
+embedded-hal-async = "1.0.0"
+i2c-character-display = "0.5.1"
+ch1115 = { version = "0.1.2", features = ["graphics"] }
+esp-storage = "0.9.0"
+embedded-storage = "0.3.1"
+binary_serde = "1.0.25"
+static_assertions = { version = "1.1.0", default-features = false }
+embedded-text = "0.7.3"
+esp-nvs = { version = "0.5.0", features = ["esp32s3"] }
+esp-backtrace = { version = "0.19.0", features = [
+  "esp32s3",
+  "panic-handler",
+  "println",
+] }
+esp-radio = { version = "0.18.0", features = ["esp32s3", "wifi"] }
 
+[build-dependencies]
+log = "0.4.27"
+
+
+[patch.crates-io]
+ch1115 = { git = "https://github.com/ede1998/ch1115.git", rev = "2d3a3ba38050efe012e6a210afe3e125ec280c37" }
 
 # For fine tuning these settings, please refer to https://doc.rust-lang.org/cargo/reference/profiles.html
 [profile.dev]
 # The default debug profile is too slow and too big for resource-constrained devices.
 # Always build with some optimizations enabled.
-opt-level = "s"
+opt-level = 0
+debug = 2
+
+[profile.dev.package."*"]
+opt-level = 3
+debug = 0
 
 [profile.release]
 codegen-units = 1 # LLVM can perform better optimizations using a single thread
 debug = 2         # prefer slower builds but better debugging experience
 lto = 'fat'
 opt-level = 's'
+
+[features]
+default = []
+wokwi = []
+nop_tertiary = []
+
+[lints.clippy]
+manual_async_fn = "allow"

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

@@ -1,44 +1,121 @@
 {
   "version": 1,
+  "author": "CreatureDex",
   "editor": "wokwi",
   "parts": [
-    { "type": "board-esp32-s3-devkitc-1", "id": "esp1", "top": 67.2, "left": -263.96, "attrs": {} },
     {
-      "type": "board-ili9341-cap-touch",
+      "type": "board-esp32-s3-devkitc-1",
-      "id": "lcd1",
+      "id": "esp1",
-      "top": -191.24,
+      "top": 67.2,
-      "left": -0.38,
+      "left": -263.96,
       "attrs": {}
     },
+    { "type": "wokwi-ili9341", "id": "lcd1", "top": -200.8, "left": 354.9, "attrs": {} },
     {
-      "type": "wokwi-led",
+      "type": "wokwi-pushbutton",
-      "id": "led1",
+      "id": "btn-up",
-      "top": -82.89,
+      "top": -99.4,
-      "left": 196.26,
+      "left": -76.8,
-      "attrs": { "color": "red" }
+      "attrs": { "color": "RebeccaPurple", "xray": "1", "key": "1", "label": "Up" }
     },
     {
-      "type": "wokwi-resistor",
+      "type": "wokwi-pushbutton",
-      "id": "r1",
+      "id": "btn-down",
-      "top": 183.86,
+      "top": 25.4,
-      "left": 154.06,
+      "left": -76.8,
-      "attrs": { "value": "220" }
+      "attrs": { "color": "green", "xray": "1", "key": "1", "label": "Down" }
-    }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-left",
+      "top": -32.2,
+      "left": -163.2,
+      "attrs": { "color": "yellow", "xray": "1", "key": "1", "label": "Left" }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-right",
+      "top": -32.2,
+      "left": 19.2,
+      "attrs": { "color": "red", "xray": "1", "key": "1", "label": "Right" }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-back",
+      "top": -99.4,
+      "left": 115.2,
+      "attrs": { "color": "Magenta", "xray": "1", "key": "1", "label": "Back" }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-ok",
+      "top": 25.4,
+      "left": 115.2,
+      "attrs": { "color": "Lime", "xray": "1", "key": "1", "label": "Ok" }
+    },
+    {
+      "type": "wokwi-lcd1602",
+      "id": "lcd2",
+      "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" ] ],
-    [ "esp1:22", "lcd1:SCL", "yellow", [ "h48", "v163.2", "h192" ] ],
+    [ "btn-up:2.l", "esp1:38", "purple", [ "h-9.6", "v19.4" ] ],
-    [ "esp1:21", "lcd1:SDA", "cyan", [ "h38.4", "v144", "h211.2" ] ],
+    [ "btn-up:1.l", "esp1:GND.2", "black", [ "h0" ] ],
-    [ "r1:2", "led1:A", "green", [ "h8.4", "v-230.4" ] ],
+    [ "btn-down:1.l", "esp1:GND.2", "black", [ "h0" ] ],
-    [ "esp1:GND.2", "led1:C", "black", [ "v0", "h86.4", "v76.8", "h278.4" ] ],
+    [ "btn-down:2.l", "esp1:39", "green", [ "h-19.2", "v115.4" ] ],
-    [ "esp1:17", "r1:1", "green", [ "h0" ] ]
+    [ "btn-left:2.l", "esp1:40", "yellow", [ "h0", "v173" ] ],
+    [ "btn-left:1.l", "esp1:GND.2", "black", [ "h0" ] ],
+    [ "btn-right:2.l", "esp1:41", "red", [ "h-19.2", "v153.8" ] ],
+    [ "btn-right:1.l", "btn-left:1.r", "black", [ "h-96", "v28.8" ] ],
+    [ "btn-back:2.l", "esp1:42", "Magenta", [ "h-19.2", "v211.58" ] ],
+    [ "btn-back:1.l", "btn-up:1.r", "black", [ "h0" ] ],
+    [ "btn-ok:1.l", "btn-down:1.r", "black", [ "h0" ] ],
+    [ "btn-ok:2.l", "esp1:45", "Lime", [ "h-9.6", "v173" ] ],
+    [ "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" ] ],
+    [ "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": {}
 }

espflash.toml

@@ -0,0 +1,2 @@
+[idf_format_args]
+partition_table = "partitions.csv"

model/common.scad

@@ -1,9 +1,77 @@
+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 main_display(pin_header = false) {
+  // Outer dimensions
+  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 pad() {
@@ -11,35 +79,188 @@ module pad(){
   cube([20, 20, 10]);
 }
 
-module small_display_below_main()
+module secondary_display(pin_header = false) {
-{
   // https://de.aliexpress.com/item/1005003753680706.html
-    cube([45.8, 20, 11.3]);
+  length = 45.8;
-    // old i2c variant:
+  width = 20;
-    //cube([43.5, 19.44, 4.5]);
+  height = 3.7;
 
-    // initial dimension ideas
+  hole_diameter = 2;
-    // cube([38,16,4]);
+  hole_inset = 1.5;
-    // translate([150,0,0]) cube([22,5.5,4]);
+
+  difference() {
+    cuboid([length, width, height]) {
+      if (pin_header)
+        position(LEFT + TOP)
+          pin_header(7, spin=90, anchor=BACK + BOTTOM);
     }
 
-module tertiary_display()
+    right(length / 2 - hole_inset) {
-{
+      ycopies(width - (2 * hole_inset) - hole_diameter) {
-    // https://de.aliexpress.com/item/1005006034531826.html
+        zcyl(d=hole_diameter, h=height + EPS, anchor=RIGHT);
-    cube([80, 36, 10]);
+      }
+    }
+  }
 }
 
-module battery() {
+module battery(anchor = BOTTOM) {
   // 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
+  pcb_height_no_components = 1.1;
+  pcb_width = 28.8;
+
+  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;
-    delta = length - battery_length;
+  battery_protrusion = 4.5;
-    cube([length, 32, height]);
+
-    translate([delta / 2,16, 15]) battery();
+  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);
 }

model/right-half.scad

@@ -17,10 +17,10 @@ module right_half_door_only() {
 }
 // #right_half_door_only();
 
-module battery_spacer(cable_cube_additional_length=0) {
+module battery_spacer(cable_cube_additional_length=0, cable_cube = 8.25) {
     length = 106;
-    rotate([0, 90, 90]) cylinder(d=18.5, h=length);
+    battery_d = 18;
-    cable_cube = 8.25;
+    rotate([0, 90, 90]) cylinder(d=battery_d+1.9, h=length);
     translate([0, 0, -cable_cube]) cube([cable_cube, length+cable_cube_additional_length, cable_cube]);
 }
 // !battery_spacer();
@@ -28,13 +28,13 @@ module battery_spacer(cable_cube_additional_length=0) {
 module battery_contact()
 {
     base_height = 4;
-    silver_wire_d = 1.15;
+    silver_wire_d = 1.7;
 
     module base_body() {
         rotate([90, 0, 0])
             resize([0, base_height, 0], auto=[false, true, false])
-                scale(0.99)
+                scale(0.92)
-                    battery_spacer();
+                    battery_spacer(cable_cube=0);
     }
 
     module contact_spring()
@@ -42,24 +42,24 @@ module battery_contact()
         spring_width = 11;
         translate([-2, -spring_width/2, 0])
             difference() {
-                scale([1.75, 1, 1]) rotate([-90, 0, 0]) cylinder(d=10, h=spring_width);
+                scale([1.5, 1, 1]) rotate([-90, 0, 0]) cylinder(d=10, h=spring_width);
-                scale([1.75, 1, 1.5]) rotate([-90, 0, 0]) cylinder(d=6, h=spring_width);
+                scale([0.95, 1, 0.87]) rotate([-90, 0, 0]) cylinder(d=10, h=spring_width);
-                translate([-100, 0, -50]) cube(100);
+                translate([-101, 0, -50]) cube(100);
                 translate([-50, 0, -100]) cube(100);
-                translate([0, spring_width/3-silver_wire_d, 0]) cube([silver_wire_d, silver_wire_d, 50]);
+                translate([-1, spring_width/3-silver_wire_d, 0]) cube([silver_wire_d, silver_wire_d, 50]);
-                translate([0, spring_width*2/3, 0]) cube([silver_wire_d, silver_wire_d, 50]);
+                translate([-1, spring_width*2/3, 0]) cube([silver_wire_d, silver_wire_d, 50]);
             }
     }
+
     module silver_wire_channels()
     {
-        translate([7.3, 0, -6])
+        translate([6.5, -2.5, -7])
-            rotate([-15, 0, 0])
+                #cylinder(d=silver_wire_d, h=15);
-                cylinder(d=silver_wire_d, h=15);
 
-        translate([7.3, 0, -6])
+        translate([6.5, 2.5, -7])
-            rotate([15, 0, 0])
+                #cylinder(d=silver_wire_d, h=15);
-                cylinder(d=silver_wire_d, h=15);
     }
+    // silver_wire_channels();
 
     translate([0, 0, base_height])
         rotate([0, 0, 45])
@@ -74,7 +74,7 @@ module battery_contact()
                 silver_wire_channels();
     }
 }
-// !battery_contact();
+battery_contact();
 
 module right_half_hinge_only() {
     module original() {
@@ -104,12 +104,12 @@ module right_half_hinge_only() {
     base_model();
     // translate([0, -40, 11]) rotate([0, 0, 90]) battery();
 }
-// right_half_hinge_only();
+// !right_half_hinge_only();
 
 module right_half() {
     right_half_door_only();
     right_half_hinge_only();
 }
 
-right_half();
+// right_half();
 // #right_half_components();

partitions.csv

@@ -0,0 +1,4 @@
+# ESP-IDF Partition Table
+# Name,Type,SubType,Offset,Size,Flags
+nvs,data,nvs,0x9000,0xa00000,
+factory,app,factory,0xa10000,0x200000,

schematics/creaturedex.kicad_pcb

@@ -0,0 +1,2 @@
+(kicad_pcb (version 20241229) (generator "pcbnew") (generator_version "9.0")
+)

schematics/creaturedex.kicad_prl

@@ -0,0 +1,103 @@
+{
+  "board": {
+    "active_layer": 0,
+    "active_layer_preset": "",
+    "auto_track_width": true,
+    "hidden_netclasses": [],
+    "hidden_nets": [],
+    "high_contrast_mode": 0,
+    "net_color_mode": 1,
+    "opacity": {
+      "images": 0.6,
+      "pads": 1.0,
+      "shapes": 1.0,
+      "tracks": 1.0,
+      "vias": 1.0,
+      "zones": 0.6
+    },
+    "prototype_zone_fills": false,
+    "selection_filter": {
+      "dimensions": true,
+      "footprints": true,
+      "graphics": true,
+      "keepouts": true,
+      "lockedItems": false,
+      "otherItems": true,
+      "pads": true,
+      "text": true,
+      "tracks": true,
+      "vias": true,
+      "zones": true
+    },
+    "visible_items": [
+      "vias",
+      "footprint_text",
+      "footprint_anchors",
+      "ratsnest",
+      "grid",
+      "footprints_front",
+      "footprints_back",
+      "footprint_values",
+      "footprint_references",
+      "tracks",
+      "drc_errors",
+      "drawing_sheet",
+      "bitmaps",
+      "pads",
+      "zones",
+      "drc_warnings",
+      "drc_exclusions",
+      "locked_item_shadows",
+      "conflict_shadows",
+      "shapes"
+    ],
+    "visible_layers": "ffffffff_ffffffff_ffffffff_ffffffff",
+    "zone_display_mode": 0
+  },
+  "git": {
+    "integration_disabled": false,
+    "repo_type": "",
+    "repo_username": "",
+    "ssh_key": ""
+  },
+  "meta": {
+    "filename": "creaturedex.kicad_prl",
+    "version": 5
+  },
+  "net_inspector_panel": {
+    "col_hidden": [],
+    "col_order": [],
+    "col_widths": [],
+    "custom_group_rules": [],
+    "expanded_rows": [],
+    "filter_by_net_name": true,
+    "filter_by_netclass": true,
+    "filter_text": "",
+    "group_by_constraint": false,
+    "group_by_netclass": false,
+    "show_time_domain_details": false,
+    "show_unconnected_nets": false,
+    "show_zero_pad_nets": false,
+    "sort_ascending": true,
+    "sorting_column": -1
+  },
+  "open_jobsets": [],
+  "project": {
+    "files": []
+  },
+  "schematic": {
+    "hierarchy_collapsed": [],
+    "selection_filter": {
+      "graphics": true,
+      "images": true,
+      "labels": true,
+      "lockedItems": false,
+      "otherItems": true,
+      "pins": true,
+      "ruleAreas": true,
+      "symbols": true,
+      "text": true,
+      "wires": true
+    }
+  }
+}

schematics/creaturedex.kicad_pro

@@ -0,0 +1,456 @@
+{
+  "board": {
+    "3dviewports": [],
+    "design_settings": {
+      "defaults": {},
+      "diff_pair_dimensions": [],
+      "drc_exclusions": [],
+      "rules": {},
+      "track_widths": [],
+      "via_dimensions": []
+    },
+    "ipc2581": {
+      "bom_rev": "",
+      "dist": "",
+      "distpn": "",
+      "internal_id": "",
+      "mfg": "",
+      "mpn": "",
+      "sch_revision": ""
+    },
+    "layer_pairs": [],
+    "layer_presets": [],
+    "viewports": []
+  },
+  "boards": [],
+  "component_class_settings": {
+    "assignments": [],
+    "meta": {
+      "version": 0
+    },
+    "sheet_component_classes": {
+      "enabled": false
+    }
+  },
+  "cvpcb": {
+    "equivalence_files": []
+  },
+  "erc": {
+    "erc_exclusions": [],
+    "meta": {
+      "version": 0
+    },
+    "pin_map": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        2,
+        2,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        1,
+        0,
+        1,
+        2
+      ],
+      [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        1,
+        2,
+        1,
+        1,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1,
+        1,
+        1,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        1,
+        2,
+        0,
+        0,
+        1,
+        0,
+        2,
+        2,
+        2,
+        2
+      ],
+      [
+        0,
+        2,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        1,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        0,
+        0,
+        2
+      ],
+      [
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2
+      ]
+    ],
+    "rule_severities": {
+      "bus_definition_conflict": "error",
+      "bus_entry_needed": "error",
+      "bus_to_bus_conflict": "error",
+      "bus_to_net_conflict": "error",
+      "different_unit_footprint": "error",
+      "different_unit_net": "error",
+      "duplicate_reference": "error",
+      "duplicate_sheet_names": "error",
+      "endpoint_off_grid": "warning",
+      "extra_units": "error",
+      "field_name_whitespace": "warning",
+      "footprint_filter": "ignore",
+      "footprint_link_issues": "warning",
+      "four_way_junction": "ignore",
+      "global_label_dangling": "warning",
+      "ground_pin_not_ground": "warning",
+      "hier_label_mismatch": "error",
+      "isolated_pin_label": "warning",
+      "label_dangling": "error",
+      "label_multiple_wires": "warning",
+      "lib_symbol_issues": "warning",
+      "lib_symbol_mismatch": "warning",
+      "missing_bidi_pin": "warning",
+      "missing_input_pin": "warning",
+      "missing_power_pin": "error",
+      "missing_unit": "warning",
+      "multiple_net_names": "warning",
+      "net_not_bus_member": "warning",
+      "no_connect_connected": "warning",
+      "no_connect_dangling": "warning",
+      "pin_not_connected": "error",
+      "pin_not_driven": "error",
+      "pin_to_pin": "warning",
+      "power_pin_not_driven": "error",
+      "same_local_global_label": "warning",
+      "similar_label_and_power": "warning",
+      "similar_labels": "warning",
+      "similar_power": "warning",
+      "simulation_model_issue": "ignore",
+      "single_global_label": "ignore",
+      "stacked_pin_name": "warning",
+      "unannotated": "error",
+      "unconnected_wire_endpoint": "warning",
+      "undefined_netclass": "error",
+      "unit_value_mismatch": "error",
+      "unresolved_variable": "error",
+      "wire_dangling": "error"
+    }
+  },
+  "libraries": {
+    "pinned_footprint_libs": [],
+    "pinned_symbol_libs": []
+  },
+  "meta": {
+    "filename": "creaturedex.kicad_pro",
+    "version": 3
+  },
+  "net_settings": {
+    "classes": [
+      {
+        "bus_width": 12,
+        "clearance": 0.2,
+        "diff_pair_gap": 0.25,
+        "diff_pair_via_gap": 0.25,
+        "diff_pair_width": 0.2,
+        "line_style": 0,
+        "microvia_diameter": 0.3,
+        "microvia_drill": 0.1,
+        "name": "Default",
+        "pcb_color": "rgba(0, 0, 0, 0.000)",
+        "priority": 2147483647,
+        "schematic_color": "rgba(0, 0, 0, 0.000)",
+        "track_width": 0.2,
+        "tuning_profile": "",
+        "via_diameter": 0.6,
+        "via_drill": 0.3,
+        "wire_width": 6
+      }
+    ],
+    "meta": {
+      "version": 5
+    },
+    "net_colors": null,
+    "netclass_assignments": null,
+    "netclass_patterns": []
+  },
+  "pcbnew": {
+    "last_paths": {
+      "gencad": "",
+      "idf": "",
+      "netlist": "",
+      "plot": "",
+      "pos_files": "",
+      "specctra_dsn": "",
+      "step": "",
+      "svg": "",
+      "vrml": ""
+    },
+    "page_layout_descr_file": ""
+  },
+  "schematic": {
+    "annotate_start_num": 0,
+    "annotation": {
+      "method": 0,
+      "sort_order": 0
+    },
+    "bom_export_filename": "${PROJECTNAME}.csv",
+    "bom_fmt_presets": [],
+    "bom_fmt_settings": {
+      "field_delimiter": ",",
+      "keep_line_breaks": false,
+      "keep_tabs": false,
+      "name": "CSV",
+      "ref_delimiter": ",",
+      "ref_range_delimiter": "",
+      "string_delimiter": "\""
+    },
+    "bom_presets": [],
+    "bom_settings": {
+      "exclude_dnp": false,
+      "fields_ordered": [
+        {
+          "group_by": false,
+          "label": "Reference",
+          "name": "Reference",
+          "show": true
+        },
+        {
+          "group_by": false,
+          "label": "Qty",
+          "name": "${QUANTITY}",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "Value",
+          "name": "Value",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "DNP",
+          "name": "${DNP}",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "Exclude from BOM",
+          "name": "${EXCLUDE_FROM_BOM}",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "Exclude from Board",
+          "name": "${EXCLUDE_FROM_BOARD}",
+          "show": true
+        },
+        {
+          "group_by": true,
+          "label": "Footprint",
+          "name": "Footprint",
+          "show": true
+        },
+        {
+          "group_by": false,
+          "label": "Datasheet",
+          "name": "Datasheet",
+          "show": true
+        }
+      ],
+      "filter_string": "",
+      "group_symbols": true,
+      "include_excluded_from_bom": true,
+      "name": "Default Editing",
+      "sort_asc": true,
+      "sort_field": "Reference"
+    },
+    "bus_aliases": {},
+    "connection_grid_size": 50.0,
+    "drawing": {
+      "dashed_lines_dash_length_ratio": 12.0,
+      "dashed_lines_gap_length_ratio": 3.0,
+      "default_line_thickness": 6.0,
+      "default_text_size": 50.0,
+      "field_names": [],
+      "hop_over_size_choice": 0,
+      "intersheets_ref_own_page": false,
+      "intersheets_ref_prefix": "",
+      "intersheets_ref_short": false,
+      "intersheets_ref_show": false,
+      "intersheets_ref_suffix": "",
+      "junction_size_choice": 3,
+      "label_size_ratio": 0.375,
+      "operating_point_overlay_i_precision": 3,
+      "operating_point_overlay_i_range": "~A",
+      "operating_point_overlay_v_precision": 3,
+      "operating_point_overlay_v_range": "~V",
+      "overbar_offset_ratio": 1.23,
+      "pin_symbol_size": 25.0,
+      "text_offset_ratio": 0.15
+    },
+    "legacy_lib_dir": "",
+    "legacy_lib_list": [],
+    "meta": {
+      "version": 1
+    },
+    "net_format_name": "",
+    "page_layout_descr_file": "",
+    "plot_directory": "",
+    "reuse_designators": true,
+    "space_save_all_events": true,
+    "spice_current_sheet_as_root": false,
+    "spice_external_command": "spice \"%I\"",
+    "spice_model_current_sheet_as_root": true,
+    "spice_save_all_currents": false,
+    "spice_save_all_dissipations": false,
+    "spice_save_all_voltages": false,
+    "subpart_first_id": 65,
+    "subpart_id_separator": 0,
+    "top_level_sheets": [
+      {
+        "filename": "creaturedex.kicad_sch",
+        "name": "creaturedex",
+        "uuid": "f0cf9cac-01dc-4071-b72f-ebf42dbd12d6"
+      }
+    ],
+    "used_designators": "",
+    "variants": []
+  },
+  "sheets": [
+    [
+      "f0cf9cac-01dc-4071-b72f-ebf42dbd12d6",
+      "creaturedex"
+    ]
+  ],
+  "text_variables": {},
+  "tuning_profiles": {
+    "meta": {
+      "version": 0
+    },
+    "tuning_profiles_impedance_geometric": []
+  }
+}

schematics/sym-lib-table

@@ -0,0 +1,8 @@
+(sym_lib_table
+  (version 7)
+  (lib (name "t-energy-s3")(type "KiCad")(uri "${KIPRJMOD}/symbols/t-energy-s3.kicad_sym")(options "")(descr ""))
+  (lib (name "oled-main-display")(type "KiCad")(uri "${KIPRJMOD}/symbols/oled-main-display.kicad_sym")(options "")(descr ""))
+  (lib (name "elechouse_nfc_module_v3")(type "KiCad")(uri "${KIPRJMOD}/symbols/elechouse_nfc_module_v3.kicad_sym")(options "")(descr ""))
+  (lib (name "dot-secondary-display")(type "KiCad")(uri "${KIPRJMOD}/symbols/dot-secondary-display.kicad_sym")(options "")(descr ""))
+  (lib (name "lcd-tertiary-display")(type "KiCad")(uri "${KIPRJMOD}/symbols/lcd-tertiary-display.kicad_sym")(options "")(descr ""))
+)

schematics/symbols/dot-secondary-display.kicad_sym

@@ -0,0 +1,52 @@
+(kicad_symbol_lib (version 20211014) (generator kicad_symbol_editor)
+  (symbol "CH1115_OLED_7Pin" (in_bom yes) (on_board yes)
+    (property "Reference" "U" (id 0) (at -7.62 11.43 0)
+      (effects (font (size 1.27 1.27)) (justify left))
+    )
+    (property "Value" "CH1115_OLED_7Pin" (id 1) (at 7.62 11.43 0)
+      (effects (font (size 1.27 1.27)) (justify right))
+    )
+    (property "Footprint" "" (id 2) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (property "Datasheet" "" (id 3) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (symbol "CH1115_OLED_7Pin_0_1"
+      (rectangle (start -10.16 10.16) (end 10.16 -10.16)
+        (stroke (width 0.254) (type default) (color 0 0 0 0))
+        (fill (type background))
+      )
+    )
+    (symbol "CH1115_OLED_7Pin_1_1"
+      (pin power_in line (at -12.7 7.62 0) (length 2.54)
+        (name "GND" (effects (font (size 1.27 1.27))))
+        (number "1" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at -12.7 5.08 0) (length 2.54)
+        (name "VCC" (effects (font (size 1.27 1.27))))
+        (number "2" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -12.7 2.54 0) (length 2.54)
+        (name "SCL" (effects (font (size 1.27 1.27))))
+        (number "3" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -12.7 0 0) (length 2.54)
+        (name "SDA" (effects (font (size 1.27 1.27))))
+        (number "4" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -12.7 -2.54 0) (length 2.54)
+        (name "RES" (effects (font (size 1.27 1.27))))
+        (number "5" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -12.7 -5.08 0) (length 2.54)
+        (name "DC" (effects (font (size 1.27 1.27))))
+        (number "6" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -12.7 -7.62 0) (length 2.54)
+        (name "CS" (effects (font (size 1.27 1.27))))
+        (number "7" (effects (font (size 1.27 1.27))))
+      )
+    )
+  )
+)

schematics/symbols/elechouse_nfc_module_v3.kicad_sym

@@ -0,0 +1,72 @@
+(kicad_symbol_lib (version 20211014) (generator kicad_symbol_editor)
+  (symbol "NFC_MODULE_V3" (in_bom yes) (on_board yes)
+    (property "Reference" "U" (id 0) (at -10.16 12.7 0)
+      (effects (font (size 1.27 1.27)) (justify left))
+    )
+    (property "Value" "NFC_MODULE_V3" (id 1) (at 10.16 12.7 0)
+      (effects (font (size 1.27 1.27)) (justify right))
+    )
+    (property "Footprint" "" (id 2) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (property "Datasheet" "" (id 3) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (symbol "NFC_MODULE_V3_0_1"
+      (rectangle (start -12.7 11.43) (end 12.7 -11.43)
+        (stroke (width 0.254) (type default) (color 0 0 0 0))
+        (fill (type background))
+      )
+    )
+    (symbol "NFC_MODULE_V3_1_1"
+      (pin input line (at -15.24 8.89 0) (length 2.54)
+        (name "SCK" (effects (font (size 1.27 1.27))))
+        (number "1" (effects (font (size 1.27 1.27))))
+      )
+      (pin output line (at -15.24 6.35 0) (length 2.54)
+        (name "MISO" (effects (font (size 1.27 1.27))))
+        (number "2" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 3.81 0) (length 2.54)
+        (name "MOSI" (effects (font (size 1.27 1.27))))
+        (number "3" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 1.27 0) (length 2.54)
+        (name "SS" (effects (font (size 1.27 1.27))))
+        (number "4" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at -15.24 -1.27 0) (length 2.54)
+        (name "VCC" (effects (font (size 1.27 1.27))))
+        (number "5" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at -15.24 -3.81 0) (length 2.54)
+        (name "GND" (effects (font (size 1.27 1.27))))
+        (number "6" (effects (font (size 1.27 1.27))))
+      )
+      (pin output line (at -15.24 -6.35 0) (length 2.54)
+        (name "IRQ" (effects (font (size 1.27 1.27))))
+        (number "7" (effects (font (size 1.27 1.27))))
+      )
+      (pin output line (at -15.24 -8.89 0) (length 2.54)
+        (name "RSTO" (effects (font (size 1.27 1.27))))
+        (number "8" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at 15.24 3.81 180) (length 2.54)
+        (name "GND" (effects (font (size 1.27 1.27))))
+        (number "9" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at 15.24 1.27 180) (length 2.54)
+        (name "VCC" (effects (font (size 1.27 1.27))))
+        (number "10" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 15.24 -1.27 180) (length 2.54)
+        (name "SDA/TXD" (effects (font (size 1.27 1.27))))
+        (number "11" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 15.24 -3.81 180) (length 2.54)
+        (name "SCL/RXD" (effects (font (size 1.27 1.27))))
+        (number "12" (effects (font (size 1.27 1.27))))
+      )
+    )
+  )
+)

schematics/symbols/lcd-tertiary-display.kicad_sym

@@ -0,0 +1,52 @@
+(kicad_symbol_lib (version 20211014) (generator kicad_symbol_editor)
+  (symbol "lcd_tertiary_display" (in_bom yes) (on_board yes)
+    (property "Reference" "U" (id 0) (at -7.62 11.43 0)
+      (effects (font (size 1.27 1.27)) (justify left))
+    )
+    (property "Value" "lcd_tertiary_display" (id 1) (at 7.62 11.43 0)
+      (effects (font (size 1.27 1.27)) (justify right))
+    )
+    (property "Footprint" "" (id 2) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (property "Datasheet" "" (id 3) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (symbol "lcd_tertiary_display_0_1"
+      (rectangle (start -10.16 10.16) (end 10.16 -5.08)
+        (stroke (width 0.254) (type default) (color 0 0 0 0))
+        (fill (type background))
+      )
+    )
+    (symbol "lcd_tertiary_display_1_1"
+      (pin power_in line (at -12.7 7.62 0) (length 2.54)
+        (name "GND" (effects (font (size 1.27 1.27))))
+        (number "1" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at -12.7 5.08 0) (length 2.54)
+        (name "VCC" (effects (font (size 1.27 1.27))))
+        (number "2" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -12.7 2.54 0) (length 2.54)
+        (name "SDA" (effects (font (size 1.27 1.27))))
+        (number "3" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -12.7 0 0) (length 2.54)
+        (name "SCL" (effects (font (size 1.27 1.27))))
+        (number "4" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at 12.7 7.62 180) (length 2.54)
+        (name "A0" (effects (font (size 1.27 1.27))))
+        (number "5" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at 12.7 5.08 180) (length 2.54)
+        (name "A1" (effects (font (size 1.27 1.27))))
+        (number "6" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at 12.7 2.54 180) (length 2.54)
+        (name "A2" (effects (font (size 1.27 1.27))))
+        (number "7" (effects (font (size 1.27 1.27))))
+      )
+    )
+  )
+)

schematics/symbols/oled-main-display.kicad_sym

@@ -0,0 +1,96 @@
+(kicad_symbol_lib (version 20211014) (generator kicad_symbol_editor)
+  (symbol "3.2_TFT_SPI_Touch_SD" (in_bom yes) (on_board yes)
+    (property "Reference" "U" (id 0) (at -10.16 21.59 0)
+      (effects (font (size 1.27 1.27)) (justify left))
+    )
+    (property "Value" "3.2_TFT_SPI_Touch_SD" (id 1) (at 10.16 21.59 0)
+      (effects (font (size 1.27 1.27)) (justify right))
+    )
+    (property "Footprint" "" (id 2) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (property "Datasheet" "" (id 3) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (symbol "3.2_TFT_SPI_Touch_SD_0_1"
+      (rectangle (start -12.7 20.32) (end 12.7 -17.78)
+        (stroke (width 0.254) (type default) (color 0 0 0 0))
+        (fill (type background))
+      )
+    )
+    (symbol "3.2_TFT_SPI_Touch_SD_1_1"
+      (pin power_in line (at -15.24 17.78 0) (length 2.54)
+        (name "VCC" (effects (font (size 1.27 1.27))))
+        (number "1" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at -15.24 15.24 0) (length 2.54)
+        (name "GND" (effects (font (size 1.27 1.27))))
+        (number "2" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 12.7 0) (length 2.54)
+        (name "CS" (effects (font (size 1.27 1.27))))
+        (number "3" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 10.16 0) (length 2.54)
+        (name "RESET" (effects (font (size 1.27 1.27))))
+        (number "4" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 7.62 0) (length 2.54)
+        (name "DC/RS" (effects (font (size 1.27 1.27))))
+        (number "5" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 5.08 0) (length 2.54)
+        (name "SDI(MOSI)" (effects (font (size 1.27 1.27))))
+        (number "6" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 2.54 0) (length 2.54)
+        (name "SCK" (effects (font (size 1.27 1.27))))
+        (number "7" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 0 0) (length 2.54)
+        (name "LED" (effects (font (size 1.27 1.27))))
+        (number "8" (effects (font (size 1.27 1.27))))
+      )
+      (pin output line (at -15.24 -2.54 0) (length 2.54)
+        (name "SDO(MISO)" (effects (font (size 1.27 1.27))))
+        (number "9" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 -5.08 0) (length 2.54)
+        (name "T_CLK" (effects (font (size 1.27 1.27))))
+        (number "10" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 -7.62 0) (length 2.54)
+        (name "T_CS" (effects (font (size 1.27 1.27))))
+        (number "11" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -15.24 -10.16 0) (length 2.54)
+        (name "T_DIN" (effects (font (size 1.27 1.27))))
+        (number "12" (effects (font (size 1.27 1.27))))
+      )
+      (pin output line (at -15.24 -12.7 0) (length 2.54)
+        (name "T_DO" (effects (font (size 1.27 1.27))))
+        (number "13" (effects (font (size 1.27 1.27))))
+      )
+      (pin output line (at -15.24 -15.24 0) (length 2.54)
+        (name "T_IRQ" (effects (font (size 1.27 1.27))))
+        (number "14" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at 15.24 5.08 180) (length 2.54)
+        (name "SD_CS" (effects (font (size 1.27 1.27))))
+        (number "15" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at 15.24 2.54 180) (length 2.54)
+        (name "SD_MOSI" (effects (font (size 1.27 1.27))))
+        (number "16" (effects (font (size 1.27 1.27))))
+      )
+      (pin output line (at 15.24 0 180) (length 2.54)
+        (name "SD_MISO" (effects (font (size 1.27 1.27))))
+        (number "17" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at 15.24 -2.54 180) (length 2.54)
+        (name "SD_SCK" (effects (font (size 1.27 1.27))))
+        (number "18" (effects (font (size 1.27 1.27))))
+      )
+    )
+  )
+)

schematics/symbols/t-energy-s3.kicad_sym

@@ -0,0 +1,184 @@
+(kicad_symbol_lib (version 20211014) (generator kicad_symbol_editor)
+  (symbol "LILYGO_T-Energy-S3" (in_bom yes) (on_board yes)
+    (property "Reference" "U" (id 0) (at -12.7 26.67 0)
+      (effects (font (size 1.27 1.27)) (justify left))
+    )
+    (property "Value" "LILYGO_T-Energy-S3" (id 1) (at 12.7 26.67 0)
+      (effects (font (size 1.27 1.27)) (justify right))
+    )
+    (property "Footprint" "" (id 2) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (property "Datasheet" "" (id 3) (at 0 0 0)
+      (effects (font (size 1.27 1.27)) hide)
+    )
+    (symbol "LILYGO_T-Energy-S3_0_1"
+      (rectangle (start -15.24 25.4) (end 15.24 -27.94)
+        (stroke (width 0.254) (type default) (color 0 0 0 0))
+        (fill (type background))
+      )
+    )
+    (symbol "LILYGO_T-Energy-S3_1_1"
+      (pin power_in line (at -17.78 22.86 0) (length 2.54)
+        (name "3V" (effects (font (size 1.27 1.27))))
+        (number "1" (effects (font (size 1.27 1.27))))
+      )
+      (pin input line (at -17.78 20.32 0) (length 2.54)
+        (name "RST" (effects (font (size 1.27 1.27))))
+        (number "2" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 17.78 0) (length 2.54)
+        (name "IO37" (effects (font (size 1.27 1.27))))
+        (number "3" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 15.24 0) (length 2.54)
+        (name "IO35" (effects (font (size 1.27 1.27))))
+        (number "4" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 12.7 0) (length 2.54)
+        (name "IO36" (effects (font (size 1.27 1.27))))
+        (number "5" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 10.16 0) (length 2.54)
+        (name "IO45" (effects (font (size 1.27 1.27))))
+        (number "6" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 7.62 0) (length 2.54)
+        (name "IO48" (effects (font (size 1.27 1.27))))
+        (number "7" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 5.08 0) (length 2.54)
+        (name "IO47" (effects (font (size 1.27 1.27))))
+        (number "8" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 2.54 0) (length 2.54)
+        (name "IO21" (effects (font (size 1.27 1.27))))
+        (number "9" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 0 0) (length 2.54)
+        (name "IO14" (effects (font (size 1.27 1.27))))
+        (number "10" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 -2.54 0) (length 2.54)
+        (name "IO13" (effects (font (size 1.27 1.27))))
+        (number "11" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 -5.08 0) (length 2.54)
+        (name "IO12" (effects (font (size 1.27 1.27))))
+        (number "12" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 -7.62 0) (length 2.54)
+        (name "IO11" (effects (font (size 1.27 1.27))))
+        (number "13" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at -17.78 -10.16 0) (length 2.54)
+        (name "GND" (effects (font (size 1.27 1.27))))
+        (number "14" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 -12.7 0) (length 2.54)
+        (name "IO10" (effects (font (size 1.27 1.27))))
+        (number "15" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 -15.24 0) (length 2.54)
+        (name "IO9" (effects (font (size 1.27 1.27))))
+        (number "16" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at -17.78 -17.78 0) (length 2.54)
+        (name "IO46" (effects (font (size 1.27 1.27))))
+        (number "17" (effects (font (size 1.27 1.27))))
+      )
+      (pin no_connect line (at -17.78 -20.32 0) (length 2.54)
+        (name "NC" (effects (font (size 1.27 1.27))))
+        (number "18" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at -17.78 -22.86 0) (length 2.54)
+        (name "5V" (effects (font (size 1.27 1.27))))
+        (number "19" (effects (font (size 1.27 1.27))))
+      )
+      (pin no_connect line (at -17.78 -25.4 0) (length 2.54)
+        (name "NC" (effects (font (size 1.27 1.27))))
+        (number "20" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at 17.78 22.86 180) (length 2.54)
+        (name "GND" (effects (font (size 1.27 1.27))))
+        (number "21" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 20.32 180) (length 2.54)
+        (name "IO1" (effects (font (size 1.27 1.27))))
+        (number "22" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 17.78 180) (length 2.54)
+        (name "IO2" (effects (font (size 1.27 1.27))))
+        (number "23" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 15.24 180) (length 2.54)
+        (name "TXD" (effects (font (size 1.27 1.27))))
+        (number "24" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 12.7 180) (length 2.54)
+        (name "RXD" (effects (font (size 1.27 1.27))))
+        (number "25" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 10.16 180) (length 2.54)
+        (name "IO42" (effects (font (size 1.27 1.27))))
+        (number "26" (effects (font (size 1.27 1.27))))
+      )
+      (pin power_in line (at 17.78 7.62 180) (length 2.54)
+        (name "GND" (effects (font (size 1.27 1.27))))
+        (number "27" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 5.08 180) (length 2.54)
+        (name "IO4" (effects (font (size 1.27 1.27))))
+        (number "28" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 2.54 180) (length 2.54)
+        (name "IO5" (effects (font (size 1.27 1.27))))
+        (number "29" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 0 180) (length 2.54)
+        (name "IO6" (effects (font (size 1.27 1.27))))
+        (number "30" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -2.54 180) (length 2.54)
+        (name "IO7" (effects (font (size 1.27 1.27))))
+        (number "31" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -5.08 180) (length 2.54)
+        (name "IO17" (effects (font (size 1.27 1.27))))
+        (number "32" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -7.62 180) (length 2.54)
+        (name "IO18" (effects (font (size 1.27 1.27))))
+        (number "33" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -10.16 180) (length 2.54)
+        (name "IO0" (effects (font (size 1.27 1.27))))
+        (number "34" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -12.7 180) (length 2.54)
+        (name "IO8" (effects (font (size 1.27 1.27))))
+        (number "35" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -15.24 180) (length 2.54)
+        (name "IO41" (effects (font (size 1.27 1.27))))
+        (number "36" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -17.78 180) (length 2.54)
+        (name "IO40" (effects (font (size 1.27 1.27))))
+        (number "37" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -20.32 180) (length 2.54)
+        (name "IO39" (effects (font (size 1.27 1.27))))
+        (number "38" (effects (font (size 1.27 1.27))))
+      )
+      (pin bidirectional line (at 17.78 -22.86 180) (length 2.54)
+        (name "IO38" (effects (font (size 1.27 1.27))))
+        (number "39" (effects (font (size 1.27 1.27))))
+      )
+      (pin no_connect line (at 17.78 -25.4 180) (length 2.54)
+        (name "NC" (effects (font (size 1.27 1.27))))
+        (number "40" (effects (font (size 1.27 1.27))))
+      )
+    )
+  )
+)

src/background_tasks.rs

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

src/background_tasks/nfc.rs

@@ -0,0 +1,82 @@
+use crate::navigation::navigation::display_error;
+use crate::{
+    Mutex,
+    navigation::{outputs::Outputs, state::NavigationState},
+    peripherals::Peripherals,
+};
+use alloc::string::ToString;
+use embedded_hal_bus::i2c::AtomicDevice;
+use esp_hal::{Blocking, i2c::master::I2c, time::Instant};
+
+use crate::{
+    card::{decoder::split_nfc_hex, model::Card},
+    drivers::nfc_pn532::NfcPn532Driver,
+    navigation::navigation::CARD_DATA,
+};
+
+#[embassy_executor::task]
+#[allow(
+    clippy::large_stack_frames,
+    reason = "ignoring this for now because it still works"
+)]
+pub async fn nfc_scanner(
+    mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>,
+    outputs: &'static Mutex<Outputs>,
+    peripherals: &'static Peripherals,
+    navigation_state: &'static Mutex<NavigationState>,
+) {
+    loop {
+        while CARD_DATA.lock().await.is_none() {
+            let start = Instant::now();
+            match nfc_driver.read_card_data().await {
+                Ok(card_data) => {
+                    let Some(split_data) = split_nfc_hex(&card_data) else {
+                        log::error!("Failed to split NFC card data");
+                        continue;
+                    };
+                    let card = match Card::try_from(split_data) {
+                        Ok(card) => card,
+                        Err(err) => {
+                            log::error!("Invalid card data: {err}");
+                            continue;
+                        }
+                    };
+                    CARD_DATA.lock().await.replace(card);
+
+                    log::debug!("saving card to flash");
+                    match peripherals
+                        .store
+                        .lock()
+                        .await
+                        .card_store
+                        .save_raw_card(&split_data, peripherals.rtc.current_time_us())
+                        .await
+                    {
+                        Ok(()) => {}
+                        Err(error) => {
+                            log::error!("Error storing card in flash: {:?}", error);
+                            display_error(
+                                error.to_string(),
+                                navigation_state,
+                                outputs,
+                                peripherals,
+                            )
+                            .await;
+                        }
+                    }
+
+                    let elapsed_ms = start.elapsed().as_millis();
+                    log::info!(
+                        "NFC read duration: {} ms, card data length: {}",
+                        elapsed_ms,
+                        card_data.len()
+                    );
+                }
+                Err(_) => {
+                    log::info!("No NFC card found");
+                }
+            }
+        }
+        embassy_time::Timer::after(embassy_time::Duration::from_millis(10)).await;
+    }
+}

src/bin/main.rs

@@ -7,46 +7,50 @@
 )]
 #![deny(clippy::large_stack_frames)]
 
-use core::convert::Infallible;
+use alloc::boxed::Box;
-
+use alloc::sync::Arc;
-use alloc::vec::Vec;
+use creaturedex::Mutex;
-use display_interface_spi::SPIInterface;
+use creaturedex::background_tasks;
-use embedded_graphics::Drawable;
+use creaturedex::drivers::i2c_bus::I2cBusPinConfiguration;
-use embedded_graphics::mono_font::MonoTextStyle;
+use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
-use embedded_graphics::mono_font::ascii::FONT_6X10;
+use creaturedex::drivers::primary_lcd::PrimaryDisplay;
-use embedded_graphics::pixelcolor::Rgb565;
+use creaturedex::drivers::secondary_oled::SecondaryDisplay;
-use embedded_graphics::prelude::Point;
+use creaturedex::drivers::spi_bus;
-use embedded_graphics::prelude::RgbColor;
+use creaturedex::drivers::tertiary_lcd::{
-use embedded_graphics::text::Text;
+    BOX, EMPTY, EXAMPLE, HEART, TertiaryDisplay, TertiaryDisplayPinConfiguration,
-use embedded_graphics_core::draw_target::DrawTarget;
-use embedded_hal_bus::spi::ExclusiveDevice;
-use esp_hal::clock::CpuClock;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::Level;
-use esp_hal::gpio::Output;
-use esp_hal::gpio::OutputConfig;
-use esp_hal::main;
-use esp_hal::spi::{
-    Mode,
-    master::{Config, Spi},
 };
-use esp_hal::time::{Duration, Instant};
+use creaturedex::navigation::inputs::Inputs;
+use creaturedex::navigation::navigation::{self};
+use creaturedex::navigation::outputs::Outputs;
+use creaturedex::navigation::state::NavigationState;
+use creaturedex::network::wifi::Wifi;
+use creaturedex::network::wifi::wait_for_wifi_credentials;
+use creaturedex::peripherals::Peripherals;
+use creaturedex::peripherals::storage::cardstore::CardStore;
+use creaturedex::peripherals::storage::store::Store;
+use creaturedex::peripherals::storage::wifistore::WifiStore;
+use embassy_executor::Spawner;
+use embedded_graphics::pixelcolor::BinaryColor;
+use embedded_graphics::{
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
+    prelude::*,
+    text::Text,
+};
+use embedded_hal_bus::i2c::AtomicDevice;
+use esp_hal::clock::CpuClock;
+use esp_hal::gpio::{Input, InputConfig, Pull};
 use esp_hal::timer::timg::TimerGroup;
-use esp_println::dbg;
-use ili9341::Ili9341;
-use ili9341::Orientation;
-use log::{error, info};
-use pn532::i2c::I2CInterface;
-use pn532::nb;
 
-#[panic_handler]
+use esp_backtrace as _;
-fn panic(panic_info: &core::panic::PanicInfo) -> ! {
+use esp_hal::rtc_cntl::Rtc;
-    error!("{}", panic_info);
-    loop {}
-}
 
 extern crate alloc;
 
+const HEAP_SIZE: usize = 73744;
+
+const NVS_PARTITION_OFFSET: usize = 0x9000;
+const NVS_PARTITION_SIZE: usize = 0xa0000;
+
 // This creates a default app-descriptor required by the esp-idf bootloader.
 // For more information see: <https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/app_image_format.html#application-description>
 esp_bootloader_esp_idf::esp_app_desc!();
@@ -55,230 +59,183 @@ esp_bootloader_esp_idf::esp_app_desc!();
     clippy::large_stack_frames,
     reason = "it's not unusual to allocate larger buffers etc. in main"
 )]
-#[main]
+#[esp_rtos::main]
-fn main() -> ! {
+async fn main(spawner: Spawner) {
-    // generator version: 1.3.0
+    creaturedex::logging::init();
-    // generator parameters: --chip esp32s3 -o esp32s3-wroom-1-octal-psram -o unstable-hal -o alloc -o wifi -o log -o wokwi -o neovim -o vscode -o esp
-
-    esp_println::logger::init_logger_from_env();
 
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
-    let peripherals = esp_hal::init(config);
+    let esp_peripherals = esp_hal::init(config);
 
-    let sck = peripherals.GPIO18;
+    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: HEAP_SIZE);
-    let mosi = peripherals.GPIO23;
-    let miso = peripherals.GPIO19;
-    let cs_main = peripherals.GPIO5;
-    let dc = peripherals.GPIO17;
-    let reset_main = peripherals.GPIO16;
 
-    let sda = peripherals.GPIO21;
-    let scl = peripherals.GPIO22;
-
-    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: 73744);
-
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
     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(esp_peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
-    let (mut _wifi_controller, _interfaces) =
-        esp_radio::wifi::new(peripherals.WIFI, Default::default())
-            .expect("Failed to initialize Wi-Fi controller");
 
-    let spi_bus = Spi::new(
+    let (mut primary, mut secondaries) = retry(
-        peripherals.SPI2,
+        5,
-        Config::default()
+        spi_bus::DisplayPinConfiguration {
-            .with_frequency(Rate::from_khz(100))
+            spi_peripheral: esp_peripherals.SPI2,
-            .with_mode(Mode::_0),
+            sck: esp_peripherals.GPIO36,
-    )
+            mosi: esp_peripherals.GPIO35,
-    .unwrap()
+            miso: esp_peripherals.GPIO37,
-    .with_sck(sck)
+            cs_primary: esp_peripherals.GPIO11,
-    .with_mosi(mosi)
+            cs_secondary_1: esp_peripherals.GPIO13,
-    .with_miso(miso);
+            cs_secondary_2: esp_peripherals.GPIO14,
+            cs_secondary_3: esp_peripherals.GPIO21,
+            reset_primary: esp_peripherals.GPIO10,
+            reset_secondary: esp_peripherals.GPIO47,
+            dc_pin: esp_peripherals.GPIO12,
+        },
+        spi_bus::DisplayPinConfiguration::build,
+    );
 
-    let cs_main = Output::new(cs_main, Level::High, OutputConfig::default());
+    // Initialize the shared I2C bus using the refactored i2c_bus module.
-
+    let shared_i2c = {
-    let mut delay = Delay::new();
+        let bus = retry(
-    let spi_dev = ExclusiveDevice::new(spi_bus, cs_main, delay).unwrap();
+            5,
-    let reset_main = Output::new(reset_main, Level::High, OutputConfig::default());
+            I2cBusPinConfiguration {
-    let spi_dc = Output::new(dc, Level::High, OutputConfig::default());
+                i2c_peripheral: esp_peripherals.I2C0,
-    let iface = SPIInterface::new(spi_dev, spi_dc);
+                scl: esp_peripherals.GPIO18,
-
+                sda: esp_peripherals.GPIO17,
-    let mut display = Ili9341::new(
+            },
-        iface,
+            I2cBusPinConfiguration::build,
-        reset_main,
+        );
-        &mut delay,
+        Box::leak(Box::new(bus))
-        Orientation::Landscape,
-        ili9341::DisplaySize240x320,
-    )
-    .unwrap();
-
-    // display.clear(Rgb565::BLACK).unwrap();
-
-    let style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
-    Text::new("Hello, ESP32!", Point::new(20, 100), style)
-        .draw(&mut display)
-        .unwrap();
-
-    use pn532::{Pn532, Request, requests::SAMMode};
-
-    // spi is a struct implementing embedded_hal::spi::SpiDevice
-    // timer is a struct implementing pn532::CountDown
-
-    use esp_hal::{
-        i2c::master::{Config as I2cConfig, I2c},
-        time::Rate,
     };
 
-    let config = I2cConfig::default().with_frequency(Rate::from_khz(20));
+    let mut lcd: TertiaryDisplay = retry(
-    let i2c = I2c::new(peripherals.I2C0, config)
+        5,
-        .expect("Failed to init I2C")
+        TertiaryDisplayPinConfiguration { i2c: shared_i2c },
-        .with_sda(sda)
+        TertiaryDisplayPinConfiguration::build,
-        .with_scl(scl);
+    );
-
+    lcd.load_charset(EXAMPLE).unwrap();
-    let mut pn532: Pn532<_, _, 32> = Pn532::new(I2CInterface { i2c }, TimerWrapper::new());
+    let h = EXAMPLE[HEART];
-
+    let e = EXAMPLE[EMPTY];
-    let ms_50 = Duration::from_millis(50);
+    let b = EXAMPLE[BOX];
-    let ms_1000 = Duration::from_millis(1000);
+    if let Err(e) = lcd.write(&alloc::format!(
-
+        "Custom symbols: {h}{e}{b} And more stuff to wrap and cut off please."
-    let delay_start = Instant::now();
+    )) {
-    while delay_start.elapsed() < Duration::from_millis(500) {}
+        log::error!(
-
+            "Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses: {e}"
-    let mut data: Vec<u8> = Vec::with_capacity(858);
+        );
-
-    if let Err(e) = pn532.process(
-        &Request::sam_configuration(SAMMode::Normal, false),
-        0,
-        Duration::from_millis(5000),
-    ) {
-        error!("Could not initialize PN532: {e:?}")
-    } else {
-        info!("Successfully init'ed PN532");
     }
 
-    loop {
+    let storage = esp_storage::FlashStorage::new(esp_peripherals.FLASH);
-        info!("Hello world!");
 
-        match pn532.process(
+    let nvs = Arc::new(Mutex::new(
-            &Request::INLIST_ONE_ISO_A_TARGET,
+        esp_nvs::Nvs::new(NVS_PARTITION_OFFSET, NVS_PARTITION_SIZE, storage)
-            23,
+            .expect("failed to create nvs"),
-            Duration::from_secs(10),
+    ));
-        ) {
+
-            Ok(uid) => {
+    let wifi_store = WifiStore::new(nvs.clone())
-                info!("uid = {uid:?}");
+        .await
-                for i in (0x04..=230) {
+        .expect("Could not initialize WiFi store");
-                    let mut parse_result = Err(());
+
-                    while parse_result.is_err() {
+    let mut wifi = Wifi::new(esp_peripherals.WIFI).expect("Could not initialize WiFi");
-                        let Ok(result) = pn532.process(&Request::ntag_read(i), 17, ms_1000) else {
+
-                            continue;
+    wifi.connect_with_stored_credentials(&wifi_store)
+        .await
+        .expect("could not connect initially");
+
+    let card_store = CardStore::new(nvs.clone())
+        .await
+        .expect("Could not initialize Card Store");
+
+    let store = Store {
+        card_store,
+        wifi_store,
     };
-                        parse_result = parse_nfc(i, result);
+    let rtc = Rtc::new(esp_peripherals.LPWR);
-                    }
-                    let bytes = parse_result.unwrap();
-                    data.extend(bytes);
-                }
-                info!("Full data: {data:02x?}");
-                match ndef::Message::try_from(&data[4..4 + 883]) {
-                    Ok(m) => info!("Parsed: {m:02x?}"),
-                    Err(e) => info!("Failed to parse: {e:?}"),
-                }
-                data.clear();
-            }
-            Err(e) => {
-                info!("No NFC card found: {e:?}");
-            }
-        }
 
-        let delay_start = Instant::now();
+    let peripherals = Box::leak(Box::new(Peripherals {
-        while delay_start.elapsed() < Duration::from_millis(500) {}
+        store: Mutex::new(store),
-    }
+        rtc,
+        wifi: Mutex::new(wifi),
+    }));
 
-    // for inspiration have a look at the examples at https://github.com/esp-rs/esp-hal/tree/esp-hal-v1.1.0/examples
+    let mut nfc_driver = NfcPn532Driver::new(AtomicDevice::new(shared_i2c));
-}
+    if nfc_driver.configure_sam().await.is_ok() {
-
+        log::info!("NFC SAM configuration successful on the shared I2C bus");
-fn parse_nfc(iteration: u8, bytes: &[u8]) -> Result<[u8; 4], ()> {
-    let success = bytes.first().is_some_and(|x| *x == 0);
-    if success {
-        // info!("page {i}: {:02x?}", result);
-        let mut arr = [0; 4];
-        arr.copy_from_slice(&bytes[1..5]);
-        Ok(arr)
     } else {
-        info!("err  {iteration}: {:02x?}", bytes);
+        log::error!("NFC SAM configuration failed on the shared I2C bus");
-        Err(())
+    }
+
+    let button_config = InputConfig::default().with_pull(Pull::Up);
+    let inputs = Inputs {
+        up: Input::new(esp_peripherals.GPIO38, button_config),
+        down: Input::new(esp_peripherals.GPIO39, button_config),
+        left: Input::new(esp_peripherals.GPIO40, button_config),
+        right: Input::new(esp_peripherals.GPIO41, button_config),
+        back: Input::new(esp_peripherals.GPIO8, button_config),
+        ok: Input::new(esp_peripherals.GPIO0, button_config),
+    };
+
+    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 = Box::leak(Box::new(Mutex::new({
+        let [sec_1, sec_2, sec_3] = secondaries;
+        Outputs {
+            primary_display: primary,
+            secondary_display_1: sec_1,
+            secondary_display_2: sec_2,
+            secondary_display_3: sec_3,
+            tertiary_display: lcd,
+            _led_a: (),
+        }
+    })));
+
+    let navigation_state = Box::leak(Box::new(Mutex::new(NavigationState::new())));
+
+    log::info!("Setup complete, entering main loop");
+    spawner.spawn(
+        navigation::run(inputs, outputs, peripherals, navigation_state).expect("run task failed"),
+    );
+    spawner.spawn(
+        background_tasks::nfc_scanner(nfc_driver, outputs, peripherals, navigation_state)
+            .expect("nfc scanner task failed"),
+    );
+    spawner.spawn(
+        wait_for_wifi_credentials(outputs, peripherals).expect("wifi credential task failed"),
+    );
+
+    core::future::pending::<()>().await
+}
+
+fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
+    oled.clear().unwrap();
+
+    let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
+    Text::new(text, Point::new(10, 20), text_style)
+        .draw(oled)
+        .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,
         }
     }
 
-struct TimerWrapper {
+    panic!("Init failed after {repetitions} retries.")
-    // TODO Is that timer accurate enough?
-    start: Instant,
-    duration: Duration,
-    counter: u32,
 }
-
-impl TimerWrapper {
-    pub fn new() -> Self {
-        Self {
-            start: Instant::now(),
-            duration: Duration::ZERO,
-            counter: 0,
-        }
-    }
-}
-
-impl pn532::CountDown for TimerWrapper {
-    type Time = Duration;
-
-    fn start<T>(&mut self, timeout: T)
-    where
-        T: Into<Self::Time>,
-    {
-        // without this debug log, it works worse: stuck in NFC card search without ever returning.
-        self.start = Instant::now();
-        self.duration = timeout.into();
-        self.counter = 0;
-    }
-
-    fn wait(&mut self) -> nb::Result<(), Infallible> {
-        let elapsed = self.start.elapsed();
-        self.counter += 1;
-        if self.counter.is_multiple_of(1) {
-            // info!("Elapsed: {elapsed}");
-        }
-        if elapsed >= self.duration {
-            Ok(())
-        } else {
-            Err(nb::Error::WouldBlock)
-        }
-    }
-}
-
-/*
-struct TimerWrapper<'a, T>
-where
-    T: esp_hal::DriverMode,
-{
-    timer: esp_hal::timer::PeriodicTimer<'a, T>,
-}
-
-impl<'a, TIM> pn532::CountDown for TimerWrapper<'a, TIM>
-where
-    TIM: esp_hal::DriverMode,
-{
-    type Time = Duration;
-    fn start<T>(&mut self, timeout: T)
-    where
-        T: Into<Self::Time>,
-    {
-        self.timer.start(timeout.into()).unwrap();
-    }
-
-    fn wait(&mut self) -> nb::Result<(), Infallible> {
-        // convert nb::Result<(), void::Void> to nb::Result<(), Infallible>
-        match self.timer.wait() {
-            Ok(_) => Ok(()),
-            Err(_) => Err(nb::Error::WouldBlock),
-        }
-    }
-}
- */

src/card.rs

@@ -0,0 +1,3 @@
+pub mod decoder;
+pub mod mock;
+pub mod model;

src/card/decoder.rs

@@ -0,0 +1,96 @@
+use core::fmt::Display;
+
+use crate::card::model::RawCard;
+use alloc::string::{String, ToString};
+
+pub fn split_nfc_hex(payload: &[u8]) -> Option<RawCard> {
+    if payload.len() < 0x35A {
+        return None;
+    }
+
+    Some(RawCard {
+        event_encoding: payload[0..2].try_into().ok()?,
+        card_type: payload[2],
+        card_uuid: payload[3..5].try_into().ok()?,
+        _reserved: payload[5..9].try_into().ok()?,
+        sprite: payload[9..0x2DB].try_into().ok()?,
+        packed_card_text: payload[0x2DB..0x311].try_into().ok()?,
+        secret: payload[0x311..0x329].try_into().ok()?,
+        _opaque_trailer: payload[0x329..0x35A].try_into().ok()?,
+        _padding: Default::default(),
+    })
+}
+
+#[derive(Debug, Clone)]
+pub enum Events {
+    CCC39,
+    CCC40,
+    GPN24,
+    GPN25,
+    Unknown,
+}
+
+impl Display for Events {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            Events::CCC39 => write!(f, "39C3"),
+            Events::CCC40 => write!(f, "40C3"),
+            Events::GPN24 => write!(f, "GPN24"),
+            Events::GPN25 => write!(f, "GPN25"),
+            Events::Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
+pub fn decode_known_event(event_encoding: &[u8]) -> Events {
+    match event_encoding {
+        [0x39, 0xC3] => Events::CCC39,
+        [0x40, 0xC3] => Events::CCC40, // future proofing :)
+        [0xE9, 0x24] => Events::GPN24,
+        [0xE9, 0x25] => Events::GPN25, // future proofing :)
+        _ => Events::Unknown,
+    }
+}
+
+pub fn decode_secret(hex: &[u8]) -> String {
+    let mut ascii_string = String::new();
+    for &byte in hex {
+        if byte == 0 {
+            break;
+        }
+
+        if byte.is_ascii_graphic() || byte == b' ' {
+            ascii_string.push(byte as char);
+        }
+    }
+    ascii_string
+}
+
+pub fn decode_packed_card_text(bytes: &[u8]) -> (String, String, String, String) {
+    let alphabet = b" ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-";
+    let mut full_text = String::with_capacity((bytes.len() * 8) / 6 + 1);
+
+    let mut accumulator: u32 = 0;
+    let mut bits_in_acc: u32 = 0;
+
+    for &byte in bytes {
+        accumulator |= (byte as u32) << bits_in_acc;
+        bits_in_acc += 8;
+
+        while bits_in_acc >= 6 {
+            let char_index = (accumulator & 0x3F) as usize;
+
+            full_text.push(alphabet[char_index] as char);
+
+            accumulator >>= 6;
+            bits_in_acc -= 6;
+        }
+    }
+
+    let name = full_text[0..24].trim().to_string();
+    let trait1 = full_text[24..40].trim().to_string();
+    let trait2 = full_text[40..56].trim().to_string();
+    let trait3 = full_text[56..72].trim().to_string();
+
+    (name, trait1, trait2, trait3)
+}

src/card/mock.rs

@@ -0,0 +1,173 @@
+/// GlaDos
+pub const MOCK_PAYLOAD2: [u8; 858] = [
+    0xE9, 0x24, 0x03, 0xDA, 0x45, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0xAA, 0xA0, 0xF0, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0xAA, 0xA0, 0xF0, 0xAA, 0x0F, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xAA, 0xAA, 0x00, 0xAA,
+    0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0xAA,
+    0xAA, 0x0A, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF0, 0xAA, 0xAA, 0xAA, 0x0A, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xF0, 0xAA, 0xAA, 0xA0, 0xAA, 0xA0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xAA, 0xAA, 0xA0, 0xAA, 0x0A, 0x0F, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xAA, 0xAA, 0xA0, 0x0A, 0x0A, 0x0F,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xAA, 0xAA, 0xAA,
+    0x00, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A,
+    0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0x0A, 0xAA, 0xAA, 0x6A, 0xAA, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xAA, 0xFA, 0xAA, 0xA6, 0xAA, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xAF, 0xFF, 0xFA, 0xAA, 0xAA, 0xAA, 0x0F, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xAA, 0xFA, 0xAA, 0xAA, 0xAA,
+    0xFA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0xF0, 0xAA, 0xAA,
+    0xAA, 0xAA, 0xFF, 0xA0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xDD, 0xDD, 0xDD, 0x0F,
+    0x0A, 0xAA, 0xAA, 0xA6, 0xAA, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0D, 0xDF,
+    0xFF, 0xFF, 0x00, 0xAA, 0xAA, 0xA0, 0xAA, 0xA0, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0x0D, 0x00, 0x0F, 0xF0, 0xAA, 0xAA, 0xAA, 0x0F, 0x0A, 0xA0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x0D, 0x0A, 0xAF, 0xF0, 0xAA, 0xAA, 0x0A, 0x0F, 0xFF, 0x0F, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0D, 0x00, 0x0F, 0xF0, 0xAA, 0xAA, 0xF0, 0xFF, 0xF0,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0D, 0x0E, 0x0F, 0xF0, 0xAA, 0xAA,
+    0xDD, 0xDD, 0xD0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0D, 0x00, 0x0F,
+    0xF0, 0xAF, 0xAF, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x0D, 0x0A, 0xAF, 0xF0, 0xAA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0x0D, 0x00, 0x0F, 0xF0, 0xAF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0D, 0xDF, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xDD, 0xDD, 0xDF, 0x0F, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xB3, 0x11, 0xCF, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x93, 0x3B, 0x9A,
+    0x26, 0x10, 0x98, 0x23, 0xFC, 0x01, 0x00, 0x00, 0x00, 0xCE, 0xF7, 0xB2, 0xA9, 0x9B, 0xCA, 0x23,
+    0x0A, 0x00, 0x00, 0x00, 0x00, 0xD7, 0x86, 0xBA, 0xC0, 0x9C, 0xBE, 0x40, 0x98, 0xA2, 0x1F, 0x00,
+    0x00, 0x54, 0x68, 0x65, 0x20, 0x63, 0x61, 0x6B, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x6C,
+    0x69, 0x65, 0x20, 0xF0, 0x9F, 0x8E, 0x82, 0x00, 0x00, 0x87, 0xF7, 0xB1, 0x44, 0xB0, 0x55, 0x5E,
+    0xF9, 0x22, 0xD6, 0x71, 0x45, 0xE9, 0xD5, 0xA7, 0xF8, 0x0F, 0xBE, 0x8F, 0xF6, 0xB9, 0x77, 0x62,
+    0x13, 0xF3, 0x84, 0x55, 0xD2, 0xBC, 0x4E, 0xCB, 0xDF, 0xDB, 0xC0, 0x91, 0x5F, 0x39, 0xE0, 0xF5,
+    0x95, 0x2D, 0x14, 0xBD, 0x43, 0xB2, 0x40, 0x76, 0x78, 0x00,
+];
+
+/// Blue Portal
+pub const MOCK_PAYLOAD: [u8; 858] = [
+    0xE9, 0x24, 0x01, 0x47, 0xF2, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0x77, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x77, 0x77, 0x77, 0x77, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0xF7, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x77,
+    0x77, 0xFF, 0xFF, 0x77, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF7, 0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xF7, 0xF7, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x77, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x7F, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0x77, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77,
+    0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xF7, 0x77, 0x7F, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xFF,
+    0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0xFF, 0xFF, 0x00, 0x00,
+    0x00, 0x0F, 0xFF, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0xFF,
+    0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x77, 0x7F, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0x00, 0x0F, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0x77, 0x7F, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xF0, 0x00, 0x17, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x7F, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x07,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0x00, 0xFF, 0xFF,
+    0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0x7F, 0xFF, 0xFF,
+    0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x70, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77,
+    0x7F, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xF7, 0x7F, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xFF,
+    0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0x00,
+    0x0F, 0xFF, 0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0x77, 0x7F,
+    0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xF7, 0x77, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF7, 0x77, 0x7F, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xF7, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x7F, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xF7, 0x7F, 0xFF, 0xF0, 0x00,
+    0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x7F, 0x7F, 0xFF, 0x00, 0x00, 0x00, 0x07, 0x7F,
+    0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x7F, 0x7F, 0xFF, 0xFF, 0x00,
+    0x00, 0x00, 0x0F, 0xF0, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0x7F,
+    0xFF, 0xFF, 0xFF, 0x77, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0x77, 0xF7, 0x7F, 0xFF, 0xF7, 0x77, 0x77, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x7F, 0x77, 0x77, 0x77, 0x77, 0x77, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0xFF, 0x77, 0x77, 0x77, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x77, 0x77, 0x77, 0x77,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x82, 0xF9, 0x7E, 0x00, 0x94,
+    0xB2, 0xEE, 0x66, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x3B, 0x9E,
+    0x1B, 0x3B, 0x03, 0x50, 0xCA, 0xBA, 0x9B, 0x09, 0x00, 0x81, 0xFA, 0xB1, 0xEE, 0xCB, 0x7E, 0xC0,
+    0xD4, 0x8D, 0x1F, 0xDA, 0x7D, 0x43, 0x8A, 0xB6, 0x1F, 0x0B, 0x7F, 0x2D, 0x30, 0xA9, 0xDF, 0xE7,
+    0x01, 0x53, 0x70, 0x65, 0x65, 0x64, 0x79, 0x20, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x67, 0x6F,
+    0x65, 0x73, 0x20, 0x69, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x23, 0xC0, 0xD6, 0x5A, 0x9D, 0xA2, 0xAB,
+    0xC4, 0x80, 0xC3, 0x06, 0xDB, 0xE8, 0x88, 0x7A, 0x7E, 0xB2, 0x40, 0x10, 0xA2, 0xDF, 0xC0, 0x89,
+    0x03, 0x63, 0x8F, 0x4C, 0x2F, 0xBA, 0xCC, 0x17, 0x23, 0x51, 0x60, 0x27, 0x3B, 0x00, 0x1C, 0x6D,
+    0x1F, 0x8C, 0x6B, 0x3E, 0x32, 0xE2, 0x53, 0xD9, 0x8F, 0x00,
+];
+
+/// Orange Portal
+pub const MOCK_PAYLOAD3: [u8; 858] = [
+    0xE9, 0x24, 0x01, 0x0A, 0x4B, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0x55, 0x55, 0x55, 0x5F, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0x55, 0xFF, 0xFF, 0x55, 0x55, 0xF5, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x5F, 0xFF, 0xFF, 0xFF, 0xF5,
+    0x55, 0x5F, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x50, 0x00,
+    0xFF, 0xFF, 0xF5, 0x55, 0x55, 0xF5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x55, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xF5, 0x55, 0xF5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0x55, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0x50, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xF5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF5, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xF5, 0xFF, 0xFF,
+    0xFF, 0x0F, 0xFF, 0xF5, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55,
+    0xF5, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xF5, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xF5, 0x55, 0xFF, 0x50, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xF5, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xFF, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xF5, 0x5F, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0xFF, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF,
+    0xF5, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0xF0, 0x00, 0x00, 0x00,
+    0x0F, 0xFF, 0xFF, 0xF5, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0xF0,
+    0x0F, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0x50, 0x00, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF,
+    0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0xFF, 0xFF, 0xFF, 0xF0, 0x0F,
+    0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x55, 0xFF, 0xFF,
+    0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF5, 0x55, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0x55,
+    0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0x5F, 0xFF, 0x00, 0x0F, 0xFF,
+    0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x50, 0x00,
+    0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF5, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0xFF, 0x55, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5,
+    0xFF, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x05, 0x5F,
+    0xFF, 0xF5, 0x5F, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF0, 0x00, 0x55, 0x55, 0x55, 0xF5, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x55, 0x5F, 0xFF, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0x55, 0x55, 0x55, 0x5F, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0x55, 0x55, 0x55, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xBB, 0xA1, 0xE1, 0x07,
+    0x40, 0x29, 0xEB, 0x6E, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD3, 0xD7, 0xA5,
+    0xA8, 0xB7, 0xB1, 0x33, 0x00, 0xA5, 0xAC, 0xBB, 0x99, 0xD1, 0xBB, 0xA1, 0xEE, 0x7B, 0x02, 0xCC,
+    0x88, 0x96, 0x9F, 0x07, 0x00, 0x86, 0x39, 0xA2, 0x61, 0x0B, 0x4C, 0x2F, 0x47, 0x7E, 0x9D, 0x0B,
+    0x00, 0x53, 0x70, 0x65, 0x65, 0x64, 0x79, 0x20, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F,
+    0x6D, 0x65, 0x73, 0x20, 0x6F, 0x75, 0x74, 0x00, 0x00, 0x74, 0xEE, 0xAF, 0x55, 0x52, 0x98, 0x43,
+    0x71, 0xC1, 0x71, 0xDB, 0xBC, 0xAD, 0x32, 0x89, 0x8A, 0x60, 0x82, 0x68, 0x28, 0x48, 0xBD, 0x2B,
+    0x3F, 0x48, 0x49, 0x65, 0x78, 0x88, 0xA8, 0x10, 0x39, 0x5A, 0x77, 0x64, 0xBB, 0x4F, 0x7E, 0x6F,
+    0xC3, 0xBD, 0x28, 0x43, 0xC4, 0x24, 0xB0, 0xF3, 0x2D, 0x00,
+];

src/card/model.rs

@@ -0,0 +1,304 @@
+use base64::prelude::*;
+use core::fmt::Display;
+use esp_nvs::Key;
+
+use alloc::{string::String, vec::Vec};
+use num_enum::FromPrimitive;
+
+use crate::card::decoder::{Events, decode_known_event, decode_packed_card_text, decode_secret};
+use embedded_graphics::pixelcolor::{Rgb565, Rgb888};
+
+use binary_serde::BinarySerde;
+
+#[derive(Debug, BinarySerde, PartialEq, Eq, Clone, Copy)]
+#[repr(C)]
+pub struct RawCard {
+    pub event_encoding: [u8; 2],
+    pub card_type: u8,
+    pub card_uuid: [u8; 2],
+    pub _reserved: [u8; 4],
+    pub sprite: [u8; 722],
+    pub packed_card_text: [u8; 54],
+    pub secret: [u8; 24],
+    pub _opaque_trailer: [u8; 49],
+    pub _padding: [u8; 2],
+}
+
+impl Default for RawCard {
+    fn default() -> Self {
+        Self {
+            event_encoding: Default::default(),
+            card_type: Default::default(),
+            card_uuid: Default::default(),
+            _reserved: Default::default(),
+            sprite: [0; 722],
+            packed_card_text: [0; 54],
+            secret: Default::default(),
+            _opaque_trailer: [0; 49],
+            _padding: Default::default(),
+        }
+    }
+}
+
+impl RawCard {
+    pub fn get_uuid(&self) -> u32 {
+        ((u16::from_ne_bytes(self.event_encoding) as u32) << 16)
+            | (u16::from_ne_bytes(self.card_uuid) as u32)
+    }
+
+    pub fn get_nvs_key(&self) -> Key {
+        let uuid = self.get_uuid();
+        Self::nvs_key_from_uuid(uuid)
+    }
+
+    pub fn nvs_key_from_uuid(uuid: u32) -> Key {
+        let base64 = BASE64_STANDARD.encode(uuid.to_ne_bytes());
+        Key::from_str(&base64)
+    }
+}
+static_assertions::const_assert!(RawCard::SERIALIZED_SIZE.is_multiple_of(4));
+
+#[derive(Debug, Clone, Eq, PartialEq, FromPrimitive)]
+#[repr(u8)]
+pub enum CardType {
+    #[num_enum(default)]
+    Default = 1,
+    Blueprint = 2,
+    CYBER = 3,
+    Nature = 4,
+    Fossil = 5,
+    Ghost = 6,
+    Daemon = 7,
+    Fairy = 8,
+}
+
+impl Display for CardType {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            CardType::Default => write!(f, "Default"),
+            CardType::Blueprint => write!(f, "Blueprint"),
+            CardType::CYBER => write!(f, "CYBER"),
+            CardType::Nature => write!(f, "Nature"),
+            CardType::Fossil => write!(f, "Fossil"),
+            CardType::Ghost => write!(f, "Ghost"),
+            CardType::Daemon => write!(f, "Daemon"),
+            CardType::Fairy => write!(f, "Fairy"),
+        }
+    }
+}
+
+pub type PrimaryColor = Rgb565;
+impl From<CardType> for PrimaryColor {
+    fn from(val: CardType) -> Self {
+        match val {
+            CardType::Default => Rgb888::new(0xD8, 0x68, 0x30).into(),
+            CardType::Blueprint => Rgb888::new(0x6D, 0x81, 0xFF).into(),
+            CardType::CYBER => Rgb888::new(0xFF, 0xFF, 0x04).into(),
+            CardType::Nature => Rgb888::new(0x55, 0xA0, 0x58).into(),
+            CardType::Fossil => Rgb888::new(0xB9, 0x7A, 0x60).into(),
+            CardType::Ghost => Rgb888::new(0xAB, 0xAB, 0xAB).into(),
+            CardType::Daemon => Rgb888::new(0x60, 0x00, 0x88).into(),
+            CardType::Fairy => Rgb888::new(0xB0, 0xA9, 0xE4).into(),
+        }
+    }
+}
+
+pub type Palette = [Rgb565; 16];
+impl From<CardType> for Palette {
+    fn from(val: CardType) -> Self {
+        match val {
+            CardType::Default => [
+                Rgb888::new(31, 23, 35).into(),
+                Rgb888::new(60, 47, 82).into(),
+                Rgb888::new(178, 39, 65).into(),
+                Rgb888::new(70, 86, 165).into(),
+                Rgb888::new(245, 70, 76).into(),
+                Rgb888::new(216, 104, 48).into(),
+                Rgb888::new(140, 127, 144).into(),
+                Rgb888::new(73, 149, 243).into(),
+                Rgb888::new(62, 197, 75).into(),
+                Rgb888::new(240, 149, 72).into(),
+                Rgb888::new(188, 176, 179).into(),
+                Rgb888::new(247, 156, 136).into(),
+                Rgb888::new(114, 222, 235).into(),
+                Rgb888::new(180, 230, 86).into(),
+                Rgb888::new(239, 208, 129).into(),
+                Rgb888::new(255, 255, 255).into(),
+            ],
+            CardType::Blueprint => [
+                Rgb888::new(83, 67, 127).into(),
+                Rgb888::new(44, 111, 153).into(),
+                Rgb888::new(142, 88, 111).into(),
+                Rgb888::new(0, 188, 170).into(),
+                Rgb888::new(153, 104, 226).into(),
+                Rgb888::new(109, 129, 255).into(),
+                Rgb888::new(255, 84, 112).into(),
+                Rgb888::new(196, 143, 158).into(),
+                Rgb888::new(168, 159, 204).into(),
+                Rgb888::new(190, 155, 255).into(),
+                Rgb888::new(255, 155, 113).into(),
+                Rgb888::new(127, 206, 255).into(),
+                Rgb888::new(255, 155, 182).into(),
+                Rgb888::new(255, 217, 174).into(),
+                Rgb888::new(255, 217, 232).into(),
+                Rgb888::new(255, 255, 255).into(),
+            ],
+            CardType::CYBER => [
+                Rgb888::new(0, 0, 0).into(),
+                Rgb888::new(0, 0, 126).into(),
+                Rgb888::new(0, 0, 255).into(),
+                Rgb888::new(126, 0, 0).into(),
+                Rgb888::new(126, 0, 126).into(),
+                Rgb888::new(4, 126, 0).into(),
+                Rgb888::new(254, 0, 0).into(),
+                Rgb888::new(4, 126, 126).into(),
+                Rgb888::new(254, 0, 255).into(),
+                Rgb888::new(126, 126, 0).into(),
+                Rgb888::new(126, 126, 126).into(),
+                Rgb888::new(6, 255, 4).into(),
+                Rgb888::new(6, 255, 255).into(),
+                Rgb888::new(190, 190, 190).into(),
+                Rgb888::new(255, 255, 4).into(),
+                Rgb888::new(255, 255, 255).into(),
+            ],
+            CardType::Nature => [
+                Rgb888::new(35, 34, 40).into(),
+                Rgb888::new(40, 66, 97).into(),
+                Rgb888::new(30, 116, 83).into(),
+                Rgb888::new(117, 77, 69).into(),
+                Rgb888::new(95, 88, 84).into(),
+                Rgb888::new(36, 133, 166).into(),
+                Rgb888::new(198, 80, 70).into(),
+                Rgb888::new(85, 160, 88).into(),
+                Rgb888::new(135, 133, 115).into(),
+                Rgb888::new(84, 186, 210).into(),
+                Rgb888::new(161, 191, 65).into(),
+                Rgb888::new(230, 146, 138).into(),
+                Rgb888::new(184, 176, 149).into(),
+                Rgb888::new(227, 192, 84).into(),
+                Rgb888::new(195, 213, 199).into(),
+                Rgb888::new(255, 255, 255).into(),
+            ],
+            CardType::Fossil => [
+                Rgb888::new(75, 61, 68).into(),
+                Rgb888::new(119, 66, 81).into(),
+                Rgb888::new(78, 84, 99).into(),
+                Rgb888::new(100, 83, 85).into(),
+                Rgb888::new(156, 82, 78).into(),
+                Rgb888::new(132, 109, 89).into(),
+                Rgb888::new(91, 125, 115).into(),
+                Rgb888::new(125, 123, 98).into(),
+                Rgb888::new(140, 124, 121).into(),
+                Rgb888::new(185, 122, 96).into(),
+                Rgb888::new(168, 138, 94).into(),
+                Rgb888::new(142, 159, 125).into(),
+                Rgb888::new(170, 162, 93).into(),
+                Rgb888::new(169, 156, 141).into(),
+                Rgb888::new(204, 168, 123).into(),
+                Rgb888::new(255, 255, 255).into(),
+            ],
+            CardType::Ghost => [
+                Rgb888::new(0, 0, 0).into(),
+                Rgb888::new(24, 24, 24).into(),
+                Rgb888::new(40, 40, 40).into(),
+                Rgb888::new(56, 56, 56).into(),
+                Rgb888::new(71, 71, 71).into(),
+                Rgb888::new(86, 86, 86).into(),
+                Rgb888::new(100, 100, 100).into(),
+                Rgb888::new(113, 113, 113).into(),
+                Rgb888::new(126, 126, 126).into(),
+                Rgb888::new(140, 140, 140).into(),
+                Rgb888::new(155, 155, 155).into(),
+                Rgb888::new(171, 171, 171).into(),
+                Rgb888::new(189, 189, 189).into(),
+                Rgb888::new(209, 209, 209).into(),
+                Rgb888::new(231, 231, 231).into(),
+                Rgb888::new(255, 255, 255).into(),
+            ],
+            CardType::Daemon => [
+                Rgb888::new(0, 3, 60).into(),
+                Rgb888::new(96, 0, 136).into(),
+                Rgb888::new(0, 56, 132).into(),
+                Rgb888::new(42, 46, 121).into(),
+                Rgb888::new(0, 82, 96).into(),
+                Rgb888::new(177, 5, 133).into(),
+                Rgb888::new(255, 0, 78).into(),
+                Rgb888::new(172, 41, 206).into(),
+                Rgb888::new(0, 157, 74).into(),
+                Rgb888::new(0, 138, 197).into(),
+                Rgb888::new(78, 110, 168).into(),
+                Rgb888::new(255, 92, 255).into(),
+                Rgb888::new(10, 255, 82).into(),
+                Rgb888::new(0, 247, 255).into(),
+                Rgb888::new(173, 212, 250).into(),
+                Rgb888::new(255, 255, 255).into(),
+            ],
+            CardType::Fairy => [
+                Rgb888::new(40, 40, 46).into(),
+                Rgb888::new(108, 86, 113).into(),
+                Rgb888::new(135, 168, 137).into(),
+                Rgb888::new(249, 130, 132).into(),
+                Rgb888::new(176, 169, 228).into(),
+                Rgb888::new(222, 163, 139).into(),
+                Rgb888::new(172, 204, 228).into(),
+                Rgb888::new(254, 170, 228).into(),
+                Rgb888::new(217, 200, 191).into(),
+                Rgb888::new(255, 195, 132).into(),
+                Rgb888::new(176, 235, 147).into(),
+                Rgb888::new(179, 227, 218).into(),
+                Rgb888::new(233, 245, 157).into(),
+                Rgb888::new(255, 230, 198).into(),
+                Rgb888::new(255, 247, 160).into(),
+                Rgb888::new(255, 255, 255).into(),
+            ],
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Sprite {
+    pub data: Vec<u8>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Card {
+    pub uuid: u32,
+    pub event: Events,
+    pub cardtype: CardType,
+    pub name: String,
+
+    pub trait1: String,
+    pub trait2: String,
+    pub trait3: String,
+    pub secret: String,
+
+    pub sprite: Sprite,
+}
+
+impl TryFrom<RawCard> for Card {
+    type Error = &'static str;
+
+    fn try_from(raw_card: RawCard) -> Result<Self, Self::Error> {
+        let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16
+            | (u16::from_ne_bytes(raw_card.card_uuid) as u32);
+
+        let event = decode_known_event(&raw_card.event_encoding);
+        let cardtype = CardType::from(raw_card.card_type);
+        let (name, trait1, trait2, trait3) = decode_packed_card_text(&raw_card.packed_card_text);
+        let secret = decode_secret(&raw_card.secret);
+        let sprite = Sprite {
+            data: raw_card.sprite.to_vec(),
+        };
+        Ok(Self {
+            uuid,
+            event,
+            cardtype,
+            name,
+            trait1,
+            trait2,
+            trait3,
+            secret,
+            sprite,
+        })
+    }
+}

src/display.rs

@@ -0,0 +1 @@
+pub mod sprite;

src/display/sprite.rs

@@ -0,0 +1,55 @@
+use crate::card::model::Palette;
+use embedded_graphics::{
+    geometry::Size, pixelcolor::Rgb565, prelude::Point, primitives::Rectangle,
+};
+use embedded_graphics_core::draw_target::DrawTarget;
+
+pub fn render_sprite_onto_ili9341<D>(ili9341: &mut D, sprite: &[u8], palette: &Palette)
+where
+    D: DrawTarget<Color = Rgb565>,
+{
+    let pixel_count = sprite.len() * 2;
+    if pixel_count == 0 {
+        return;
+    }
+
+    let mut src_width = 1usize;
+    while src_width * src_width < pixel_count {
+        src_width += 1;
+    }
+
+    let target_width = 240usize;
+    let scale = core::cmp::max(1, target_width / src_width);
+
+    for y in 0..src_width {
+        for x in 0..src_width {
+            let pixel_index = y * src_width + x;
+            if pixel_index >= pixel_count {
+                break;
+            }
+
+            // Bitwise operations are slightly faster than division/modulo
+            let byte_index = pixel_index >> 1;
+            let pixel_byte = sprite[byte_index];
+            let color_index = if pixel_index.is_multiple_of(2) {
+                (pixel_byte >> 4) & 0x0F
+            } else {
+                pixel_byte & 0x0F
+            };
+
+            let color = palette[color_index as usize];
+
+            let start_x = (x * scale) as i32;
+            let start_y = (y * scale) as i32;
+            let end_x = core::cmp::min(start_x + scale as i32, target_width as i32);
+            let end_y = core::cmp::min(start_y + scale as i32, target_width as i32);
+
+            let width = u32::try_from(end_x - start_x).unwrap();
+            let height = u32::try_from(end_y - start_y).unwrap();
+
+            let area = Rectangle::new(Point::new(start_x, start_y), Size::new(width, height));
+
+            let _ = ili9341.fill_solid(&area, color);
+        }
+    }
+}

src/drivers.rs

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

src/drivers/i2c_bus.rs

@@ -0,0 +1,38 @@
+use embedded_hal_bus::i2c::AtomicDevice;
+use embedded_hal_bus::util::AtomicCell;
+use esp_hal::gpio::interconnect::PeripheralInput;
+use esp_hal::i2c::master::Config;
+use esp_hal::{gpio::interconnect::PeripheralOutput, i2c::master::I2c};
+
+type InnerI2cBus<'a> = esp_hal::i2c::master::I2c<'a, esp_hal::Blocking>;
+pub type I2cBus<'a> = &'a AtomicCell<InnerI2cBus<'a>>;
+pub type I2cDevice<'a> = AtomicDevice<'a, esp_hal::i2c::master::I2c<'a, esp_hal::Blocking>>;
+
+pub struct I2cBusPinConfiguration<I2C, SCL, SDA> {
+    pub i2c_peripheral: I2C,
+    pub scl: SCL,
+    pub sda: SDA,
+}
+
+impl<'a, I2C, SCL, SDA> I2cBusPinConfiguration<I2C, SCL, SDA>
+where
+    I2C: esp_hal::i2c::master::Instance + 'a,
+    SCL: PeripheralOutput<'a> + PeripheralInput<'a>,
+    SDA: PeripheralOutput<'a> + PeripheralInput<'a>,
+{
+    pub fn build(self) -> Result<AtomicCell<InnerI2cBus<'a>>, Self> {
+        let config = Config::default().with_frequency(esp_hal::time::Rate::from_khz(400));
+        match I2c::new(self.i2c_peripheral, config) {
+            Ok(bus) => {
+                let i2c = bus.with_sda(self.sda).with_scl(self.scl);
+                log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
+                Ok(AtomicCell::new(i2c))
+            }
+            Err(e) => {
+                log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
+                unimplemented!("Partial move makes it impossible to retry.");
+                // Err(self)
+            }
+        }
+    }
+}

src/drivers/nfc_pn532.rs

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

src/drivers/primary_lcd.rs

@@ -0,0 +1,62 @@
+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;
+use embedded_graphics::prelude::RgbColor;
+use embedded_hal_bus::spi::AtomicDevice;
+use embedded_hal_bus::util::AtomicCell;
+use esp_hal::delay::Delay;
+use esp_hal::gpio::Output;
+use ili9341::{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> =
+    GenericPrimaryDisplay<'a, DisplaySpiBus, SharedOutput<'a>, Output<'a>>;
+
+pub struct PrimaryDisplayPinConfiguration<'a> {
+    pub spi_bus: &'a AtomicCell<DisplaySpiBus>,
+    pub cs: Output<'a>,
+    pub reset: Output<'a>,
+    pub dc: SharedOutput<'a>,
+}
+
+impl<'a> PrimaryDisplayPinConfiguration<'a> {
+    pub fn build(self) -> PrimaryDisplay<'a> {
+        let spi_dev = AtomicDevice::new(self.spi_bus, self.cs, Delay::new()).unwrap();
+        let iface = SPIInterface::new(spi_dev, self.dc);
+
+        let mut display = Ili9341::new(
+            iface,
+            self.reset,
+            &mut Delay::new(),
+            Orientation::Portrait,
+            DisplaySize240x320,
+        )
+        .unwrap();
+
+        display.clear(Rgb565::BLACK).unwrap();
+        display
+    }
+}

src/drivers/secondary_oled.rs

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

src/drivers/spi_bus.rs

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

src/drivers/tertiary_lcd.rs

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

src/lib.rs

@@ -1 +1,84 @@
 #![no_std]
+
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+
+extern crate alloc;
+
+pub mod background_tasks;
+pub mod card;
+pub mod display;
+pub mod drivers;
+pub mod logging;
+pub mod navigation;
+pub mod network;
+pub mod peripherals;
+pub mod views;
+
+pub type Mutex<T> = embassy_sync::mutex::Mutex<CriticalSectionRawMutex, T>;
+pub type Signal<T> = embassy_sync::signal::Signal<CriticalSectionRawMutex, T>;
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _embassy_trace_poll_start(_executor_id: u32) {}
+
+/// This callback is called AFTER a task is initialized/allocated, and BEFORE
+/// it is enqueued to run for the first time. If the task ends (and does not
+/// loop "forever"), there will be a matching call to `_embassy_trace_task_end`.
+///
+/// Tasks start life in the SPAWNED state.
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _embassy_trace_task_new(executor_id: u32, task_id: u32) {
+    log::debug!("Started new task on executer 0x{executor_id:x} with id 0x{task_id:x}")
+}
+
+/// This callback is called AFTER a task is destructed/freed. This will always
+/// have a prior matching call to `_embassy_trace_task_new`.
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _embassy_trace_task_end(executor_id: u32, task_id: u32) {
+    log::debug!("Ended task on executer 0x{executor_id:x} with id 0x{task_id:x}")
+}
+
+/// This callback is called AFTER a task has been dequeued from the runqueue,
+/// and BEFORE the task is polled. There will always be a matching call to
+/// `_embassy_trace_task_exec_end`.
+///
+/// This marks the TASK state transition from WAITING -> RUNNING
+/// This marks the EXECUTOR state transition from SCHEDULING -> POLLING
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _embassy_trace_task_exec_begin(_executor_id: u32, _task_id: u32) {}
+
+/// This callback is called AFTER a task has completed polling. There will
+/// always be a matching call to `_embassy_trace_task_exec_begin`.
+///
+/// This marks the TASK state transition from either:
+/// * RUNNING -> IDLE - if there were no `_embassy_trace_task_ready_begin` events
+///     for this task since the last `_embassy_trace_task_exec_begin` for THIS task
+/// * RUNNING -> WAITING - if there WAS a `_embassy_trace_task_ready_begin` event
+///     for this task since the last `_embassy_trace_task_exec_begin` for THIS task
+///
+/// This marks the EXECUTOR state transition from POLLING -> SCHEDULING
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _embassy_trace_task_exec_end(_executor_id: u32, _task_id: u32) {}
+
+/// This callback is called AFTER the waker for a task is awoken, and BEFORE it
+/// is added to the run queue.
+///
+/// If the given task is currently RUNNING, this marks no state change, BUT the
+/// RUNNING task will then move to the WAITING stage when polling is complete.
+///
+/// If the given task is currently IDLE, this marks the TASK state transition
+/// from IDLE -> WAITING.
+///
+/// NOTE: This may be called from an interrupt, outside the contpub ext of the current
+/// task or executor.
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _embassy_trace_task_ready_begin(_executor_id: u32, _task_id: u32) {}
+
+/// This callback is called AFTER all dequeued tasks in a single call to poll
+/// have been processed. This will always be paired with a call to
+/// `_embassy_trace_executor_idle`.
+///
+///
+/// This marks the EXECUTOR state transition from SCHEDULING -> IDLE
+///
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _embassy_trace_executor_idle(_executor_id: u32) {}

src/logging.rs

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

src/navigation.rs

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

src/navigation/inputs.rs

@@ -0,0 +1,81 @@
+use embassy_futures::select::select_array;
+use embassy_time::{Duration, Timer};
+use embedded_hal::digital::InputPin;
+use embedded_hal_async::digital::Wait;
+use esp_hal::gpio::Input;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum NavCommand {
+    NextCard,
+    PrevCard,
+    Select,
+    ScanTag,
+}
+
+pub struct Inputs {
+    pub up: Input<'static>,
+    pub down: Input<'static>,
+    pub left: Input<'static>,
+    pub right: Input<'static>,
+    pub back: Input<'static>,
+    pub ok: Input<'static>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ButtonAction {
+    Up = 0,
+    Down = 1,
+    Left = 2,
+    Right = 3,
+    Ok = 4,
+    Back = 5,
+}
+
+impl Inputs {
+    pub async fn wait_for_press(&mut self) -> ButtonAction {
+        let (_, index) = select_array([
+            wait_for_button(&mut self.up),
+            wait_for_button(&mut self.down),
+            wait_for_button(&mut self.left),
+            wait_for_button(&mut self.right),
+            wait_for_button(&mut self.ok),
+            wait_for_button(&mut self.back),
+        ])
+        .await;
+
+        match index {
+            0 => ButtonAction::Up,
+            1 => ButtonAction::Down,
+            2 => ButtonAction::Left,
+            3 => ButtonAction::Right,
+            4 => ButtonAction::Ok,
+            5 => ButtonAction::Back,
+            id => panic!("Unknown button {id} pressed"),
+        }
+    }
+}
+
+/// Waits for a button press, filtering out fast transients and mechanical bounce.
+async fn wait_for_button<P>(pin: &mut P)
+where
+    P: Wait + InputPin,
+{
+    loop {
+        // 1. Wait for the hardware interrupt (could be a real press or crosstalk)
+        let _ = pin.wait_for_falling_edge().await;
+
+        // 2. Debounce window: let the noise settle
+        Timer::after(Duration::from_millis(30)).await;
+
+        // 3. Verify the pin is still held down
+        // (Adapt unwrap() based on your specific HAL's Error type)
+        if pin.is_low().unwrap_or(false) {
+            // OPTIONAL: Wait for the button to be released before returning
+            // so holding it down doesn't spam triggers.
+            // let _ = pin.wait_for_rising_edge().await;
+            // Timer::after(Duration::from_millis(30)).await;
+
+            return;
+        }
+    }
+}

src/navigation/navigation.rs

@@ -0,0 +1,146 @@
+use crate::Mutex;
+use crate::card::model::Card;
+use crate::navigation::inputs::ButtonAction;
+use crate::navigation::inputs::Inputs;
+use crate::navigation::outputs::Outputs;
+use crate::navigation::state::NavigationState;
+use crate::peripherals::Peripherals;
+use crate::views::error_view::ErrorView;
+use crate::views::view::View;
+use alloc::boxed::Box;
+use alloc::string::String;
+use alloc::string::ToString;
+use core::error;
+
+use embassy_futures::select::{Either, select};
+use embassy_time::{Duration, Timer};
+
+pub static CARD_DATA: Mutex<Option<Card>> = Mutex::new(None);
+const DEBOUNCE_DURATION_MILLIS: u64 = 100;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Action {
+    Button(ButtonAction),
+    Timer,
+}
+
+pub struct NewState {
+    pub view: View,
+    pub replace_view: bool,
+    pub redraw: bool,
+}
+
+pub trait Navigable {
+    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;
+}
+
+pub async fn display_error(
+    error: String,
+    navigation_state: &Mutex<NavigationState>,
+    outputs: &Mutex<Outputs>,
+    peripherals: &Peripherals,
+) -> () {
+    let error_view = ErrorView {
+        error: error.to_string(),
+    };
+    let mut state = navigation_state.lock().await;
+    state.screens.push(View::Error(error_view));
+    let mut outs = outputs.lock().await;
+    state
+        .screens
+        .last()
+        // Unwrap: we just pushed the state
+        .unwrap()
+        .display(&mut outs, peripherals)
+        .await
+        // Unwrap: display will panic on error in error view
+        .unwrap();
+}
+
+#[embassy_executor::task]
+pub async fn run(
+    mut inputs: Inputs,
+    outputs: &'static Mutex<Outputs>,
+    peripherals: &'static Peripherals,
+    navigation_state: &'static Mutex<NavigationState>,
+) {
+    log::info!("starting navigation");
+
+    {
+        let mut outs = outputs.lock().await;
+        if let Err(error) = navigation_state
+            .lock()
+            .await
+            .screens
+            .last()
+            .unwrap()
+            .display(&mut outs, peripherals)
+            .await
+        {
+            display_error(error.to_string(), navigation_state, outputs, peripherals).await;
+        };
+    }
+
+    loop {
+        Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)).await;
+        let mut state = navigation_state.lock().await;
+        let selection = select(
+            inputs.wait_for_press(),
+            Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)),
+        )
+        .await;
+
+        let action = match selection {
+            Either::First(button) => Action::Button(button),
+            Either::Second(_) => Action::Timer,
+        };
+
+        if Action::Timer != action {
+            log::info!("Action: {:?}", action);
+        }
+
+        let new_state = if action == Action::Button(ButtonAction::Back) {
+            if state.screens.len() > 1 {
+                state.screens.pop();
+            }
+            NewState {
+                view: state.screens.last().expect("no screen on stack").clone(),
+                replace_view: false,
+                redraw: true,
+            }
+        } else {
+            let new_state = state
+                .screens
+                .last()
+                .expect("no screen on stack")
+                .handle_input(action)
+                .await;
+            if action == Action::Timer && !new_state.redraw {
+                continue;
+            }
+            new_state
+        };
+
+        if new_state.replace_view {
+            state.screens.pop();
+        }
+        state.screens.push(new_state.view);
+
+        let mut outs = outputs.lock().await;
+        if (action != Action::Timer || new_state.redraw)
+            && let Err(error) = state
+                .screens
+                .last()
+                .unwrap()
+                .display(&mut outs, peripherals)
+                .await
+        {
+            display_error(error.to_string(), navigation_state, outputs, peripherals).await;
+        }
+    }
+}

src/navigation/outputs.rs

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

src/navigation/state.rs

@@ -0,0 +1,40 @@
+use crate::views::{main_menu::MainMenu, view::View};
+use alloc::vec;
+use alloc::vec::Vec;
+
+#[derive(Debug, Clone)]
+pub struct NavigationState {
+    pub screens: Vec<View>,
+}
+
+impl Default for NavigationState {
+    fn default() -> Self {
+        Self {
+            screens: vec![View::Main(MainMenu { selected: 0 })],
+        }
+    }
+}
+
+impl NavigationState {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn back(&mut self) -> &View {
+        match &self.screens.len() {
+            0 => {
+                log::info!("No screens to go back to");
+                self.screens.last().unwrap()
+            }
+            1 => {
+                log::info!("Only one screen on stack, cannot go back");
+                self.screens.last().unwrap()
+            }
+            _ => {
+                log::info!("Going back to previous screen");
+                self.screens.pop();
+                self.screens.last().unwrap()
+            }
+        }
+    }
+}

src/network.rs

@@ -0,0 +1,2 @@
+pub mod api_client;
+pub mod wifi;

src/network/api_client.rs

@@ -0,0 +1 @@
+// Network api_client module

src/network/wifi.rs

@@ -0,0 +1,203 @@
+use crate::Mutex;
+use crate::Signal;
+use crate::alloc::string::ToString;
+use crate::navigation::outputs::Outputs;
+use crate::peripherals::Peripherals;
+#[cfg(not(feature = "wokwi"))]
+use crate::peripherals::storage::wifistore::WifiStore;
+use crate::peripherals::storage::wifistore::WifiStoreError;
+use alloc::string::String;
+use core::error::Error;
+use core::fmt::Display;
+use esp_radio::wifi::Config;
+use esp_radio::wifi::WifiController;
+use esp_radio::wifi::sta::StationConfig;
+use esp_radio::*;
+
+#[derive(Debug)]
+pub struct WifiCredentials {
+    pub ssid: String,
+    pub pass: String,
+}
+
+pub static WIFI_CREDENTIALS: Signal<WifiCredentials> = Signal::new();
+
+#[derive(Debug)]
+pub struct Wifi {
+    controller: WifiController<'static>,
+    interfaces: wifi::Interfaces<'static>,
+}
+
+#[derive(Debug)]
+pub enum WifiError {
+    Store(WifiStoreError),
+    Radio(esp_radio::wifi::WifiError),
+    NoCredentialsStored,
+}
+
+impl Error for WifiError {}
+
+impl Display for WifiError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            WifiError::Store(e) => e.fmt(f),
+            WifiError::Radio(e) => e.fmt(f),
+            WifiError::NoCredentialsStored => write!(f, "No WiFi credentials stored in flash"),
+        }
+    }
+}
+
+impl From<WifiStoreError> for WifiError {
+    fn from(error: WifiStoreError) -> WifiError {
+        WifiError::Store(error)
+    }
+}
+
+impl From<esp_radio::wifi::WifiError> for WifiError {
+    fn from(error: esp_radio::wifi::WifiError) -> WifiError {
+        WifiError::Radio(error)
+    }
+}
+
+impl Wifi {
+    pub fn new(wifi: esp_hal::peripherals::WIFI<'static>) -> Result<Self, WifiError> {
+        log::info!("creating new wifi");
+        let wifi = wifi::new(wifi, Default::default())?;
+
+        Ok(Self {
+            controller: wifi.0,
+            interfaces: wifi.1,
+        })
+    }
+    // get wifi credentials from env WIFI_SSID; WIFI_PASS (priority) or storage
+    pub async fn connect_with_stored_credentials(
+        &mut self,
+        wifi_store: &WifiStore,
+    ) -> Result<(), WifiError> {
+        let option_stored_credentials = wifi_store.load_credentials().await?;
+
+        let env_ssid = option_env!("WIFI_SSID");
+        let env_pass = option_env!("WIFI_PASS");
+
+        if env_ssid.is_none() && option_stored_credentials.is_none() {
+            log::info!("no initial wifi credentials. do not connect");
+            return Ok(());
+        }
+
+        let stored_credentials = option_stored_credentials.unwrap_or(WifiCredentials {
+            pass: "".to_string(),
+            ssid: "".to_string(),
+        });
+
+        let ssid = env_ssid.map_or(stored_credentials.ssid, |v| v.to_string());
+        let pass = env_pass.map_or(stored_credentials.pass, |v| v.to_string());
+
+        log::info!("initial wifi credentials:\nssid:{ssid}, pass:{pass}");
+
+        let credentials = WifiCredentials { ssid, pass };
+
+        self.set_station(credentials).await?;
+        self.connect().await?;
+
+        Ok(())
+    }
+
+    pub async fn connect(&mut self) -> Result<(), WifiError> {
+        log::info!("connecting wifi...");
+
+        let stationinfo = self.controller.connect_async().await?;
+
+        log::info!("connected to {}", stationinfo.ssid.as_str());
+
+        Ok(())
+    }
+
+    pub async fn set_station(&mut self, credentials: WifiCredentials) -> Result<(), WifiError> {
+        let station_config = StationConfig::default()
+            .with_ssid(credentials.ssid)
+            .with_password(credentials.pass);
+        self.controller
+            .set_config(&Config::Station(station_config))?;
+        Ok(())
+    }
+
+    #[cfg(feature = "wokwi")]
+    pub async fn setup(
+        wifi: esp_hal::peripherals::WIFI<'static>,
+        nvs: Arc<Mutex<Nvs>>,
+        spawner: &Spawner,
+    ) {
+        log::info!("Wokwi mode active: pre-seeding WiFi Manager with Wokwi credentials");
+
+        const WIFIMANAGER_NAMESPACE: Key = Key::from_str("wifimanager");
+        const WIFIMANAGER_NVS_KEY: Key = Key::from_str("WIFI_SETUP");
+
+        if let Err(e) = nvs.lock().await.set(
+            &WIFIMANAGER_NAMESPACE,
+            &WIFIMANAGER_NVS_KEY,
+            "{\"ssid\":\"Wokwi-GUEST\",\"psk\":\"\",\"data\":{}}",
+        ) {
+            log::error!("Failed to store Wokwi WiFi config in NVS: {e:?}");
+            return;
+        }
+
+        // Preload connection data so init_wm can connect immediately without AP setup.
+        let nvs = esp_hal_wifimanager::Nvs::new_from_nvs(nvs, 0, 0);
+
+        let mut wm_settings = esp_hal_wifimanager::WmSettings::default();
+
+        // Wokwi simulation uses a default open network called "Wokwi-GUEST"
+        wm_settings.ssid.clear();
+        _ = core::fmt::write(&mut wm_settings.ssid, format_args!("Wokwi-GUEST"));
+
+        wm_settings.wifi_conn_timeout = 30000;
+
+        // Initialize Wi-Fi connection through WiFi Manager using the pre-seeded NVS data.
+        let wifi_res =
+            esp_hal_wifimanager::init_wm(wm_settings, spawner, Some(&nvs), wifi, None).await;
+
+        log::info!("Wokwi wifi_res: {wifi_res:?}");
+    }
+}
+
+#[embassy_executor::task]
+pub async fn wait_for_wifi_credentials(
+    _outputs: &'static Mutex<Outputs>,
+    peripherals: &'static Peripherals,
+) {
+    loop {
+        log::info!("Waiting for new WiFi credentials");
+        let credentials = WIFI_CREDENTIALS.wait().await;
+
+        log::info!(
+            "Received new WiFi credentials:\nssid: {}, pass: {}",
+            credentials.ssid,
+            credentials.pass
+        );
+        if let Err(err) = peripherals
+            .store
+            .lock()
+            .await
+            .wifi_store
+            .save_credentials(&credentials)
+            .await
+        {
+            log::error!("Error storing credentials: {err}");
+            continue;
+        }
+
+        log::info!("Saved new WiFi credentials. Restarting WiFi");
+
+        let mut wifi = peripherals.wifi.lock().await;
+
+        if let Err(err) = wifi.set_station(credentials).await {
+            log::error!("Error setting new wifi station: {err}");
+            continue;
+        }
+
+        if let Err(err) = wifi.connect().await {
+            log::error!("Error connecting to wifi: {err}");
+            continue;
+        }
+    }
+}

src/peripherals.rs

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

src/peripherals/storage.rs

@@ -0,0 +1,8 @@
+use esp_storage::FlashStorage;
+
+pub type Nvs = esp_nvs::Nvs<FlashStorage<'static>>;
+
+pub mod cardstore;
+pub mod settings;
+pub mod store;
+pub mod wifistore;

src/peripherals/storage/cardstore.rs

@@ -0,0 +1,303 @@
+use crate::card::model::RawCard;
+use crate::peripherals::Mutex;
+use crate::peripherals::storage::Nvs;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use binary_serde::{BinarySerde, DeserializeError, Endianness};
+use core::error::Error;
+use core::fmt::Display;
+use esp_nvs::Key;
+
+const NVS_NAMESPACE_CARDSTORE: Key = Key::from_str("CARDSTORE");
+const NVS_NAMESPACE_CARDSTORE_METADATA: Key = Key::from_str("CSMETA");
+const NVS_NAMESPACE_CARDSTORE_CARDS: Key = Key::from_str("CSCARDS");
+
+const NVS_CARDSTORE_INITIALIZED_KEY: Key = Key::from_str("INITIALIZED");
+const NVS_CARDSTORE_CARDCOUNT_KEY: Key = Key::from_str("CARDCOUNT");
+
+const NVS_CARDSTORE_DUMMY_KEY: Key = Key::from_str("DUMMY");
+
+#[derive(Debug)]
+pub enum CardStoreError {
+    Store(esp_nvs::error::Error),
+    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<esp_nvs::error::Error> for CardStoreError {
+    fn from(error: esp_nvs::error::Error) -> CardStoreError {
+        CardStoreError::Store(error)
+    }
+}
+
+impl From<DeserializeError> for CardStoreError {
+    fn from(error: DeserializeError) -> CardStoreError {
+        CardStoreError::CorruptedEntry(error)
+    }
+}
+
+#[derive(Debug, BinarySerde, PartialEq, Eq, Clone)]
+pub struct CardStoreMetaData {
+    pub creation_date: u64,
+    pub last_read_date: u64,
+
+    // how often a card has been read by nfc
+    pub read_count: u32,
+}
+
+impl CardStoreMetaData {
+    fn new(creation_date: u64) -> Self {
+        Self {
+            creation_date,
+            last_read_date: creation_date,
+            read_count: 0,
+        }
+    }
+}
+
+pub struct CardStore {
+    nvs: Arc<Mutex<Nvs>>,
+}
+
+impl CardStore {
+    pub async fn new(nvs: Arc<Mutex<Nvs>>) -> Result<Self, CardStoreError> {
+        if !Self::is_initialized(&nvs).await? {
+            log::info!("CardStore has not been initialized");
+            Self::initialize(&nvs).await?;
+        }
+
+        log::info!("CardStore has been initialized");
+        let card_count = nvs
+            .lock()
+            .await
+            .get::<u32>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?;
+        log::info!("Cards stored in flash: {card_count}");
+
+        Ok(Self { nvs })
+    }
+
+    async fn is_initialized(nvs: &Mutex<Nvs>) -> Result<bool, CardStoreError> {
+        log::info!("check initialization");
+        let mut nvs_lock = nvs.lock().await;
+        match nvs_lock.get::<bool>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_INITIALIZED_KEY) {
+            Ok(initialized) => {
+                log::debug!("initialization_check: initialized {initialized:?}");
+                Ok(true)
+            }
+            Err(esp_nvs::error::Error::NamespaceNotFound) => {
+                log::debug!("initialization_check: error: namespace not found");
+                Ok(false)
+            }
+            Err(esp_nvs::error::Error::KeyNotFound) => {
+                log::debug!("initialization_check: error: key not found");
+                Ok(false)
+            }
+            Err(error) => Err(error.into()),
+        }
+    }
+
+    // initializing cardstore with 0 cards, so that all namespaces exist and there
+    // are only keynotfound errors in the future
+    async fn initialize(nvs: &Mutex<Nvs>) -> Result<(), CardStoreError> {
+        log::info!("initializing card store");
+
+        Self::delete_all_cards(nvs).await?;
+
+        let mut nvs_lock = nvs.lock().await;
+
+        log::debug!("initialization: write card count");
+        // initialize card count
+        nvs_lock.set::<u32>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY, 0)?;
+
+        // initialize card namespace
+        let dummy_card = RawCard::default();
+        let mut carddata_serialized: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE];
+        dummy_card.binary_serialize(&mut carddata_serialized, Endianness::Little);
+
+        log::debug!("initialization: write dummy card");
+        nvs_lock.set::<&[u8]>(
+            &NVS_NAMESPACE_CARDSTORE_CARDS,
+            &NVS_CARDSTORE_DUMMY_KEY,
+            &carddata_serialized,
+        )?;
+
+        // initialize metadata namespace
+        log::debug!("initialization: write dummy metadata");
+        let dummy_metadata = CardStoreMetaData::new(0);
+
+        let mut metadata_serialized: [u8; CardStoreMetaData::SERIALIZED_SIZE] =
+            [0; CardStoreMetaData::SERIALIZED_SIZE];
+
+        dummy_metadata.binary_serialize(&mut metadata_serialized, Endianness::Little);
+
+        nvs_lock.set::<&[u8]>(
+            &NVS_NAMESPACE_CARDSTORE_METADATA,
+            &NVS_CARDSTORE_DUMMY_KEY,
+            &metadata_serialized,
+        )?;
+
+        // set initialized
+        log::debug!("initialization: write initialized");
+        nvs_lock.set::<bool>(
+            &NVS_NAMESPACE_CARDSTORE,
+            &NVS_CARDSTORE_INITIALIZED_KEY,
+            true,
+        )?;
+
+        Ok(())
+    }
+
+    async fn delete_all_cards(nvs: &Mutex<Nvs>) -> Result<(), CardStoreError> {
+        log::info!("delete all cards");
+        let mut nvs_lock = nvs.lock().await;
+        let keys = nvs_lock.keys().collect::<Result<Vec<_>, _>>()?;
+        for (namespace, key) in keys {
+            if namespace == NVS_NAMESPACE_CARDSTORE || namespace == NVS_NAMESPACE_CARDSTORE_METADATA
+            {
+                nvs_lock.delete(&namespace, &key)?;
+            }
+        }
+        Ok(())
+    }
+
+    pub async fn load_card_count(&self) -> Result<u32, CardStoreError> {
+        log::debug!("load card count");
+        let mut nvs_lock = self.nvs.lock().await;
+        let result = nvs_lock.get::<u32>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?;
+        log::debug!("card count: {result}");
+        Ok(result)
+    }
+
+    pub async fn load_raw_card(&self, uuid: u32) -> Result<Option<RawCard>, CardStoreError> {
+        log::debug!("load raw card\nuuid: 0x{uuid:x}");
+        let nvs_key = RawCard::nvs_key_from_uuid(uuid);
+        let mut nvs_lock = self.nvs.lock().await;
+
+        let carddata_binary: Vec<u8> = match nvs_lock.get(&NVS_NAMESPACE_CARDSTORE_CARDS, &nvs_key)
+        {
+            Ok(carddata) => carddata,
+            Err(esp_nvs::error::Error::KeyNotFound) => return Ok(None),
+            Err(error) => return Err(error.into()),
+        };
+
+        let carddata = RawCard::binary_deserialize(carddata_binary.as_ref(), Endianness::Little)?;
+        Ok(Some(carddata))
+    }
+
+    async fn write_card(&self, nvs_key: Key, card: &RawCard) -> Result<(), CardStoreError> {
+        log::debug!("writing card...\nkey: {nvs_key:?}");
+        let mut carddata_serialized: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE];
+        card.binary_serialize(&mut carddata_serialized, Endianness::Little);
+
+        self.nvs.lock().await.set::<&[u8]>(
+            &NVS_NAMESPACE_CARDSTORE_CARDS,
+            &nvs_key,
+            &carddata_serialized,
+        )?;
+
+        Ok(())
+    }
+
+    async fn update_card_metadata(
+        &self,
+        nvs_key: Key,
+        timestamp: u64,
+    ) -> Result<bool, CardStoreError> {
+        log::debug!("updating card metadata...\nkey: {nvs_key:?}\ntimestamp: {timestamp}");
+        let mut is_new = false;
+        // update metadata
+        let metadata: CardStoreMetaData =
+            if let Some(mut metadata) = self.load_card_metadata(nvs_key).await? {
+                log::debug!("found existing card");
+                metadata.last_read_date = timestamp;
+                metadata.read_count += 1;
+                metadata
+            } else {
+                log::debug!("new card");
+                is_new = true;
+                CardStoreMetaData::new(timestamp)
+            };
+
+        let mut metadata_serialized: [u8; CardStoreMetaData::SERIALIZED_SIZE] =
+            [0; CardStoreMetaData::SERIALIZED_SIZE];
+
+        metadata.binary_serialize(&mut metadata_serialized, Endianness::Little);
+
+        self.nvs.lock().await.set::<&[u8]>(
+            &NVS_NAMESPACE_CARDSTORE_METADATA,
+            &nvs_key,
+            &metadata_serialized,
+        )?;
+
+        Ok(is_new)
+    }
+
+    async fn increment_card_count(&self) -> Result<(), CardStoreError> {
+        log::debug!("incrementing card count");
+        let card_count: u32 = self.load_card_count().await?;
+        log::debug!("previous card count: {card_count}");
+        self.nvs.lock().await.set::<u32>(
+            &NVS_NAMESPACE_CARDSTORE,
+            &NVS_CARDSTORE_CARDCOUNT_KEY,
+            card_count + 1,
+        )?;
+
+        let card_count = self
+            .nvs
+            .lock()
+            .await
+            .get::<u32>(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?;
+        log::info!("Cards stored in flash: {card_count}");
+        Ok(())
+    }
+
+    pub async fn save_raw_card(
+        &self,
+        card: &RawCard,
+        timestamp: u64,
+    ) -> Result<(), CardStoreError> {
+        log::debug!("saving raw card\ntimestamp: {timestamp}");
+        let nvs_key = card.get_nvs_key();
+
+        self.write_card(nvs_key, card).await?;
+
+        let new_card = self.update_card_metadata(nvs_key, timestamp).await?;
+
+        if new_card {
+            self.increment_card_count().await?;
+        }
+
+        Ok(())
+    }
+
+    pub async fn load_card_metadata(
+        &self,
+        nvs_key: Key,
+    ) -> Result<Option<CardStoreMetaData>, CardStoreError> {
+        log::debug!("load card meta data\nkey: {nvs_key:?}");
+        let mut nvs_lock = self.nvs.lock().await;
+        let metadata_binary: Vec<u8> =
+            match nvs_lock.get(&NVS_NAMESPACE_CARDSTORE_METADATA, &nvs_key) {
+                Ok(metadata) => metadata,
+                Err(esp_nvs::error::Error::KeyNotFound) => return Ok(None),
+                Err(error) => return Err(error.into()),
+            };
+
+        let metadata =
+            CardStoreMetaData::binary_deserialize(metadata_binary.as_ref(), Endianness::Little)?;
+
+        Ok(Some(metadata))
+    }
+}

src/peripherals/storage/settings.rs

@@ -0,0 +1 @@
+

src/peripherals/storage/store.rs

@@ -0,0 +1,7 @@
+use crate::peripherals::storage::cardstore::CardStore;
+use crate::peripherals::storage::wifistore::WifiStore;
+
+pub struct Store {
+    pub card_store: CardStore,
+    pub wifi_store: WifiStore,
+}

src/peripherals/storage/wifistore.rs

@@ -0,0 +1,140 @@
+use alloc::string::String;
+use crate::network::wifi::WifiCredentials;
+use crate::Mutex;
+use crate::peripherals::storage::Nvs;
+use alloc::sync::Arc;
+use core::error::Error;
+use core::fmt::Display;
+use esp_nvs::Key;
+
+const NVS_NAMESPACE_WIFI: Key = Key::from_str("WIFI");
+const NVS_WIFI_SSID_KEY: Key = Key::from_str("WIFI_SSID");
+const NVS_WIFI_PASS_KEY: Key = Key::from_str("WIFI_PASS");
+const NVS_WIFI_INITIALIZED_KEY: Key = Key::from_str("INITIALIZED");
+
+#[derive(Debug)]
+pub enum WifiStoreError {
+    Store(esp_nvs::error::Error),
+}
+
+impl Error for WifiStoreError {}
+
+impl Display for WifiStoreError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            WifiStoreError::Store(e) => e.fmt(f),
+        }
+    }
+}
+
+impl From<esp_nvs::error::Error> for WifiStoreError {
+    fn from(error: esp_nvs::error::Error) -> WifiStoreError {
+        WifiStoreError::Store(error)
+    }
+}
+
+pub struct WifiStore {
+    nvs: Arc<Mutex<Nvs>>,
+}
+
+impl WifiStore {
+    pub async fn new(nvs: Arc<Mutex<Nvs>>) -> Result<Self, WifiStoreError> {
+        if !Self::is_initialized(&nvs).await? {
+            log::info!("WifiStore has not been initialized");
+            Self::initialize(&nvs).await?;
+        }
+
+        log::info!("WifiStore has been initialized");
+
+        Ok(Self { nvs })
+    }
+
+    async fn is_initialized(nvs: &Mutex<Nvs>) -> Result<bool, WifiStoreError> {
+        log::info!("check initialization");
+        let mut nvs_lock = nvs.lock().await;
+        match nvs_lock.get::<bool>(&NVS_NAMESPACE_WIFI, &NVS_WIFI_INITIALIZED_KEY) {
+            Ok(initialized) => {
+                log::debug!("initialization_check: initialized {initialized:?}");
+                Ok(true)
+            }
+            Err(esp_nvs::error::Error::NamespaceNotFound) => {
+                log::debug!("initialization_check: error: namespace not found");
+                Ok(false)
+            }
+            Err(esp_nvs::error::Error::KeyNotFound) => {
+                log::debug!("initialization_check: error: key not found");
+                Ok(false)
+            }
+            Err(error) => Err(error.into()),
+        }
+    }
+
+    async fn initialize(nvs: &Mutex<Nvs>) -> Result<(), WifiStoreError> {
+        log::info!("initializing wifi store");
+
+        let mut nvs_lock = nvs.lock().await;
+
+        log::debug!("initialization: write empty ssid");
+        nvs_lock.set::<&str>(
+            &NVS_NAMESPACE_WIFI,
+            &NVS_WIFI_SSID_KEY,
+            ""
+        )?;
+
+        log::debug!("initialization: write empty pass");
+        nvs_lock.set::<&str>(
+            &NVS_NAMESPACE_WIFI,
+            &NVS_WIFI_PASS_KEY,
+            ""
+        )?;
+
+        // set initialized
+        log::debug!("initialization: write initialized");
+        nvs_lock.set::<bool>(
+            &NVS_NAMESPACE_WIFI,
+            &NVS_WIFI_INITIALIZED_KEY,
+            true,
+        )?;
+
+        Ok(())
+    }
+
+    pub async fn load_credentials(&self) -> Result<Option<WifiCredentials>, WifiStoreError> {
+        log::debug!("loading wifi credentials");
+        log::debug!("loading ssid");
+        let mut nvs_lock = self.nvs.lock().await;
+        let ssid = nvs_lock.get::<String>(&NVS_NAMESPACE_WIFI, &NVS_WIFI_SSID_KEY)?;
+        if ssid.is_empty() {
+            return Ok(None);
+        }
+        log::debug!("ssid: {ssid}");
+
+        log::debug!("loading pass");
+        let pass = nvs_lock.get::<String>(&NVS_NAMESPACE_WIFI, &NVS_WIFI_PASS_KEY)?;
+
+        log::debug!("pass: {pass}");
+
+        Ok(Some(WifiCredentials{ssid, pass}))
+    }
+
+    pub async fn save_credentials(&self, credentials: &WifiCredentials) -> Result<(), WifiStoreError> {
+        log::debug!("writing wifi credentials");
+        log::debug!("writing ssid...\nssid: {}", credentials.ssid);
+
+        self.nvs.lock().await.set::<&str>(
+            &NVS_NAMESPACE_WIFI,
+            &NVS_WIFI_SSID_KEY,
+            &credentials.ssid,
+        )?;
+
+        log::debug!("writing pass...\npass: {}", credentials.pass);
+
+        self.nvs.lock().await.set::<&str>(
+            &NVS_NAMESPACE_WIFI,
+            &NVS_WIFI_PASS_KEY,
+            &credentials.pass,
+        )?;
+
+        Ok(())
+    }
+}

src/views.rs

@@ -0,0 +1,10 @@
+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;
+pub mod scan_menu;
+pub mod settings_menu;
+pub mod status_bar;
+pub mod view;

src/views/card_view.rs

@@ -0,0 +1,121 @@
+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;
+use embedded_graphics::prelude::Point;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics::text::Text;
+use embedded_graphics::{Drawable, geometry::Size, primitives::Rectangle};
+use embedded_graphics_core::draw_target::DrawTarget;
+
+use core::future;
+
+use crate::{
+    card::model::{Card, Palette},
+    navigation::navigation::{Action, Navigable},
+    views::view::View,
+};
+
+#[derive(Debug, Clone)]
+pub struct CardView {
+    pub card: Card,
+}
+
+impl Navigable for CardView {
+    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)
+                .map_err(PrimaryDisplayError::from)?;
+
+            let background = Rectangle::new(Point::new(0, 0), Size::new(240, 320));
+            let bg_color = self.card.cardtype.clone().into();
+
+            let _ = display.fill_solid(&background, bg_color);
+
+            let style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
+            Text::new(
+                &format!("Name: {}", self.card.name),
+                Point::new(20, 240),
+                style,
+            )
+            .draw(display)
+            .map_err(PrimaryDisplayError::from)?;
+            Text::new(
+                &format!("Type: {}", self.card.cardtype),
+                Point::new(20, 250),
+                style,
+            )
+            .draw(display)
+            .map_err(PrimaryDisplayError::from)?;
+            Text::new(
+                &format!("Event: {}", self.card.event),
+                Point::new(20, 260),
+                style,
+            )
+            .draw(display)
+            .map_err(PrimaryDisplayError::from)?;
+            Text::new(
+                &format!("UUID: {}", self.card.uuid),
+                Point::new(20, 270),
+                style,
+            )
+            .draw(display)
+            .map_err(PrimaryDisplayError::from)?;
+            Text::new(
+                &format!("Trait1: {}", self.card.trait1),
+                Point::new(20, 280),
+                style,
+            )
+            .draw(display)
+            .map_err(PrimaryDisplayError::from)?;
+            Text::new(
+                &format!("Trait2: {}", self.card.trait2),
+                Point::new(20, 290),
+                style,
+            )
+            .draw(display)
+            .map_err(PrimaryDisplayError::from)?;
+            Text::new(
+                &format!("Trait3: {}", self.card.trait3),
+                Point::new(20, 300),
+                style,
+            )
+            .draw(display)
+            .map_err(PrimaryDisplayError::from)?;
+            Text::new(
+                &format!("Secret: {}", self.card.secret),
+                Point::new(20, 310),
+                style,
+            )
+            .draw(display)
+            .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(())
+        }
+    }
+
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
+        let new_state = NewState {
+            view: View::Card(self.clone()),
+            replace_view: true,
+            redraw: !matches!(input, Action::Timer),
+        };
+
+        future::ready(new_state)
+    }
+}

src/views/error_view.rs

@@ -0,0 +1,101 @@
+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 {
+            outputs
+                .primary_display
+                .clear(Rgb565::BLACK)
+                .unwrap_or_else(|error| {
+                    panic!(
+                        "Error: {error:?}\nDraw error while rendering ErrorView: {}",
+                        self.error
+                    )
+                });
+            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 ErrorView: {}",
+                    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, 50), 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 ErrorView: {}",
+                        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,93 @@
+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::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 {
+            outputs
+                .primary_display
+                .clear(Rgb565::BLACK)
+                .map_err(PrimaryDisplayError::from)?;
+            let _style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+
+            let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+            let textbox_style = TextBoxStyleBuilder::new()
+                .height_mode(HeightMode::FitToText)
+                .alignment(HorizontalAlignment::Justified)
+                .build();
+
+            let display_area = outputs.primary_display.bounding_box();
+            let bounds = Rectangle::new(Point::new(0, 30), display_area.size);
+
+            log::debug!("locking store");
+            let store = peripherals.store.lock().await;
+
+            log::debug!("getting card count");
+            let card_count = store.card_store.load_card_count().await?;
+
+            TextBox::with_textbox_style(
+                &format!(
+                    "
+Card Count: {}\n 
+",
+                    card_count
+                ),
+                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

@@ -0,0 +1,52 @@
+use crate::drivers::primary_lcd::PrimaryDisplayError;
+use crate::peripherals::Peripherals;
+use alloc::boxed::Box;
+use core::error;
+use core::future;
+
+use alloc::vec::Vec;
+
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics_core::draw_target::DrawTarget;
+
+use crate::{
+    card::model::Card,
+    navigation::{
+        navigation::{Action, Navigable, NewState},
+        outputs::Outputs,
+    },
+    views::view::View,
+};
+
+#[derive(Debug, Clone)]
+pub struct JournalView {
+    pub cards: Vec<Card>,
+    pub selected_card: usize,
+}
+
+impl Navigable for JournalView {
+    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)
+                .map_err(PrimaryDisplayError::from)?;
+            Ok(())
+        }
+    }
+
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
+        let new_state = NewState {
+            view: View::Journal(self.clone()),
+            replace_view: true,
+            redraw: !matches!(input, Action::Timer),
+        };
+
+        future::ready(new_state)
+    }
+}

src/views/main_menu.rs

@@ -0,0 +1,102 @@
+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::*};
+
+use crate::navigation::inputs::ButtonAction;
+use crate::navigation::outputs::Outputs;
+use crate::views::card_view::CardView;
+use crate::views::journal_view::JournalView;
+use crate::views::{menu_item, settings_menu::SettingsMenu, view::View};
+
+use crate::navigation::navigation::{Action, Navigable, NewState};
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics_core::draw_target::DrawTarget;
+
+pub const MAX_SELECTED: i32 = 4;
+
+#[derive(Debug, Clone)]
+pub struct MainMenu {
+    pub selected: i32,
+}
+
+impl Navigable for MainMenu {
+    fn display(
+        &self,
+        outputs: &mut Outputs,
+        _: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+        async move {
+            let display = &mut outputs.primary_display;
+            display.clear(Rgb565::BLACK).unwrap();
+
+            menu_item::show(display, "Scan card", 0, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Last card", 1, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Journal", 2, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+            menu_item::show(display, "Settings", 3, self.selected)
+                .map_err(PrimaryDisplayError::from)?;
+
+            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::Main(self.clone()),
+                    replace_view: true,
+                    redraw: false,
+                };
+            };
+
+            let card_mock1 = Card::try_from(split_nfc_hex(&MOCK_PAYLOAD3).unwrap()).unwrap();
+            let card_mock2 = Card::try_from(split_nfc_hex(&MOCK_PAYLOAD2).unwrap()).unwrap();
+
+            let new_menu = match input {
+                ButtonAction::Up => {
+                    let new_selected = if (self.selected - 1) < 0 {
+                        MAX_SELECTED - 1
+                    } else {
+                        self.selected - 1
+                    };
+                    View::Main(MainMenu {
+                        selected: new_selected,
+                    })
+                }
+                ButtonAction::Down => {
+                    let new_selected = self.selected.wrapping_add(1) % MAX_SELECTED;
+                    View::Main(MainMenu {
+                        selected: new_selected,
+                    })
+                }
+                ButtonAction::Ok => match self.selected {
+                    0 => View::Scan(crate::views::scan_menu::ScanMenu { progress: 0 }),
+                    1 => View::Card(CardView { card: card_mock1 }),
+                    2 => View::Journal(JournalView {
+                        cards: vec![card_mock1, card_mock2],
+                        selected_card: 0,
+                    }),
+                    3 => View::Settings(SettingsMenu { selected: 0 }),
+                    _ => View::Main(self.clone()),
+                },
+                _ => View::Main(self.clone()),
+            };
+
+            NewState {
+                replace_view: matches!(new_menu, View::Main(_)),
+                view: new_menu,
+                redraw: true,
+            }
+        }
+    }
+}

src/views/menu_item.rs

@@ -0,0 +1,29 @@
+use embedded_graphics::Drawable;
+use embedded_graphics::draw_target::DrawTarget;
+use embedded_graphics::mono_font::MonoTextStyle;
+use embedded_graphics::mono_font::ascii::FONT_10X20;
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::Point;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics::text::Text;
+
+pub fn show<D>(display: &mut D, name: &str, position: i32, selected: i32) -> Result<(), D::Error>
+where
+    D: DrawTarget<Color = Rgb565>,
+    D::Error: core::fmt::Debug,
+{
+    let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+    let selected_style = MonoTextStyle::new(&FONT_10X20, Rgb565::BLUE);
+
+    Text::new(
+        name,
+        Point::new(40, 40 + position * 40),
+        if position == selected {
+            selected_style
+        } else {
+            style
+        },
+    )
+    .draw(display)?;
+    Ok(())
+}

src/views/scan_menu.rs

@@ -0,0 +1,120 @@
+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;
+use embedded_graphics::geometry::AngleUnit as _;
+use embedded_graphics::geometry::Dimensions as _;
+use embedded_graphics::geometry::Size;
+use embedded_graphics::mono_font::MonoTextStyle;
+use embedded_graphics::mono_font::ascii::FONT_10X20;
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::Point;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics::primitives::Arc;
+use embedded_graphics::primitives::Primitive as _;
+use embedded_graphics::primitives::PrimitiveStyleBuilder;
+use embedded_graphics::primitives::Rectangle;
+use embedded_graphics::primitives::StrokeAlignment;
+use embedded_graphics::text::Alignment;
+use embedded_graphics::text::Baseline;
+use embedded_graphics::text::Text;
+use embedded_graphics::text::TextStyleBuilder;
+use embedded_graphics_core::draw_target::DrawTarget;
+
+use crate::navigation::navigation::{Action, Navigable};
+use crate::views::view::View;
+
+#[derive(Debug, Clone)]
+pub struct ScanMenu {
+    pub progress: u8, // 0..255
+}
+
+impl Navigable for ScanMenu {
+    fn display(
+        &self,
+        outputs: &mut Outputs,
+        _: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+        async move {
+            let display = &mut outputs.primary_display;
+            let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+            display
+                .clear(Rgb565::BLACK)
+                .map_err(PrimaryDisplayError::from)?;
+
+            let display_area = display.bounding_box();
+
+            Text::new("Scanning...", Point::new(20, 30), style)
+                .draw(display)
+                .map_err(PrimaryDisplayError::from)?;
+
+            // Create styles used by the drawing operations.
+            let arc_stroke = PrimitiveStyleBuilder::new()
+                .stroke_color(Rgb565::WHITE)
+                .stroke_width(5)
+                .stroke_alignment(StrokeAlignment::Inside)
+                .build();
+            let character_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+            let text_style = TextStyleBuilder::new()
+                .baseline(Baseline::Middle)
+                .alignment(Alignment::Center)
+                .build();
+
+            let sweep = self.progress as f32 * 360.0 / 255.0;
+
+            let width = display_area.size.width;
+            let bounding_box =
+                Rectangle::with_center(display_area.center(), Size::new_equal(4 * width / 5));
+            // log::info!("bounding_box: {:?}", bounding_box);
+            // log::info!("display_area: {:?}", display_area);
+            // Draw an arc with a 5px wide stroke.
+            Arc::new(
+                bounding_box.top_left,
+                bounding_box.size.width,
+                90.0.deg(),
+                sweep.deg(),
+            )
+            .into_styled(arc_stroke)
+            .draw(display)
+            .map_err(PrimaryDisplayError::from)?;
+
+            // Draw centered text.
+            let text = format!("{:.2}%", 100. * (self.progress as f32) / 255.);
+            Text::with_text_style(&text, display_area.center(), character_style, text_style)
+                .draw(display)
+                .map_err(PrimaryDisplayError::from)?;
+            Ok(())
+        }
+    }
+
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
+        async move {
+            if let Some(card_data) = CARD_DATA.lock().await.take() {
+                NewState {
+                    view: View::Card(crate::views::card_view::CardView { card: card_data }),
+                    replace_view: true,
+                    redraw: true,
+                }
+            } else {
+                let new_progress = match input {
+                    Action::Button(ButtonAction::Up) => self.progress.wrapping_add(5),
+                    _ => self.progress,
+                };
+                NewState {
+                    view: View::Scan(ScanMenu {
+                        progress: new_progress,
+                    }),
+                    replace_view: true,
+                    redraw: matches!(input, Action::Button(ButtonAction::Up) | Action::Timer),
+                }
+            }
+        }
+    }
+}

src/views/settings_menu.rs

@@ -0,0 +1,85 @@
+use crate::drivers::primary_lcd::PrimaryDisplayError;
+use crate::navigation::navigation::{Action, Navigable, NewState};
+use crate::navigation::outputs::Outputs;
+use crate::peripherals::Peripherals;
+use crate::views::{flash_info_view::FlashInfoView, menu_item, view::View};
+use alloc::boxed::Box;
+use core::error;
+
+use crate::navigation::inputs::ButtonAction;
+
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics_core::draw_target::DrawTarget;
+
+pub const MAX_SELECTED: i32 = 3;
+
+#[derive(Debug, Clone)]
+pub struct SettingsMenu {
+    pub selected: i32,
+}
+
+impl Navigable for SettingsMenu {
+    fn display(
+        &self,
+        outputs: &mut Outputs,
+        _: &Peripherals,
+    ) -> impl core::future::Future<Output = Result<(), Box<dyn error::Error>>> + Send {
+        async move {
+            let display = &mut outputs.primary_display;
+            display
+                .clear(Rgb565::BLACK)
+                .map_err(PrimaryDisplayError::from)?;
+            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 {
+                replace_view: matches!(new_menu, View::Settings(_)),
+                view: new_menu,
+                redraw: true,
+            }
+        }
+    }
+}

src/views/status_bar.rs

@@ -0,0 +1 @@
+// Status bar view module

src/views/view.rs

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

@@ -1,5 +1,10 @@
 [wokwi]
 version = 1
 gdbServerPort = 3333
-elf = "target/xtensa-esp32-none-elf/debug/creaturedex"
+elf = "target/xtensa-esp32s3-none-elf/release/creaturedex"
-firmware = "target/xtensa-esp32-none-elf/debug/creaturedex"
+firmware = "target/xtensa-esp32s3-none-elf/release/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
+  }
+}