move nfc to background tasks

.cargo/config.toml

@@ -2,11 +2,13 @@
 runner = "espflash flash --monitor --chip esp32s3"
 
 [env]
-ESP_LOG = "info"
+ESP_LOG="info"
 WM_CONN = '{"ssid": "Wokwi-GUEST", "psk": "", "data": {}}'
 
 [build]
-rustflags = ["-C", "link-arg=-nostartfiles"]
+rustflags = [
+  "-C", "link-arg=-nostartfiles",
+]
 
 target = "xtensa-esp32s3-none-elf"
 

.gitignore

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

Cargo.toml

@@ -9,11 +9,7 @@ name = "creaturedex"
 path = "./src/bin/main.rs"
 
 [dependencies]
-esp-hal = { version = "~1.1.0", features = [
+esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
-  "esp32s3",
-  "log-04",
-  "unstable",
-] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
 
 esp-rtos = { version = "0.3.0", features = [
   "embassy",
@@ -28,10 +24,15 @@ 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-executor = { version = "0.10.0", features = [
+] }
 embassy-time = { version = "0.5.1", default-features = false }
 embassy-futures = "0.1.2"
 esp-alloc = "0.10.0"
+esp-hal-wifimanager = { git = "https://github.com/InvisibleUSA/esp-hal-wifimanager", default-features = false, features = [
+  "ap",
+  "esp32s3",
+] }
 esp-println = { version = "0.17.0", features = ["esp32s3", "log-04"] }
 display-interface-spi = "0.5.0"
 ili9341 = "0.6.0"
@@ -42,25 +43,10 @@ embedded-graphics-core = "0.4.1"
 base64 = { version = "0.23.1", default-features = false, features = ["alloc"] }
 pn532 = "0.5.0"
 num_enum = { version = "0.7.6", default-features = false }
-embassy-sync = "0.7.2"
+embassy-sync = "0.8.0"
 embedded-hal-async = "1.0.0"
 i2c-character-display = "0.5.1"
 ch1115 = { version = "0.1.2", features = ["graphics"] }
-esp-storage = "0.9.0"
-embedded-storage = "0.3.1"
-binary_serde = "1.0.25"
-static_assertions = { version = "1.1.0", default-features = false }
-embedded-text = "0.7.3"
-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]
@@ -86,7 +72,3 @@ opt-level = 's'
 [features]
 default = []
 wokwi = []
-nop_tertiary = []
-
-[lints.clippy]
-manual_async_fn = "allow"

build.rs

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

diagram.json

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

espflash.toml

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

model/combined.scad

@@ -2,8 +2,8 @@ include <common.scad>
 use <left-half.scad>
 use <right-half.scad>
 
-left_half_creaturedex();
+left_half();
-right_half_creaturedex();
+right_half();
 
 #union() {
   right_half_components();

model/common.scad

@@ -1,267 +1,45 @@
-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 pin_header(cols = 4, rows = 1, anchor = BOTTOM, spin = 0, orient = UP) {
+module main_display(){
-  // Standard pin header dimensions (in mm)
+    // Outer dimensions, height currently unknown
-  base_height = 2.54; // Height of the plastic base
+    cube([55.04, 89.3, 10]);
-  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) {
+module pad(){
-  // 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);
-
-      if (pin_header)
-        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() {
     // A button has 4.2 x 6 mm -> At least ~20x20 are required for the PCB
     cube([20, 20, 10]);
 }
 
-module secondary_display(pin_header = false) {
+module small_display_below_main()
+{
     // https://de.aliexpress.com/item/1005003753680706.html
-  length = 45.8;
+    cube([45.8, 20, 11.3]);
-  width = 20;
+    // old i2c variant:
-  height = 3.7;
+    //cube([43.5, 19.44, 4.5]);
 
-  hole_diameter = 2;
+    // initial dimension ideas
-  hole_inset = 1.5;
+    // cube([38,16,4]);
-
+    // 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);
-    }
-
-    right(length / 2 - hole_inset) {
-      ycopies(width - (2 * hole_inset) - hole_diameter) {
-        zcyl(d=hole_diameter, h=height + EPS, anchor=RIGHT);
-      }
-    }
-  }
 }
 
-module battery(anchor = BOTTOM) {
+module tertiary_display()
-  // 18650
+{
-  rotate([0, 90, 0]) cylinder(d=18, h=65, anchor=anchor);
-}
-
-/// USB-C port and switch not 100% dimensionally accurate, take care!
-module micro_controller(battery_holder = false, battery = false) {
-  pcb_length = 91.5;
-  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;
-  battery_protrusion = 4.5;
-
-  difference() {
-    cuboid([pcb_length, pcb_width, pcb_height], rounding=2, edges="Z") {
-      if (battery_holder)
-        position(TOP)
-          cube([battery_holder_length, battery_holder_width, battery_holder_height], anchor=BOTTOM + CENTER) {
-            if (battery)
-              position(TOP)
-                up(battery_protrusion)
-                  battery(anchor=CENTER + LEFT);
-          }
-      position(RIGHT + BOTTOM) {
-        position(FRONT)
-          left(usb_inset_from_pcb_end)
-            cube([usb_width, usb_protrusion, pcb_height - pcb_height_no_components], orient=FRONT, anchor=RIGHT + BOTTOM + FRONT);
-        position(BACK)
-          left(power_switch_inset_from_pcb_end)
-            cube([power_switch_width, power_switch_protrusion, pcb_height - pcb_height_no_components], orient=FRONT, anchor=RIGHT + TOP + FRONT);
-      }
-    }
-
-    xcopies(pcb_length - (2 * hole_inset) - hole_diameter) {
-      ycopies(pcb_width - (2 * hole_inset) - hole_diameter) {
-        cyl(d=hole_diameter, h=pcb_height + EPS, orient=UP);
-      }
-    }
-  }
-}
-
-module nfc(pin_header = true) {
-  length = 43;
-  width = 40.5;
-  height = 4;
-
-  pin_protrusion = 2.2;
-
-  hole_diameter = 3;
-  hole_inset = 6;
-
-  x_span = length - (2 * hole_inset) - hole_diameter;
-  y_span = width - (2 * hole_inset) - hole_diameter;
-
-  color("red")
-    difference() {
-      cuboid([length, width, height], rounding=2, edges="Z") {
-        // pin header is lower than highest other component -> in the cube.
-        if (pin_header)
-          right(6 - pin_protrusion) // ugly: 6mm is the pin height
-            position(LEFT + TOP)
-              yrot(-90)
-                pin_header(7, spin=90, anchor=FRONT + TOP);
-      }
-
-      move_copies(
-        [
-          [x_span / 2, -y_span / 2], // Bottom-Left corner
-          [-x_span / 2, y_span / 2], // Top-Right corner
-        ]
-      ) {
-        zcyl(d=hole_diameter, h=height + EPS);
-      }
-    }
-}
-
-module tertiary_display(pin_headers = true) {
     // https://de.aliexpress.com/item/1005006034531826.html
-
+    cube([80, 36, 10]);
-  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
+module battery() {
-if (false) {
+    // 18650
-  back(30) tertiary_display(true);
+    rotate([0,90,0]) cylinder(d=18, h=65);
-  back(80) yrot(180) secondary_display(true);
+}
-  right(100) zrot(90) main_display(true);
+
-  fwd(20) micro_controller(true, true);
+module microcontroller() {
-  fwd(60) nfc(true);
+    // width 32 including USB-C port
+    length = 91.5;
+    height = 20;
+    battery_length = 65;
+    delta = length - battery_length;
+    cube([length, 32, height]);
+    translate([delta / 2,16, 15]) battery();
 }

model/left-half.scad

@@ -1,226 +1,12 @@
-include <BOSL2/std.scad>
 include <common.scad>
 
-module left_half_orig() {
+module left_half_components() {
-  translate(BASE_MODEL_TRANSLATE) scale(BASE_MODEL_SCALE) import(file="left-half.3mf");
+    cube([1,1,1]);
 }
 
-BASE_MODEL_SCALE = 1.1;
+module left_half() {
-// Bounds: ~ [128.62, 185.46, 35.2]
+    translate(BASE_MODEL_TRANSLATE) scale(BASE_MODEL_SCALE) import(file = "left-half.3mf");
-LEFT_HALF_BOUNDING_BOX = BASE_MODEL_SCALE * [116.93, 168.6, 32];
-
-w = LEFT_HALF_BOUNDING_BOX.x;
-l = LEFT_HALF_BOUNDING_BOX.y;
-max_h = LEFT_HALF_BOUNDING_BOX.z;
-
-// Proportional heights based on a 4.5 unit total scale
-base_h = max_h * (2.0 / 4.5);
-border_h = max_h * (2.5 / 4.5);
-top_h = max_h * (3.5 / 4.5);
-sphere_r = max_h - top_h;
-
-recess_h = 3;
-
-bump_height = 10;
-faceplate_thickness = 2;
-wall = 5;
-
-top_bump_width_big = 55;
-top_bump_width_small = 35;
-
-hinge_thickness = 22;
-
-/// Builds the top bump.
-module top_bump(height, extra_width = 0, inverted = false, wall = 2, anchor = CENTER, spin = 0, orient = UP) {
-  width_big = top_bump_width_big;
-  width_small = top_bump_width_small;
-
-  // Assuming 'w' is your base width defined in the outer scope.
-  // Lock the left side to the base width, add extra_width only to the right.
-  left_x = -w / 2;
-  right_x = (w / 2) + extra_width;
-
-  top_path = back(
-    // center the path around the origin
-    width_big / 2, [
-      [right_x, 0], // Index 0, top-right
-      [left_x, 0], // Index 1, top-left
-      [left_x, -width_big], // Index 2, bottom-left
-      [left_x / 2 + 20, -width_big], // Index 3, bottom-center-left
-      [0, -width_small], // Index 4, middle-center
-      [right_x, -width_small], // Index 5, bottom-right
-    ]
-  );
-
-  radii_list = [5, 5, 5, 15, 5, 5];
-
-  top_poly = round_corners(top_path, radius=radii_list);
-  inner_poly = offset(top_poly, delta=-wall);
-
-  // The new total width
-  total_width = w + extra_width;
-  part_size = [total_width, width_big, height];
-
-  // The geometric center of the asymmetric shape is shifted to the right
-  part_offset = [extra_width / 2, 0, 0];
-
-  // Removed the `right(extra_width)` translation here.
-  // Added `offset` so BOSL2 knows the bounding box isn't centered at [0,0,0], 
-  // keeping the CENTER anchor exactly on your original origin point.
-  attachable(anchor, spin, orient, size=part_size, offset=part_offset) {
-    if (inverted) {
-      down(wall / 2)
-        linear_sweep(inner_poly, height=height - wall + EPS, center=true);
-    } else {
-      diff("empty") {
-        linear_sweep(top_poly, height=height, center=true) {
-          attach(TOP)
-            tag("empty")
-              down(wall)
-                left(wall / 4) // (Leaving your original shift here)
-                  linear_sweep(inner_poly, height=height - wall + EPS, anchor=TOP);
-        }
-      }
-    }
-
-    children();
-  }
 }
 
-module top_bump_skirt(height = 5) {
+left_half();
-  intersection() {
+#left_half_components();
-    diff("heel_holes") {
-      tag("heel_holes")
-        down(EPS / 2)
-          top_bump(height=height * 2 + EPS, wall=wall, inverted=true, anchor=FRONT + BOTTOM);
-      top_bump(height=height, wall=wall, anchor=FRONT + BOTTOM);
-    }
-    down(EPS / 2)
-      cuboid([w, wall + (top_bump_width_big - top_bump_width_small) + EPS, height * 2 + EPS], anchor=FRONT + BOTTOM);
-  }
-}
-
-module top_bump_side_extension(width, height = 5) {
-  intersection() {
-    diff("heel_holes") {
-      tag("heel_holes")
-        down(EPS / 2)
-          top_bump(height=height * 2 + EPS, wall=wall, inverted=true, anchor=RIGHT + TOP + BACK);
-      top_bump(height=height, wall=wall, anchor=RIGHT + TOP + BACK);
-    }
-    back(EPS / 2)
-      up(EPS / 2)
-        cuboid([width, top_bump_width_small + EPS, height * 2 + EPS], anchor=RIGHT + TOP + BACK);
-  }
-}
-
-module top_bump_big_sphere(diameter, ring_extra_diameter, ring_height) {
-  zcyl(d=diameter + ring_extra_diameter, h=ring_height, anchor=BOTTOM)
-    position(TOP)
-      top_half() sphere(diameter / 2);
-}
-
-module top_bump_small_spheres(diameter, spacing) {
-  top_half() {
-    left(spacing) sphere(r=diameter / 2, anchor=CENTER);
-    sphere(r=diameter / 2, anchor=CENTER);
-    right(spacing) sphere(r=diameter / 2, anchor=CENTER);
-  }
-}
-
-/// Hinges to attach the right to the left (=this) half.
-/// Origin is at the bottom left front corner.
-module hinges(joint_axis_length = 80, hinge_thickness = 22) {
-  hinge_inset = 10;
-  hinge_inset_diameter = 6;
-
-  back(joint_axis_length)
-    yflip_copy(offset=joint_axis_length) {
-      right(border_h / 2 + 2)
-        // cannot get it to align with edge otherwise
-        ycyl(r=border_h / 2 + 2, l=hinge_thickness, anchor=BOTTOM + BACK)
-          position(FRONT) tag("holes") fwd(EPS) ycyl(d=hinge_inset_diameter, l=hinge_inset, anchor=FRONT);
-      cuboid([border_h / 2 + 2 + EPS, hinge_thickness, base_h], anchor=LEFT + BOTTOM + BACK);
-    }
-}
-
-module left_half_creaturedex() {
-  left((w + hinge_thickness) / 2)
-    diff("holes", "forcekeep")
-      // Outer walls
-      color_this("green")
-        rect_tube(h=base_h, size=[w, l], wall=wall, rounding=[0, 5, 5, 0]) {
-
-          // Gap for extension of top bump
-          position(RIGHT + BACK + BOTTOM)
-            fwd(wall)
-              move([EPS / 2, 0, -EPS / 2])
-                tag("holes")
-                  cuboid([wall + EPS, top_bump_width_small - wall + EPS, EPS + bump_height + base_h], anchor=RIGHT + BOTTOM + BACK);
-
-          // Recessed Faceplate
-          attach(TOP)
-            recolor("blue")
-              down(recess_h) {
-                cuboid([w - EPS, l - EPS, faceplate_thickness], rounding=5, edges="Z", anchor=TOP) {
-                  position(BACK)
-                    tag("holes") top_bump(height=bump_height + faceplate_thickness + recess_h, wall=wall, inverted=true, anchor=BACK);
-                }
-              }
-
-          // Top Bump
-          tag("forcekeep")
-            recolor("Gold")
-              position(TOP + BACK) {
-                down(recess_h + faceplate_thickness)
-                  top_bump(height=bump_height + faceplate_thickness + recess_h, extra_width=hinge_thickness, wall=wall, anchor=BOTTOM + BACK) {
-                    position(TOP + BACK)
-                      fwd(20) {
-                        position(LEFT)
-                          right(w / 5)
-                            top_bump_big_sphere(diameter=23, ring_extra_diameter=4, ring_height=2);
-                        position(RIGHT)
-                          left(w / 5)
-                            top_bump_small_spheres(diameter=7, spacing=15);
-                      }
-                    position(FRONT + BOTTOM)
-                      fwd(wall)
-                        top_bump_skirt(recess_h + faceplate_thickness);
-                    position(RIGHT + BACK + TOP)
-                      down(EPS)
-                        back(EPS)
-                          recolor("red")
-                            top_bump_side_extension(width=hinge_thickness + wall, height=bump_height + base_h);
-                  }
-              }
-
-          // TODO: do this properly!
-          // 4. Cutouts/Details in the Recessed Area
-          *up(base_h / 2 - max_h / 2) {
-            // Main Portrait Display Cutout
-            translate([0, 10, 0])
-              tag("holes") cuboid([w - 40, l - 90, base_h + 2], rounding=2, edges="Z");
-
-            // Small Landscape Display Cutout (Bottom Left)
-            translate([-w / 2 + 35, -l / 2 + 35, 0])
-              tag("holes") cuboid([28, 12, base_h + 2], rounding=1, edges="Z");
-
-            // D-Pad Cutout (Bottom Right)
-            translate([w / 2 - 35, -l / 2 + 35, 0])
-              tag("holes") union() {
-                  cuboid([22, 8, base_h + 2], rounding=1, edges="Z");
-                  cuboid([8, 22, base_h + 2], rounding=1, edges="Z");
-                }
-          }
-
-          // 5. Right Side Hinges
-          recolor("Red")
-            position(BOTTOM + RIGHT + FRONT) {
-              hinges();
-            }
-        }
-}
-
-left_half_creaturedex();
-
-left(300) left_half_orig();

model/right-half.scad

@@ -106,10 +106,10 @@ module right_half_hinge_only() {
 }
 // !right_half_hinge_only();
 
-module right_half_creaturedex() {
+module right_half() {
     right_half_door_only();
     right_half_hinge_only();
 }
 
-// right_half_creaturedex();
+// right_half();
 // #right_half_components();

partitions.csv

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

src/background_tasks.rs

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

src/background_tasks/nfc.rs

@@ -1,29 +1,10 @@
-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(
+async fn nfc_driver_task(
     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() {
@@ -34,37 +15,10 @@ pub async fn nfc_scanner(
                         log::error!("Failed to split NFC card data");
                         continue;
                     };
-                    let card = match Card::try_from(split_data) {
+                    CARD_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
+                        .replace(Card::try_from(split_data).unwrap());
-                        .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: {}",
@@ -72,11 +26,11 @@ pub async fn nfc_scanner(
                         card_data.len()
                     );
                 }
-                Err(_) => {
+                Err(e) => {
-                    log::info!("No NFC card found");
+                    log::error!("NFC read failed: {e}");
                 }
             }
         }
-        embassy_time::Timer::after(embassy_time::Duration::from_millis(10)).await;
+        embassy_time::Timer::after(embassy_time::Duration::from_millis(1000)).await;
     }
 }

src/bin/main.rs

@@ -7,29 +7,19 @@
 )]
 #![deny(clippy::large_stack_frames)]
 
-use alloc::boxed::Box;
+use creaturedex::card::decoder::split_nfc_hex;
-use alloc::sync::Arc;
+use creaturedex::card::model::Card;
-use creaturedex::Mutex;
-use creaturedex::background_tasks;
 use creaturedex::drivers::i2c_bus::I2cBusPinConfiguration;
 use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
-use creaturedex::drivers::primary_lcd::PrimaryDisplay;
 use creaturedex::drivers::secondary_oled::SecondaryDisplay;
 use creaturedex::drivers::spi_bus;
-use creaturedex::drivers::tertiary_lcd::{
+use creaturedex::drivers::tertiary_lcd::{TertiaryDisplay, init_tertiary_lcd, write_wrapped};
-    BOX, EMPTY, EXAMPLE, HEART, TertiaryDisplay, TertiaryDisplayPinConfiguration,
-};
 use creaturedex::navigation::inputs::Inputs;
-use creaturedex::navigation::navigation::{self};
+use creaturedex::navigation::navigation::{self, CARD_DATA};
 use creaturedex::navigation::outputs::Outputs;
-use creaturedex::navigation::state::NavigationState;
+use creaturedex::network::wifi::setup_wifi;
-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 embassy_time::Instant;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::{
     mono_font::{MonoTextStyle, ascii::FONT_6X10},
@@ -37,20 +27,23 @@ use embedded_graphics::{
     text::Text,
 };
 use embedded_hal_bus::i2c::AtomicDevice;
+use esp_hal::Blocking;
 use esp_hal::clock::CpuClock;
 use esp_hal::gpio::{Input, InputConfig, Pull};
+use esp_hal::i2c::master::I2c;
 use esp_hal::timer::timg::TimerGroup;
+use log::error;
 
-use esp_backtrace as _;
+#[panic_handler]
-use esp_hal::rtc_cntl::Rtc;
+fn panic(panic_info: &core::panic::PanicInfo) -> ! {
+    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!();
@@ -61,99 +54,51 @@ esp_bootloader_esp_idf::esp_app_desc!();
 )]
 #[esp_rtos::main]
 async fn main(spawner: Spawner) {
-    creaturedex::logging::init();
+    esp_println::logger::init_logger_from_env();
 
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
-    let esp_peripherals = esp_hal::init(config);
+    let peripherals = esp_hal::init(config);
 
     esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: HEAP_SIZE);
 
     let sw_interrupt =
-        esp_hal::interrupt::software::SoftwareInterruptControl::new(esp_peripherals.SW_INTERRUPT);
+        esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
-    let timg0 = TimerGroup::new(esp_peripherals.TIMG0);
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
 
-    let (mut primary, mut secondaries) = retry(
+    let (primary, mut secondaries) = spi_bus::DisplayPinConfiguration {
-        5,
+        spi_peripheral: peripherals.SPI2,
-        spi_bus::DisplayPinConfiguration {
+        sck: peripherals.GPIO36,
-            spi_peripheral: esp_peripherals.SPI2,
+        mosi: peripherals.GPIO35,
-            sck: esp_peripherals.GPIO36,
+        miso: peripherals.GPIO37,
-            mosi: esp_peripherals.GPIO35,
+        cs_primary: peripherals.GPIO11,
-            miso: esp_peripherals.GPIO37,
+        cs_secondary_1: peripherals.GPIO13,
-            cs_primary: esp_peripherals.GPIO11,
+        cs_secondary_2: peripherals.GPIO14,
-            cs_secondary_1: esp_peripherals.GPIO13,
+        cs_secondary_3: peripherals.GPIO21,
-            cs_secondary_2: esp_peripherals.GPIO14,
+        reset_primary: peripherals.GPIO10,
-            cs_secondary_3: esp_peripherals.GPIO21,
+        reset_secondary: peripherals.GPIO47,
-            reset_primary: esp_peripherals.GPIO10,
+        dc_pin: peripherals.GPIO12,
-            reset_secondary: esp_peripherals.GPIO47,
+    }
-            dc_pin: esp_peripherals.GPIO12,
+    .build();
-        },
-        spi_bus::DisplayPinConfiguration::build,
-    );
 
     // Initialize the shared I2C bus using the refactored i2c_bus module.
     let shared_i2c = {
-        let bus = retry(
+        let config = I2cBusPinConfiguration {
-            5,
+            i2c_peripheral: peripherals.I2C0,
-            I2cBusPinConfiguration {
+            scl: peripherals.GPIO18,
-                i2c_peripheral: esp_peripherals.I2C0,
+            sda: peripherals.GPIO17,
-                scl: esp_peripherals.GPIO18,
+        };
-                sda: esp_peripherals.GPIO17,
+        config.build()
-            },
-            I2cBusPinConfiguration::build,
-        );
-        Box::leak(Box::new(bus))
     };
 
-    let mut lcd: TertiaryDisplay = retry(
+    let mut lcd: TertiaryDisplay = init_tertiary_lcd(AtomicDevice::new(shared_i2c));
-        5,
+    if let Err(e) = write_wrapped(&mut lcd, "Testing more than 16 chars what happens now?") {
-        TertiaryDisplayPinConfiguration { i2c: shared_i2c },
-        TertiaryDisplayPinConfiguration::build,
-    );
-    lcd.load_charset(EXAMPLE).unwrap();
-    let h = EXAMPLE[HEART];
-    let e = EXAMPLE[EMPTY];
-    let b = EXAMPLE[BOX];
-    if let Err(e) = lcd.write(&alloc::format!(
-        "Custom symbols: {h}{e}{b} And more stuff to wrap and cut off please."
-    )) {
         log::error!(
             "Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses: {e}"
         );
     }
 
-    let storage = esp_storage::FlashStorage::new(esp_peripherals.FLASH);
+    setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
-
-    let nvs = Arc::new(Mutex::new(
-        esp_nvs::Nvs::new(NVS_PARTITION_OFFSET, NVS_PARTITION_SIZE, storage)
-            .expect("failed to create nvs"),
-    ));
-
-    let wifi_store = WifiStore::new(nvs.clone())
-        .await
-        .expect("Could not initialize WiFi store");
-
-    let mut wifi = Wifi::new(esp_peripherals.WIFI).expect("Could not initialize WiFi");
-
-    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,
-    };
-    let rtc = Rtc::new(esp_peripherals.LPWR);
-
-    let peripherals = Box::leak(Box::new(Peripherals {
-        store: Mutex::new(store),
-        rtc,
-        wifi: Mutex::new(wifi),
-    }));
 
     let mut nfc_driver = NfcPn532Driver::new(AtomicDevice::new(shared_i2c));
     if nfc_driver.configure_sam().await.is_ok() {
@@ -164,20 +109,19 @@ async fn main(spawner: Spawner) {
 
     let button_config = InputConfig::default().with_pull(Pull::Up);
     let inputs = Inputs {
-        up: Input::new(esp_peripherals.GPIO38, button_config),
+        up: Input::new(peripherals.GPIO38, button_config),
-        down: Input::new(esp_peripherals.GPIO39, button_config),
+        down: Input::new(peripherals.GPIO39, button_config),
-        left: Input::new(esp_peripherals.GPIO40, button_config),
+        left: Input::new(peripherals.GPIO40, button_config),
-        right: Input::new(esp_peripherals.GPIO41, button_config),
+        right: Input::new(peripherals.GPIO41, button_config),
-        back: Input::new(esp_peripherals.GPIO8, button_config),
+        back: Input::new(peripherals.GPIO8, button_config),
-        ok: Input::new(esp_peripherals.GPIO0, button_config),
+        ok: Input::new(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 outputs = {
         let [sec_1, sec_2, sec_3] = secondaries;
         Outputs {
             primary_display: primary,
@@ -187,23 +131,11 @@ async fn main(spawner: Spawner) {
             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(
+    spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
-        navigation::run(inputs, outputs, peripherals, navigation_state).expect("run task failed"),
+    spawner.spawn(nfc_driver_task(nfc_driver).expect("nfc driver 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) {
@@ -215,27 +147,3 @@ fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
         .unwrap();
     oled.flush().unwrap();
 }
-
-fn display_shit_prim(main: &mut PrimaryDisplay<'static>, text: &str) {
-    use embedded_graphics::pixelcolor::Rgb565;
-    main.clear(Rgb565::BLACK).unwrap();
-
-    let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
-    Text::new(text, Point::new(10, 20), text_style)
-        .draw(main)
-        .unwrap();
-}
-
-fn retry<T, U, F: FnMut(T) -> Result<U, T>>(repetitions: u32, input: T, mut action: F) -> U {
-    let mut initial_state = input;
-    for iteration in 0..repetitions {
-        log::debug!("Trying to initialize. Retries: {iteration}");
-
-        match action(initial_state) {
-            Ok(success) => return success,
-            Err(recovered_input) => initial_state = recovered_input,
-        }
-    }
-
-    panic!("Init failed after {repetitions} retries.")
-}

src/card/decoder.rs

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

src/card/model.rs

@@ -1,6 +1,4 @@
-use base64::prelude::*;
 use core::fmt::Display;
-use esp_nvs::Key;
 
 use alloc::{string::String, vec::Vec};
 use num_enum::FromPrimitive;
@@ -8,56 +6,18 @@ use num_enum::FromPrimitive;
 use crate::card::decoder::{Events, decode_known_event, decode_packed_card_text, decode_secret};
 use embedded_graphics::pixelcolor::{Rgb565, Rgb888};
 
-use binary_serde::BinarySerde;
+#[derive(Debug, Clone, Copy)]
-
+pub struct NfcPayload<'a> {
-#[derive(Debug, BinarySerde, PartialEq, Eq, Clone, Copy)]
+    pub event_encoding: &'a [u8],
-#[repr(C)]
-pub struct RawCard {
-    pub event_encoding: [u8; 2],
     pub card_type: u8,
-    pub card_uuid: [u8; 2],
+    pub card_uuid: &'a [u8],
-    pub _reserved: [u8; 4],
+    pub _reserved: &'a [u8],
-    pub sprite: [u8; 722],
+    pub sprite: &'a [u8],
-    pub packed_card_text: [u8; 54],
+    pub packed_card_text: &'a [u8],
-    pub secret: [u8; 24],
+    pub secret: &'a [u8],
-    pub _opaque_trailer: [u8; 49],
+    pub _opaque_trailer: &'a [u8],
-    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 {
@@ -262,7 +222,7 @@ pub struct Sprite {
 
 #[derive(Debug, Clone)]
 pub struct Card {
-    pub uuid: u32,
+    pub uuid: String,
     pub event: Events,
     pub cardtype: CardType,
     pub name: String,
@@ -275,19 +235,17 @@ pub struct Card {
     pub sprite: Sprite,
 }
 
-impl TryFrom<RawCard> for Card {
+impl<'a> TryFrom<NfcPayload<'a>> for Card {
     type Error = &'static str;
 
-    fn try_from(raw_card: RawCard) -> Result<Self, Self::Error> {
+    fn try_from(payload: NfcPayload<'a>) -> Result<Self, Self::Error> {
-        let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16
+        let uuid: String = "empty for now".into(); //str::from_utf8(payload.card_uuid).unwrap().into();
-            | (u16::from_ne_bytes(raw_card.card_uuid) as u32);
+        let event = decode_known_event(payload.event_encoding);
-
+        let cardtype = CardType::from(payload.card_type);
-        let event = decode_known_event(&raw_card.event_encoding);
+        let (name, trait1, trait2, trait3) = decode_packed_card_text(payload.packed_card_text);
-        let cardtype = CardType::from(raw_card.card_type);
+        let secret = decode_secret(payload.secret);
-        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(),
+            data: payload.sprite.to_vec(),
         };
         Ok(Self {
             uuid,

src/drivers/i2c_bus.rs

@@ -1,12 +1,11 @@
-use embedded_hal_bus::i2c::AtomicDevice;
+use alloc::boxed::Box;
 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>;
+type InnerI2cBus = esp_hal::i2c::master::I2c<'static, esp_hal::Blocking>;
-pub type I2cBus<'a> = &'a AtomicCell<InnerI2cBus<'a>>;
+pub type I2cBus = &'static AtomicCell<InnerI2cBus>;
-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,
@@ -14,25 +13,24 @@ pub struct I2cBusPinConfiguration<I2C, SCL, SDA> {
     pub sda: SDA,
 }
 
-impl<'a, I2C, SCL, SDA> I2cBusPinConfiguration<I2C, SCL, SDA>
+impl<I2C, SCL, SDA> I2cBusPinConfiguration<I2C, SCL, SDA>
 where
-    I2C: esp_hal::i2c::master::Instance + 'a,
+    I2C: esp_hal::i2c::master::Instance + 'static,
-    SCL: PeripheralOutput<'a> + PeripheralInput<'a>,
+    SCL: PeripheralOutput<'static> + PeripheralInput<'static>,
-    SDA: PeripheralOutput<'a> + PeripheralInput<'a>,
+    SDA: PeripheralOutput<'static> + PeripheralInput<'static>,
 {
-    pub fn build(self) -> Result<AtomicCell<InnerI2cBus<'a>>, Self> {
+    pub fn build(self) -> I2cBus {
         let config = Config::default().with_frequency(esp_hal::time::Rate::from_khz(400));
-        match I2c::new(self.i2c_peripheral, config) {
+        let i2c = match I2c::new(self.i2c_peripheral, config) {
-            Ok(bus) => {
+            Ok(bus) => bus.with_sda(self.sda).with_scl(self.scl),
-                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.");
+                panic!("Shared I2C bus initialization failed");
-                // Err(self)
-            }
             }
+        };
+        let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
+        log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
+
+        shared_i2c
     }
 }

src/drivers/nfc_pn532.rs

@@ -23,9 +23,118 @@ where
 struct PageParseError<const N: usize> {
     iteration: u8,
     bytes: [u8; N],
-    status_code: Option<pn532::ErrorCode>,
+    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> {
@@ -38,7 +147,7 @@ impl<const N: usize> core::fmt::Display for PageParseError<N> {
         match status_code {
             Some(code) => write!(
                 f,
-                "NFC pages parse error in iteration {iteration} with code: {code:?}: {bytes:02x?}"
+                "NFC pages parse error in iteration {iteration} with {code}: {bytes:02x?}"
             ),
             None => write!(
                 f,
@@ -78,7 +187,7 @@ where
             .await
         {
             Ok(uid) => {
-                info!("PN532 detected NFC target UID: 0x{uid:x?}");
+                info!("PN532 detected NFC target UID: {uid:?}");
                 Ok(())
             }
             Err(e) => {
@@ -101,7 +210,7 @@ where
             error => Err(PageParseError {
                 iteration,
                 bytes: arr,
-                status_code: Some(pn532::ErrorCode::try_from(error.copied().unwrap()).unwrap()),
+                status_code: error.copied().map(Into::into),
             }),
         }
     }
@@ -129,14 +238,15 @@ where
                     }
                 };
 
-                log::info!("{bytes:x?}");
                 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) {
                             return Err("Failed to parse NFC page");
                         }
                     }
+                }
             };
             let bytes = if i == 0x0B { &bytes[1..] } else { &bytes };
             data.extend(bytes);

src/drivers/primary_lcd.rs

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

src/drivers/spi_bus.rs

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

src/drivers/tertiary_lcd.rs

@@ -1,449 +1,103 @@
+use embedded_hal::i2c::I2c;
 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 TertiaryDisplay<'a> =
-pub type TertiaryDisplayError<'a> = i2c_character_display::CharacterDisplayError<I2cDevice<'a>>;
+    GenericTertiaryDisplay<AtomicDevice<'a, esp_hal::i2c::master::I2c<'a, esp_hal::Blocking>>>;
 
-pub struct TertiaryDisplayPinConfiguration<'a> {
+pub fn init_tertiary_lcd<I2C>(i2c: I2C) -> GenericTertiaryDisplay<I2C>
-    pub i2c: I2cBus<'a>,
+where
-}
+    I2C: I2c,
-
+{
-#[cfg(feature = "nop_tertiary")]
+    let mut lcd = CharacterDisplayPCF8574T::new(i2c, LcdDisplayType::Lcd16x2, Delay::new());
-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 {
+            lcd
-                    display: lcd,
-                    charset: create_custom_char_set!(),
-                })
         }
-            Err(e) => {
+        Err(_) => {
-                log::error!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
+            error!(
-                Err(self)
+                "I2C tertiary LCD init failed on PCF8574T at address 0x27; check bus wiring, power, and device address"
-            }
+            );
-        }
+            panic!("tertiary LCD initialization failed");
-    }
-}
-
-#[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 fn write_line<I2C>(
-pub struct TertiaryDisplay<'a> {
+    lcd: &mut GenericTertiaryDisplay<I2C>,
-    display: TertiaryDisplayRaw<'a>,
+    line: u8,
-    charset: CustomCharset,
+    text: &str,
-}
+) -> Result<(), i2c_character_display::CharacterDisplayError<I2C>>
-
+where
-#[cfg(feature = "nop_tertiary")]
+    I2C: I2c,
-pub struct TertiaryDisplay<'a> {
+{
-    phantom: &'a (),
+    if let Err(e) = lcd.set_cursor(0, line) {
-}
+        error!("I2C LCD cursor move failed on line {line}; bus or device may be unavailable");
-
+        return Err(e);
-#[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(())
     }
-
+    if let Err(e) = lcd.print(text) {
-    pub fn clear(&mut self) -> Result<(), TertiaryDisplayError<'a>> {
+        error!(
-        log::info!("nop tertiary");
+            "I2C LCD print failed on line {line}; payload length={} and device may be busy or disconnected",
-        Ok(())
+            text.len()
-    }
+        );
-
-    /// 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 fn write_wrapped<I2C>(
-pub enum LinesError {
+    lcd: &mut GenericTertiaryDisplay<I2C>,
-    ColumnOverflow { line: u8, columns: usize },
+    text: &str,
-    LineOverflow,
+) -> Result<(), i2c_character_display::CharacterDisplayError<I2C>>
-    InvalidChar { position: usize, symbol: char },
+where
-}
+    I2C: I2c,
+{
+    const DISPLAY_WIDTH: usize = 16;
+    const DISPLAY_ROWS: usize = 2;
 
-impl core::fmt::Display for LinesError {
+    if let Err(e) = lcd.clear() {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        error!(
-        match self {
+            "I2C LCD clear failed before wrapped write; check the shared bus and display response"
-            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"
         );
-
+        return Err(e);
-        // 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
+
+    let mut offset = 0;
+    for row in 0..DISPLAY_ROWS {
+        let remaining = &text[offset..];
+        if remaining.is_empty() {
+            return Ok(());
+        }
+
+        let chunk = if remaining.len() > DISPLAY_WIDTH {
+            &remaining[..DISPLAY_WIDTH]
+        } else {
+            remaining
         };
 
-        CustomCharset {
+        if let Err(e) = lcd.set_cursor(0, row as u8) {
-            set: SET,
+            error!(
-            len: LEN,
+                "I2C LCD cursor move failed while writing wrapped row {row}; bus may be busy or device unresponsive"
+            );
+            return Err(e);
         }
-    }};
+        if let Err(e) = lcd.print(chunk) {
+            error!(
+                "I2C LCD wrapped write failed on row {row}; chunk length={} and text may exceed display width",
+                chunk.len()
+            );
+            return Err(e);
+        }
+        offset += chunk.len();
+
+        if offset >= text.len() {
+            return Ok(());
+        }
+    }
+
+    Ok(())
 }
-
-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,84 +1,12 @@
 #![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 storage;
 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

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

src/navigation/navigation.rs

@@ -1,20 +1,16 @@
-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_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_time::{Duration, Timer};
 
+pub type Mutex<T> = embassy_sync::mutex::Mutex<CriticalSectionRawMutex, T>;
+pub type Signal<T> = embassy_sync::signal::Signal<CriticalSectionRawMutex, T>;
 pub static CARD_DATA: Mutex<Option<Card>> = Mutex::new(None);
 const DEBOUNCE_DURATION_MILLIS: u64 = 100;
 
@@ -31,64 +27,18 @@ pub struct NewState {
 }
 
 pub trait Navigable {
-    fn display(
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send;
-        &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(
+pub async fn run(mut inputs: Inputs, mut outputs: Outputs) {
-    mut inputs: Inputs,
-    outputs: &'static Mutex<Outputs>,
-    peripherals: &'static Peripherals,
-    navigation_state: &'static Mutex<NavigationState>,
-) {
     log::info!("starting navigation");
 
-    {
+    let mut state = NavigationState::new();
-        let mut outs = outputs.lock().await;
+    state.screens.last().unwrap().display(&mut outputs).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)),
@@ -131,16 +81,10 @@ pub async fn run(
         }
         state.screens.push(new_state.view);
 
-        let mut outs = outputs.lock().await;
+        if action != Action::Timer || new_state.redraw {
-        if (action != Action::Timer || new_state.redraw)
+            state.screens.last().unwrap().display(&mut outputs).await;
-            && let Err(error) = state
-                .screens
-                .last()
-                .unwrap()
-                .display(&mut outs, peripherals)
-                .await
-        {
-            display_error(error.to_string(), navigation_state, outputs, peripherals).await;
         }
+
+        Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)).await;
     }
 }

src/network/wifi.rs

@@ -1,149 +1,57 @@
-use crate::Mutex;
+use embassy_executor::Spawner;
-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;
+pub async fn setup_wifi(
-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>>,
+    flash: esp_hal::peripherals::FLASH<'static>,
     spawner: &Spawner,
-    ) {
+) {
+    let nvs = esp_hal_wifimanager::Nvs::new(0x9000, 0x6000, flash).unwrap();
+
+    let mut wm_settings = esp_hal_wifimanager::WmSettings::default();
+
+    wm_settings.ssid.clear();
+    _ = core::fmt::write(
+        &mut wm_settings.ssid,
+        format_args!("CreatureDex-{:X}", esp_hal_wifimanager::get_efuse_mac()),
+    );
+
+    wm_settings.wifi_conn_timeout = 30000;
+    wm_settings.esp_reset_timeout = Some(300000); // 5min
+
+    let wifi_res = esp_hal_wifimanager::init_wm(wm_settings, spawner, Some(&nvs), wifi, None).await;
+
+    log::info!("wifi_res: {wifi_res:?}");
+}
+
+#[cfg(feature = "wokwi")]
+pub async fn setup_wifi(
+    wifi: esp_hal::peripherals::WIFI<'static>,
+    flash: esp_hal::peripherals::FLASH<'static>,
+    spawner: &Spawner,
+) {
     log::info!("Wokwi mode active: pre-seeding WiFi Manager with Wokwi credentials");
 
-        const WIFIMANAGER_NAMESPACE: Key = Key::from_str("wifimanager");
+    // Preload connection data so init_wm can connect immediately without AP setup.
-        const WIFIMANAGER_NVS_KEY: Key = Key::from_str("WIFI_SETUP");
+    let nvs = match esp_hal_wifimanager::Nvs::new(0x9000, 0x6000, flash) {
+        Ok(nvs) => nvs,
+        Err(e) => {
+            log::error!("Failed to initialize NVS for Wokwi: {e:?}");
+            return;
+        }
+    };
 
-        if let Err(e) = nvs.lock().await.set(
+    if let Err(e) = nvs
-            &WIFIMANAGER_NAMESPACE,
+        .set(
-            &WIFIMANAGER_NVS_KEY,
+            esp_hal_wifimanager::WIFI_NVS_KEY,
             "{\"ssid\":\"Wokwi-GUEST\",\"psk\":\"\",\"data\":{}}",
-        ) {
+        )
+        .await
+    {
         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"
@@ -153,51 +61,7 @@ impl Wifi {
     wm_settings.wifi_conn_timeout = 30000;
 
     // Initialize Wi-Fi connection through WiFi Manager using the pre-seeded NVS data.
-        let wifi_res =
+    let wifi_res = esp_hal_wifimanager::init_wm(wm_settings, spawner, Some(&nvs), wifi, None).await;
-            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

@@ -1,13 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,303 +0,0 @@
-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

@@ -1 +0,0 @@
-

src/peripherals/storage/store.rs

@@ -1,7 +0,0 @@
-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

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

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

src/storage/dex_db.rs

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

src/storage/nvs.rs

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

src/views.rs

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

src/views/card_view.rs

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

src/views/error_view.rs

@@ -1,101 +0,0 @@
-use crate::navigation::navigation::Action;
-use crate::navigation::navigation::Navigable;
-use crate::navigation::navigation::NewState;
-use crate::navigation::outputs::Outputs;
-use crate::peripherals::Peripherals;
-use crate::views::view::View;
-use alloc::boxed::Box;
-use alloc::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

@@ -1,93 +0,0 @@
-use crate::drivers::primary_lcd::PrimaryDisplayError;
-use crate::navigation::navigation::Action;
-use crate::navigation::navigation::Navigable;
-use crate::navigation::navigation::NewState;
-use crate::navigation::outputs::Outputs;
-use crate::peripherals::Peripherals;
-use crate::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

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

src/views/main_menu.rs

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

src/views/menu_item.rs

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

src/views/scan_menu.rs

@@ -1,11 +1,7 @@
-use crate::drivers::primary_lcd::PrimaryDisplayError;
 use crate::navigation::inputs::ButtonAction;
 use crate::navigation::navigation::CARD_DATA;
 use crate::navigation::navigation::NewState;
 use crate::navigation::outputs::Outputs;
-use crate::peripherals::Peripherals;
-use alloc::boxed::Box;
-use core::error;
 
 use alloc::format;
 use embedded_graphics::Drawable;
@@ -37,23 +33,16 @@ pub struct ScanMenu {
 }
 
 impl Navigable for ScanMenu {
-    fn display(
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
-        &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
+        display.clear(Rgb565::BLACK).unwrap();
-                .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)?;
+            .unwrap();
 
         // Create styles used by the drawing operations.
         let arc_stroke = PrimitiveStyleBuilder::new()
@@ -83,15 +72,15 @@ impl Navigable for ScanMenu {
         )
         .into_styled(arc_stroke)
         .draw(display)
-            .map_err(PrimaryDisplayError::from)?;
+        .unwrap();
 
         // Draw centered text.
         let text = format!("{:.2}%", 100. * (self.progress as f32) / 255.);
         Text::with_text_style(&text, display_area.center(), character_style, text_style)
             .draw(display)
-                .map_err(PrimaryDisplayError::from)?;
+            .unwrap();
-            Ok(())
+
-        }
+        core::future::ready(())
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/settings_menu.rs

@@ -1,18 +1,11 @@
-use crate::drivers::primary_lcd::PrimaryDisplayError;
 use crate::navigation::navigation::{Action, Navigable, NewState};
 use crate::navigation::outputs::Outputs;
-use crate::peripherals::Peripherals;
+use crate::views::{menu_item, view::View};
-use crate::views::{flash_info_view::FlashInfoView, menu_item, view::View};
-use alloc::boxed::Box;
-use core::error;
-
-use crate::navigation::inputs::ButtonAction;
 
 use embedded_graphics::pixelcolor::Rgb565;
 use embedded_graphics::prelude::RgbColor;
 use embedded_graphics_core::draw_target::DrawTarget;
-
+pub const MAX_SELECTED: i8 = 2;
-pub const MAX_SELECTED: i32 = 3;
 
 #[derive(Debug, Clone)]
 pub struct SettingsMenu {
@@ -20,65 +13,21 @@ pub struct SettingsMenu {
 }
 
 impl Navigable for SettingsMenu {
-    fn display(
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
-        &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
+        display.clear(Rgb565::BLACK).unwrap();
-                .clear(Rgb565::BLACK)
+        menu_item::show(display, "System Inforation", 0, self.selected);
-                .map_err(PrimaryDisplayError::from)?;
+        menu_item::show(display, "Wifi Information", 1, self.selected);
-            menu_item::show(display, "System Inforation", 0, self.selected)
+
-                .map_err(PrimaryDisplayError::from)?;
+        core::future::ready(())
-            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: View::Settings(SettingsMenu { selected: 0 }),
-                view: new_menu,
+                replace_view: true,
-                redraw: true,
+                redraw: !matches!(input, Action::Timer),
             }
         }
     }

src/views/view.rs

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

wokwi.toml

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

wokwi/Makefile

@@ -1,36 +0,0 @@
-.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

@@ -1,86 +0,0 @@
-#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

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