fix: recognize actual button, not wrong one

Cargo.lock

@@ -96,6 +96,12 @@ dependencies = [
  "vsimd",
 ]
 
+[[package]]
+name = "bitfield"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f798d2d157e547aa99aab0967df39edd0b70307312b6f8bd2848e6abe40896e0"
+
 [[package]]
 name = "bitfield"
 version = "0.19.5"
@@ -229,16 +235,6 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
-[[package]]
-name = "ch1115"
-version = "0.1.2"
-source = "git+https://github.com/ede1998/ch1115.git?rev=2d3a3ba38050efe012e6a210afe3e125ec280c37#2d3a3ba38050efe012e6a210afe3e125ec280c37"
-dependencies = [
- "display-interface",
- "embedded-graphics-core",
- "embedded-hal 1.0.0",
-]
-
 [[package]]
 name = "cobs"
 version = "0.3.0"
@@ -313,16 +309,17 @@ name = "creaturedex"
 version = "0.1.0"
 dependencies = [
  "base64 0.22.1",
- "ch1115",
  "critical-section",
  "display-interface-spi",
  "embassy-executor",
+ "embassy-futures",
+ "embassy-sync 0.8.0",
  "embassy-time",
  "embedded-graphics",
  "embedded-graphics-core",
  "embedded-hal 1.0.0",
+ "embedded-hal-async",
  "embedded-hal-bus",
- "embedded-hal-compat",
  "embedded-io 0.7.1",
  "esp-alloc",
  "esp-bootloader-esp-idf",
@@ -330,12 +327,12 @@ dependencies = [
  "esp-hal-wifimanager",
  "esp-println",
  "esp-rtos",
+ "i2c-character-display",
  "ili9341",
  "log",
  "ndef",
+ "num_enum",
  "pn532",
- "sh1106",
- "ssd1306",
 ]
 
 [[package]]
@@ -620,17 +617,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ba2aab1ef3793e6f7804162debb5ac5edb93b3d650fbcc5aeb72fcd0e6c03a0"
 
-[[package]]
-name = "display-interface-i2c"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d964fa85bbbb5a6ecd06e58699407ac5dc3e3ad72dac0ab7e6b0d00a1cd262d"
-dependencies = [
- "display-interface",
- "embedded-hal 1.0.0",
- "embedded-hal-async",
-]
-
 [[package]]
 name = "display-interface-spi"
 version = "0.5.0"
@@ -970,17 +956,6 @@ dependencies = [
  "embedded-hal 1.0.0",
 ]
 
-[[package]]
-name = "embedded-hal-compat"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08ecac72f6be75ad2d4809c9f07d45502e2e5c9a4e9579077f28d7135de81df3"
-dependencies = [
- "embedded-hal 0.2.7",
- "embedded-hal 1.0.0",
- "nb 1.1.0",
-]
-
 [[package]]
 name = "embedded-io"
 version = "0.4.0"
@@ -1131,7 +1106,7 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bfcf2a0842903717f4663f6a08512c32b0f6b2d7fb7db3c8a6895d2e6d49f72"
 dependencies = [
- "bitfield",
+ "bitfield 0.19.5",
  "bitflags 2.13.1",
  "bytemuck",
  "cfg-if",
@@ -1566,27 +1541,27 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "futures-core"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cd50c473c80f6d7c3670a752354b8e569b1a7cbfdc0419ec88e5edad85e0dc7"
+checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
 
 [[package]]
 name = "futures-sink"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e34418ac499d6305c2fb5ad0ed2f6ac998c5f8ca209b4510f7f94242c647e307"
+checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"
 
 [[package]]
 name = "futures-task"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b231ed28831efb4a61a08580c4bc233ec56bc009f4cd8f52da2c3cb97df0c109"
+checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
 
 [[package]]
 name = "futures-util"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa"
+checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1713,6 +1688,16 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "i2c-character-display"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86a620ec16541e28c0e52ce21cd23d734a5d7efaae3d609b2a58694b0ef67739"
+dependencies = [
+ "bitfield 0.17.0",
+ "embedded-hal 1.0.0",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -1952,30 +1937,6 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ca88d725a0a943b096803bd34e73a4437208b6077654cc4ecb2947a5f91618d"
 
-[[package]]
-name = "manyhow"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b33efb3ca6d3b07393750d4030418d594ab1139cee518f0dc88db70fec873587"
-dependencies = [
- "manyhow-macros",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
- "syn 2.0.119",
-]
-
-[[package]]
-name = "manyhow-macros"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46fce34d199b78b6e6073abf984c9cf5fd3e9330145a93ee0738a7443e371495"
-dependencies = [
- "proc-macro-utils",
- "proc-macro2",
- "quote",
-]
-
 [[package]]
 name = "matchers"
 version = "0.2.0"
@@ -1991,19 +1952,6 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
-[[package]]
-name = "maybe-async-cfg"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8dbfaa67a76e2623580df07d6bb5e7956c0a4bae4b418314083a9c619bd66627"
-dependencies = [
- "manyhow",
- "proc-macro2",
- "pulldown-cmark",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "memchr"
 version = "2.8.3"
@@ -2763,17 +2711,6 @@ dependencies = [
  "toml_edit",
 ]
 
-[[package]]
-name = "proc-macro-utils"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eeaf08a13de400bc215877b5bdc088f241b12eb42f0a548d3390dc1c56bb7071"
-dependencies = [
- "proc-macro2",
- "quote",
- "smallvec",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.107"
@@ -2803,17 +2740,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "pulldown-cmark"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "679341d22c78c6c649893cbd6c3278dcbe9fc4faa62fea3a9296ae2b50c14625"
-dependencies = [
- "bitflags 2.13.1",
- "memchr",
- "unicase",
-]
-
 [[package]]
 name = "quote"
 version = "1.0.47"
@@ -3140,16 +3066,6 @@ dependencies = [
  "unsafe-libyaml",
 ]
 
-[[package]]
-name = "sh1106"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc12a0563ec9b3b1f99b1f64613581ebbade1347416a34766564f406c15d1bf3"
-dependencies = [
- "embedded-graphics-core",
- "embedded-hal 0.2.7",
-]
-
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -3238,20 +3154,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0f368519fc6c85fc1afdb769fb5a51123f6158013e143656e25a3485a0d401c"
 
-[[package]]
-name = "ssd1306"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ed51935bdc6e9e976d3d9a747e768589eaea0cf26f483213bfededc947c8624"
-dependencies = [
- "display-interface",
- "display-interface-i2c",
- "display-interface-spi",
- "embedded-graphics-core",
- "embedded-hal 1.0.0",
- "maybe-async-cfg",
-]
-
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -3519,12 +3421,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e87a2ed6b42ec5e28cc3b94c09982969e9227600b2e3dcbc1db927a84c06bd69"
 
-[[package]]
-name = "unicase"
-version = "2.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
-
 [[package]]
 name = "unicode-id-start"
 version = "1.4.0"

Cargo.toml

@@ -9,7 +9,7 @@ name = "creaturedex"
 path = "./src/bin/main.rs"
 
 [dependencies]
-esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] }
+esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
 
 esp-rtos = { version = "0.3.0", features = [
   "embassy",
@@ -24,8 +24,10 @@ log                    = "0.4.27"
 
 critical-section = "1.2.0"
 embedded-io = "0.7.1"
-embassy-executor = { version = "0.10.0", default-features = false }
+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",
@@ -34,7 +36,6 @@ esp-hal-wifimanager = { git = "https://github.com/InvisibleUSA/esp-hal-wifimanag
 esp-println = { version = "0.17.0", features = ["esp32s3", "log-04"] }
 display-interface-spi = "0.5.0"
 ili9341 = "0.6.0"
-ssd1306 = "0.9.0"
 embedded-hal = "1.0.0"
 embedded-hal-bus = "0.3.0"
 embedded-graphics = "0.8.2"
@@ -42,19 +43,21 @@ embedded-graphics-core = "0.4.1"
 base64 = { version = "0.22", default-features = false, features = ["alloc"] }
 pn532 = "0.5.0"
 ndef = "0.5.0"
-ch1115 = { version = "0.1.2", features = ["graphics"] }
+num_enum = { version = "0.7.6", default-features = false }
-sh1106 = "0.5.0"
+embassy-sync = "0.8.0"
-embedded-hal-compat = "0.13.0"
+embedded-hal-async = "1.0.0"
-
+i2c-character-display = "0.5.1"
-
-[patch.crates-io]
-ch1115 = { git = "https://github.com/ede1998/ch1115.git", rev = "2d3a3ba38050efe012e6a210afe3e125ec280c37" }
 
 # For fine tuning these settings, please refer to https://doc.rust-lang.org/cargo/reference/profiles.html
 [profile.dev]
 # The default debug profile is too slow and too big for resource-constrained devices.
 # Always build with some optimizations enabled.
-opt-level = "s"
+opt-level = 0
+debug = 2
+
+[profile.dev.package."*"]
+opt-level = 3
+debug = 0
 
 [profile.release]
 codegen-units = 1     # LLVM can perform better optimizations using a single thread

diagram.json

@@ -10,13 +10,55 @@
       "left": -263.96,
       "attrs": {}
     },
-    { "type": "wokwi-ili9341", "id": "lcd1", "top": -191.24, "left": -0.38, "attrs": {} },
+    { "type": "wokwi-ili9341", "id": "lcd1", "top": -200.8, "left": 354.9, "attrs": {} },
     {
       "type": "wokwi-pushbutton",
-      "id": "btn1",
+      "id": "btn-up",
-      "top": 131,
+      "top": -99.4,
-      "left": -124.8,
+      "left": -76.8,
-      "attrs": { "color": "green", "xray": "1", "key": "1" }
+      "attrs": { "color": "RebeccaPurple", "xray": "1", "key": "1", "label": "Up" }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-down",
+      "top": 25.4,
+      "left": -76.8,
+      "attrs": { "color": "green", "xray": "1", "key": "1", "label": "Down" }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-left",
+      "top": -32.2,
+      "left": -163.2,
+      "attrs": { "color": "yellow", "xray": "1", "key": "1", "label": "Left" }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-right",
+      "top": -32.2,
+      "left": 19.2,
+      "attrs": { "color": "red", "xray": "1", "key": "1", "label": "Right" }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-back",
+      "top": -99.4,
+      "left": 115.2,
+      "attrs": { "color": "Magenta", "xray": "1", "key": "1", "label": "Back" }
+    },
+    {
+      "type": "wokwi-pushbutton",
+      "id": "btn-ok",
+      "top": 25.4,
+      "left": 115.2,
+      "attrs": { "color": "Lime", "xray": "1", "key": "1", "label": "Ok" }
+    },
+    {
+      "type": "wokwi-lcd1602",
+      "id": "lcd2",
+      "top": -291.2,
+      "left": -167.2,
+      "attrs": { "pins": "i2c" }
     }
   ],
   "connections": [
@@ -30,8 +72,22 @@
     [ "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", "v105.6", "h172.8" ] ],
-    [ "btn1:1.l", "esp1:GND.2", "green", [ "h-9.6", "v-48" ] ],
+    [ "btn-up:2.l", "esp1:38", "purple", [ "h-9.6", "v19.4" ] ],
-    [ "btn1:2.l", "esp1:38", "green", [ "h-9.6", "v19.4" ] ]
+    [ "btn-up:1.l", "esp1:GND.2", "black", [ "h0" ] ],
+    [ "btn-down:1.l", "esp1:GND.2", "black", [ "h0" ] ],
+    [ "btn-down:2.l", "esp1:39", "green", [ "h-19.2", "v115.4" ] ],
+    [ "btn-left:2.l", "esp1:40", "yellow", [ "h0", "v173" ] ],
+    [ "btn-left:1.l", "esp1:GND.2", "black", [ "h0" ] ],
+    [ "btn-right:2.l", "esp1:41", "red", [ "h-19.2", "v153.8" ] ],
+    [ "btn-right:1.l", "btn-left:1.r", "black", [ "h-96", "v28.8" ] ],
+    [ "btn-back:2.l", "esp1:42", "Magenta", [ "h-19.2", "v211.58" ] ],
+    [ "btn-back:1.l", "btn-up:1.r", "black", [ "h0" ] ],
+    [ "btn-ok:1.l", "btn-down:1.r", "black", [ "h0" ] ],
+    [ "btn-ok:2.l", "esp1:45", "Lime", [ "h-9.6", "v173" ] ],
+    [ "lcd2:GND", "esp1:GND.2", "black", [ "h0" ] ],
+    [ "lcd2:VCC", "esp1:3V3.1", "red", [ "h0" ] ],
+    [ "lcd2:SDA", "esp1:17", "green", [ "h-134.4", "v413" ] ],
+    [ "lcd2:SCL", "esp1:18", "green", [ "h-124.8", "v38.7" ] ]
   ],
   "dependencies": {}
 }

src/bin/experiment_ch1115.rs

@@ -1,106 +0,0 @@
-#![no_std]
-#![no_main]
-#![deny(
-    clippy::mem_forget,
-    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
-    holding buffers for the duration of a data transfer."
-)]
-
-use ch1115::Ch1115;
-use core::cell::RefCell;
-use creaturedex::display::shared_bus::SharedPin;
-use embassy_executor::Spawner;
-use embassy_time::Timer;
-use embedded_graphics::pixelcolor::BinaryColor;
-use embedded_graphics::{
-    mono_font::{MonoTextStyle, ascii::FONT_6X10},
-    prelude::*,
-    text::Text,
-};
-use esp_hal::clock::CpuClock;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig};
-use esp_hal::spi::Mode;
-use esp_hal::spi::master::{Config as SpiConfig, Spi};
-use esp_hal::time::Rate;
-use esp_hal::timer::timg::TimerGroup;
-use log::error;
-
-#[panic_handler]
-fn panic(panic_info: &core::panic::PanicInfo) -> ! {
-    error!("{}", panic_info);
-    loop {}
-}
-
-extern crate alloc;
-
-esp_bootloader_esp_idf::esp_app_desc!();
-
-#[esp_rtos::main]
-async fn main(_spawner: Spawner) {
-    esp_println::logger::init_logger_from_env();
-
-    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
-    let peripherals = esp_hal::init(config);
-
-    // The following GPIO pins are in use by some feature of the module and should not be used.
-    let _ = peripherals.GPIO27;
-    let _ = peripherals.GPIO28;
-    let _ = peripherals.GPIO29;
-    let _ = peripherals.GPIO30;
-    let _ = peripherals.GPIO31;
-    let _ = peripherals.GPIO32;
-    let _ = peripherals.GPIO33;
-    let _ = peripherals.GPIO34;
-
-    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: 73744);
-
-    let mut delay = Delay::new();
-
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
-    let sw_interrupt =
-        esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
-    esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
-
-    let spi = peripherals.SPI2;
-    let sck = peripherals.GPIO36;
-    let mosi = peripherals.GPIO35;
-    let cs = peripherals.GPIO13;
-    let reset = peripherals.GPIO10;
-    let dc = peripherals.GPIO12;
-    let miso = peripherals.GPIO37;
-
-    let cs = Output::new(cs, Level::High, OutputConfig::default());
-    let dc = Output::new(dc, Level::Low, OutputConfig::default());
-    let reset = Output::new(reset, Level::High, OutputConfig::default());
-
-    let spi = Spi::new(
-        spi,
-        SpiConfig::default()
-            .with_frequency(Rate::from_khz(5000))
-            .with_mode(Mode::_0),
-    )
-    .unwrap()
-    .with_sck(sck)
-    .with_mosi(mosi)
-    .with_miso(miso);
-
-    let spi = RefCell::new(spi);
-    let spi_dev = embedded_hal_bus::spi::RefCellDevice::new(&spi, cs, delay).unwrap();
-    let interface = display_interface_spi::SPIInterface::new(spi_dev, dc);
-
-    let mut display = Ch1115::new(interface, reset, ch1115::Size128x64);
-    display.init(&mut delay).unwrap();
-
-
-    loop {
-        log::info!("Init finished");
-        let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
-        Text::new("Hello OLED", Point::new(10, 20), text_style)
-            .draw(&mut display)
-            .unwrap();
-
-        display.flush().unwrap();
-        Timer::after_millis(1000).await;
-    }
-}

src/bin/experiment_sh1106.rs

@@ -1,121 +0,0 @@
-#![no_std]
-#![no_main]
-#![deny(
-    clippy::mem_forget,
-    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
-    holding buffers for the duration of a data transfer."
-)]
-
-use embassy_executor::Spawner;
-use embassy_time::Timer;
-use embedded_graphics::pixelcolor::BinaryColor;
-use embedded_graphics::{
-    mono_font::{MonoTextStyle, ascii::FONT_6X10},
-    prelude::*,
-    text::Text,
-};
-use embedded_hal_compat::ReverseCompat;
-use esp_hal::clock::CpuClock;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig};
-use esp_hal::spi::Mode;
-use esp_hal::spi::master::{Config as SpiConfig, Spi};
-use esp_hal::time::Rate;
-use esp_hal::timer::timg::TimerGroup;
-use log::error;
-
-#[panic_handler]
-fn panic(panic_info: &core::panic::PanicInfo) -> ! {
-    error!("{}", panic_info);
-    loop {}
-}
-
-extern crate alloc;
-
-esp_bootloader_esp_idf::esp_app_desc!();
-
-// This creates a defaembedded_hal_compatedReverseCompat::reverse(Output::new(cs,Level::High,OutputConfig::default()))vel::High,OutputConfig::default())) more information see: embedded_hal_compat::ForwardCompat::forward(Spi::new(spi,SpiConfig::default().with_frequency(Rate::from_khz(100)).with_mode(Mode::_0),).unwrap().with_sck(sck).with_mosi(mosi))rward(Spi::new(spi,SpiConfig::default().with_frequency(Rate::from_khz(100)).with_mode(Mode::_0),).unwrap().with_sck(sck).with_mosi(mosi)) to allocate larger buffers etc. in main"
-#[esp_rtos::main]
-async fn main(_spawner: Spawner) {
-    esp_println::logger::init_logger_from_env();
-
-    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
-    let peripherals = esp_hal::init(config);
-
-    // The following GPIO pins are in use by some feature of the module and should not be used.
-    let _ = peripherals.GPIO27;
-    let _ = peripherals.GPIO28;
-    let _ = peripherals.GPIO29;
-    let _ = peripherals.GPIO30;
-    let _ = peripherals.GPIO31;
-    let _ = peripherals.GPIO32;
-    let _ = peripherals.GPIO33;
-    let _ = peripherals.GPIO34;
-
-    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: 73744);
-
-    let delay = Delay::new();
-
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
-    let sw_interrupt =
-        esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
-    esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
-
-    let spi = peripherals.SPI2;
-    let sck = peripherals.GPIO36;
-    let mosi = peripherals.GPIO35;
-    let cs = peripherals.GPIO13;
-    let reset = peripherals.GPIO10;
-    let dc = peripherals.GPIO12;
-    let miso = peripherals.GPIO37;
-
-    let cs = Output::new(cs, Level::High, OutputConfig::default()).reverse_cell();
-    let dc = Output::new(dc, Level::Low, OutputConfig::default()).reverse_cell();
-    let mut reset = Output::new(reset, Level::High, OutputConfig::default());
-
-    let spi = Spi::new(
-        spi,
-        SpiConfig::default()
-            .with_frequency(Rate::from_khz(5000))
-            .with_mode(Mode::_0),
-    )
-    .unwrap()
-    .with_sck(sck)
-    .with_mosi(mosi)
-    .with_miso(miso)
-    .reverse();
-
-    let mut display: sh1106::mode::GraphicsMode<_> =
-        sh1106::Builder::new().connect_spi(spi, dc, cs).into();
-
-    display.init().unwrap();
-
-    // Hard reset the OLED
-    reset.set_high();
-    delay.delay_millis(1);
-    reset.set_low();
-    delay.delay_millis(10);
-    reset.set_high();
-
-    display.flush().unwrap();
-
-    display.set_pixel(10, 20, 1);
-
-    display.flush().unwrap();
-
-    let mut oled = display;
-
-    oled.clear();
-
-    let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
-    Text::new("Hello OLED", Point::new(10, 20), text_style)
-        .draw(&mut oled)
-        .unwrap();
-
-    oled.flush().unwrap();
-
-    loop {
-        log::info!("Init finished");
-        Timer::after_millis(1000).await;
-    }
-}

src/bin/experiment_ssd1306.rs

@@ -1,122 +0,0 @@
-#![no_std]
-#![no_main]
-#![deny(
-    clippy::mem_forget,
-    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
-    holding buffers for the duration of a data transfer."
-)]
-#![deny(clippy::large_stack_frames)]
-
-use embassy_executor::Spawner;
-use embassy_time::Timer;
-use embedded_graphics::draw_target::DrawTarget;
-use embedded_graphics::pixelcolor::BinaryColor;
-use embedded_graphics::text::Text;
-use embedded_graphics::{
-    mono_font::{MonoTextStyle, ascii::FONT_6X10},
-    prelude::*,
-};
-
-use core::cell::RefCell;
-use esp_hal::clock::CpuClock;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig};
-use esp_hal::spi::Mode;
-use esp_hal::spi::master::{Config as SpiConfig, Spi};
-use esp_hal::time::Rate;
-use esp_hal::timer::timg::TimerGroup;
-use log::error;
-use ssd1306::Ssd1306;
-use ssd1306::mode::DisplayConfig;
-use ssd1306::rotation::DisplayRotation;
-use ssd1306::size::DisplaySize128x64;
-
-#[panic_handler]
-fn panic(panic_info: &core::panic::PanicInfo) -> ! {
-    error!("{}", panic_info);
-    loop {}
-}
-
-extern crate alloc;
-
-esp_bootloader_esp_idf::esp_app_desc!();
-
-// This creates a defaembedded_hal_compatedReverseCompat::reverse(Output::new(cs,Level::High,OutputConfig::default()))vel::High,OutputConfig::default())) more information see: embedded_hal_compat::ForwardCompat::forward(Spi::new(spi,SpiConfig::default().with_frequency(Rate::from_khz(100)).with_mode(Mode::_0),).unwrap().with_sck(sck).with_mosi(mosi))rward(Spi::new(spi,SpiConfig::default().with_frequency(Rate::from_khz(100)).with_mode(Mode::_0),).unwrap().with_sck(sck).with_mosi(mosi)) to allocate larger buffers etc. in main"
-#[esp_rtos::main]
-async fn main(_spawner: Spawner) {
-    esp_println::logger::init_logger_from_env();
-
-    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
-    let peripherals = esp_hal::init(config);
-
-    // The following GPIO pins are in use by some feature of the module and should not be used.
-    let _ = peripherals.GPIO27;
-    let _ = peripherals.GPIO28;
-    let _ = peripherals.GPIO29;
-    let _ = peripherals.GPIO30;
-    let _ = peripherals.GPIO31;
-    let _ = peripherals.GPIO32;
-    let _ = peripherals.GPIO33;
-    let _ = peripherals.GPIO34;
-
-    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: 73744);
-
-    let mut delay = Delay::new();
-
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
-    let sw_interrupt =
-        esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
-    esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
-
-    let spi = peripherals.SPI2;
-    let sck = peripherals.GPIO36;
-    let mosi = peripherals.GPIO35;
-    let cs = peripherals.GPIO13;
-    let reset = peripherals.GPIO10;
-    let dc = peripherals.GPIO12;
-    let miso = peripherals.GPIO37;
-
-    let cs = Output::new(cs, Level::High, OutputConfig::default());
-    let dc = Output::new(dc, Level::Low, OutputConfig::default());
-    let mut reset = Output::new(reset, Level::High, OutputConfig::default());
-
-    let spi = Spi::new(
-        spi,
-        SpiConfig::default()
-            .with_frequency(Rate::from_khz(5000))
-            .with_mode(Mode::_0),
-    )
-    .unwrap()
-    .with_sck(sck)
-    .with_mosi(mosi)
-    .with_miso(miso);
-
-    let spi = RefCell::new(spi);
-    let spi_dev = embedded_hal_bus::spi::RefCellDevice::new(&spi, cs, delay).unwrap();
-    let interface = display_interface_spi::SPIInterface::new(spi_dev, dc);
-    let mut display = Ssd1306::new(
-        interface,
-        DisplaySize128x64,
-        DisplayRotation::Rotate0,
-    )
-    .into_buffered_graphics_mode();
-
-    display.reset(&mut reset, &mut delay).unwrap();
-    display.init().unwrap();
-    display.clear(BinaryColor::Off).unwrap();
-
-
-    let mut oled = display;
-
-    let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
-    Text::new("Hello OLED", Point::new(10, 20), text_style)
-        .draw(&mut oled)
-        .unwrap();
-
-    oled.flush().unwrap();
-
-    loop {
-        log::info!("Init finished");
-        Timer::after_millis(1000).await;
-    }
-}

src/bin/main.rs

@@ -7,28 +7,23 @@
 )]
 #![deny(clippy::large_stack_frames)]
 
-use creaturedex::card::mock::{MOCK_PAYLOAD, MOCK_PAYLOAD2};
+use alloc::boxed::Box;
-use creaturedex::display::shared_bus::init_dual_displays;
+use creaturedex::card::decoder::split_nfc_hex;
-
+use creaturedex::card::model::Card;
-use creaturedex::display::views::card_view::render_nfc_payload;
+use creaturedex::display::primary_lcd::{PrimaryLcdDisplay, init_primary_lcd};
+use creaturedex::display::tertiary_lcd::{init_tertiary_lcd, write_wrapped};
 use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
-use creaturedex::navigation::input::init_navigation_button;
+use creaturedex::navigation::inputs::Inputs;
-use creaturedex::navigation::state::NavigationState;
+use creaturedex::navigation::navigation::{self, CARD_DATA};
 use creaturedex::network::wifi::setup_wifi;
 use embassy_executor::Spawner;
-use embassy_time::Timer;
+use embedded_hal_bus::i2c::AtomicDevice;
-use embedded_graphics::draw_target::DrawTarget;
+use embedded_hal_bus::util::AtomicCell;
-use embedded_graphics::pixelcolor::{BinaryColor, Rgb565};
+use esp_hal::Blocking;
-use embedded_graphics::prelude::RgbColor;
-use embedded_graphics::{
-    mono_font::{MonoTextStyle, ascii::FONT_6X10},
-    prelude::*,
-    text::Text,
-};
 use esp_hal::clock::CpuClock;
-use esp_hal::delay::Delay;
+use esp_hal::gpio::{Input, InputConfig, Pull};
-use esp_hal::time::Duration;
 use esp_hal::timer::timg::TimerGroup;
+use esp_hal::i2c::master::{Config as I2cConfig, I2c};
 use log::error;
 
 #[panic_handler]
@@ -39,6 +34,8 @@ fn panic(panic_info: &core::panic::PanicInfo) -> ! {
 
 extern crate alloc;
 
+const HEAP_SIZE: usize = 73744;
+
 // 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!();
@@ -54,64 +51,82 @@ async fn main(spawner: Spawner) {
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
     let peripherals = esp_hal::init(config);
 
-    // The following GPIO pins are in use by some feature of the module and should not be used.
+    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: HEAP_SIZE);
-    let _ = peripherals.GPIO27;
-    let _ = peripherals.GPIO28;
-    let _ = peripherals.GPIO29;
-    let _ = peripherals.GPIO30;
-    let _ = peripherals.GPIO31;
-    let _ = peripherals.GPIO32;
-    let _ = peripherals.GPIO33;
-    let _ = peripherals.GPIO34;
 
-    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: 73744);
-
-    let mut delay = Delay::new();
-    let button1 = init_navigation_button(peripherals.GPIO38);
-
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
     let sw_interrupt =
         esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
 
-    let (mut display, mut oled) = init_dual_displays(
+    let display: &mut PrimaryLcdDisplay = Box::leak(Box::new(init_primary_lcd(
         peripherals.SPI2,
         peripherals.GPIO36, // sck
         peripherals.GPIO35, // mosi
         peripherals.GPIO37, // miso
         peripherals.GPIO11, // primary cs
-        peripherals.GPIO13, // oled cs
         peripherals.GPIO10, // shared reset
         peripherals.GPIO12, // shared dc
-        &mut delay,
+    )));
-    );
 
-    setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
+    let config = I2cConfig::default().with_frequency(esp_hal::time::Rate::from_khz(20));
+    let i2c = match I2c::new(peripherals.I2C0, config) {
+        Ok(bus) => bus.with_sda(peripherals.GPIO17).with_scl(peripherals.GPIO18),
+        Err(e) => {
+            log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
+            panic!("Shared I2C bus initialization failed");
+        }
+    };
+    let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
+    log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
 
-    let mut nav_state = NavigationState::new();
+    let mut lcd = init_tertiary_lcd(AtomicDevice::new(shared_i2c));
-
+    if let Err(_) = write_wrapped(&mut lcd, "Testing more than 16 chars what happens now?") {
-    oled.clear(BinaryColor::Off).unwrap();
+        log::error!("Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses");
-
-    let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
-    Text::new("Hello OLED", Point::new(10, 20), text_style)
-        .draw(&mut oled)
-        .unwrap();
-    oled.flush().unwrap();
-
-    let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
-    display.clear_screen(0).unwrap();
-    Text::new("Hello OLED", Point::new(10, 20), text_style).draw(&mut display).unwrap();
-
-    let mut nfc_driver =
-        NfcPn532Driver::new(peripherals.I2C0, peripherals.GPIO17, peripherals.GPIO18);
-    let timeout = Duration::from_millis(1000);
-    if nfc_driver.configure_sam(timeout).is_ok() {
-        log::info!("NFC SAM configuration successful");
-    } else {
-        log::error!("NFC SAM configuration failed");
     }
 
+    // setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
+
+    let mut nfc_driver = NfcPn532Driver::new(AtomicDevice::new(shared_i2c));
+    if nfc_driver.configure_sam().await.is_ok() {
+        log::info!("NFC SAM configuration successful on the shared I2C bus");
+    } else {
+        log::error!("NFC SAM configuration failed on the shared I2C bus");
+    }
+
+    let button_config = InputConfig::default().with_pull(Pull::Up);
+    let inputs = Inputs {
+        up: Input::new(peripherals.GPIO38, button_config),
+        down: Input::new(peripherals.GPIO39, button_config),
+        left: Input::new(peripherals.GPIO40, button_config),
+        right: Input::new(peripherals.GPIO41, button_config),
+        back: Input::new(peripherals.GPIO42, button_config),
+        ok: Input::new(peripherals.GPIO45, button_config),
+    };
+
+    log::info!("Setup complete, entering main loop");
+    spawner.spawn(navigation::run(inputs, display).expect("run task failed"));
+    spawner.spawn(nfc_driver_task(nfc_driver).expect("nfc driver task failed"));
+}
+
+
+#[embassy_executor::task]
+async fn nfc_driver_task(mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>) {
     loop {
-        Timer::after_millis(10).await;
+        while CARD_DATA.lock().await.is_none() {
+            match nfc_driver.read_card_data().await {
+                Ok(card_data) => {
+                    log::info!("NFC Card Data Read: {:?}", card_data);
+                    let Some(split_data) = split_nfc_hex(&card_data) else {
+                        log::error!("Failed to split NFC card data");
+                        continue;
+                    };
+                    CARD_DATA.lock().await.replace(Card::try_from(split_data).unwrap());
+                }
+                Err(_) => {
+                    log::info!("No NFC card found");
+                }
+            }
+        }
+        embassy_time::Timer::after(embassy_time::Duration::from_millis(1000)).await;
     }
 }

src/card/decoder.rs

@@ -1,5 +1,7 @@
-use alloc::string::{String, ToString};
+use core::fmt::Display;
+
 use crate::card::model::NfcPayload;
+use alloc::string::{String, ToString};
 
 pub fn split_nfc_hex(payload: &[u8]) -> Option<NfcPayload<'_>> {
     if payload.len() < 0x35A {
@@ -18,13 +20,34 @@ pub fn split_nfc_hex(payload: &[u8]) -> Option<NfcPayload<'_>> {
     })
 }
 
-pub fn decode_known_event(event_encoding: &[u8]) -> Option<&'static str> {
+#[derive(Debug, Clone)]
+pub enum Events {
+    CCC39,
+    CCC40,
+    GPN24,
+    GPN25,
+    Unknown,
+}
+
+impl Display for Events {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            Events::CCC39 => write!(f, "39C3"),
+            Events::CCC40 => write!(f, "40C3"),
+            Events::GPN24 => write!(f, "GPN24"),
+            Events::GPN25 => write!(f, "GPN25"),
+            Events::Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
+pub fn decode_known_event(event_encoding: &[u8]) -> Events {
     match event_encoding {
-        [0x39, 0xC3] => Some("39C3"),
+        [0x39, 0xC3] => Events::CCC39,
-        [0x40, 0xC3] => Some("40C3"), // future proofing :)
+        [0x40, 0xC3] => Events::CCC40, // future proofing :)
-        [0xE9, 0x24] => Some("GPN 24"),
+        [0xE9, 0x24] => Events::GPN24,
-        [0xE9, 0x25] => Some("GPN 25"), // future proofing :)
+        [0xE9, 0x25] => Events::GPN25, // future proofing :)
-        _ => None,
+        _ => Events::Unknown,
     }
 }
 

src/card/mock.rs

@@ -1,4 +1,4 @@
-/// Mock payload 2 acting as simulated NFC card read
+/// GlaDos
 pub const MOCK_PAYLOAD2: [u8; 858] = [
     0xE9, 0x24, 0x03, 0xDA, 0x45, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0A, 0xAA, 0xA0, 0xF0, 0xAA, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
@@ -56,7 +56,7 @@ pub const MOCK_PAYLOAD2: [u8; 858] = [
     0x95, 0x2D, 0x14, 0xBD, 0x43, 0xB2, 0x40, 0x76, 0x78, 0x00,
 ];
 
-/// Mock payload 1 acting as simulated NFC card read
+/// Blue Portal
 pub const MOCK_PAYLOAD: [u8; 858] = [
     0xE9, 0x24, 0x01, 0x47, 0xF2, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
@@ -113,3 +113,61 @@ pub const MOCK_PAYLOAD: [u8; 858] = [
     0x03, 0x63, 0x8F, 0x4C, 0x2F, 0xBA, 0xCC, 0x17, 0x23, 0x51, 0x60, 0x27, 0x3B, 0x00, 0x1C, 0x6D,
     0x1F, 0x8C, 0x6B, 0x3E, 0x32, 0xE2, 0x53, 0xD9, 0x8F, 0x00,
 ];
+
+/// Orange Portal
+pub const MOCK_PAYLOAD3: [u8; 858] = [
+    0xE9, 0x24, 0x01, 0x0A, 0x4B, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0x55, 0x55, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0x55, 0x55, 0x55, 0x5F, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0x55, 0xFF, 0xFF, 0x55, 0x55, 0xF5, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x5F, 0xFF, 0xFF, 0xFF, 0xF5,
+    0x55, 0x5F, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x50, 0x00,
+    0xFF, 0xFF, 0xF5, 0x55, 0x55, 0xF5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0x55, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xF5, 0x55, 0xF5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0x55, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0x50, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xF5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF5, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xF5, 0xFF, 0xFF,
+    0xFF, 0x0F, 0xFF, 0xF5, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55,
+    0xF5, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xF5, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xF5, 0x55, 0xFF, 0x50, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xF5, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xFF, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xF5, 0x5F, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0xFF, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF,
+    0xF5, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0xF0, 0x00, 0x00, 0x00,
+    0x0F, 0xFF, 0xFF, 0xF5, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0xF0,
+    0x0F, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0x50, 0x00, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF,
+    0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0xFF, 0xFF, 0xFF, 0xF0, 0x0F,
+    0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x55, 0xFF, 0xFF,
+    0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF5, 0x55, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0xFF, 0xFF, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0x55,
+    0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x55, 0x5F, 0xFF, 0x00, 0x0F, 0xFF,
+    0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0x50, 0x00,
+    0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF5, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x55, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5, 0xFF, 0x55, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xF5,
+    0xFF, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x05, 0x5F,
+    0xFF, 0xF5, 0x5F, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xF0, 0x00, 0x55, 0x55, 0x55, 0xF5, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x55, 0x5F, 0xFF, 0x55, 0x55, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0x55, 0x55, 0x55, 0x5F, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x05, 0x55, 0x55, 0x55, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xBB, 0xA1, 0xE1, 0x07,
+    0x40, 0x29, 0xEB, 0x6E, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD3, 0xD7, 0xA5,
+    0xA8, 0xB7, 0xB1, 0x33, 0x00, 0xA5, 0xAC, 0xBB, 0x99, 0xD1, 0xBB, 0xA1, 0xEE, 0x7B, 0x02, 0xCC,
+    0x88, 0x96, 0x9F, 0x07, 0x00, 0x86, 0x39, 0xA2, 0x61, 0x0B, 0x4C, 0x2F, 0x47, 0x7E, 0x9D, 0x0B,
+    0x00, 0x53, 0x70, 0x65, 0x65, 0x64, 0x79, 0x20, 0x74, 0x68, 0x69, 0x6E, 0x67, 0x20, 0x63, 0x6F,
+    0x6D, 0x65, 0x73, 0x20, 0x6F, 0x75, 0x74, 0x00, 0x00, 0x74, 0xEE, 0xAF, 0x55, 0x52, 0x98, 0x43,
+    0x71, 0xC1, 0x71, 0xDB, 0xBC, 0xAD, 0x32, 0x89, 0x8A, 0x60, 0x82, 0x68, 0x28, 0x48, 0xBD, 0x2B,
+    0x3F, 0x48, 0x49, 0x65, 0x78, 0x88, 0xA8, 0x10, 0x39, 0x5A, 0x77, 0x64, 0xBB, 0x4F, 0x7E, 0x6F,
+    0xC3, 0xBD, 0x28, 0x43, 0xC4, 0x24, 0xB0, 0xF3, 0x2D, 0x00,
+];

src/card/model.rs

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

src/display.rs

@@ -1,8 +1,4 @@
-pub mod palette;
 pub mod primary_lcd;
 pub mod secondary_oled;
-pub mod shared_bus;
 pub mod sprite;
 pub mod tertiary_lcd;
-pub mod views;
-

src/display/palette.rs

@@ -1,215 +0,0 @@
-use embedded_graphics::pixelcolor::Rgb565;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Rgb(pub u8, pub u8, pub u8);
-
-impl Rgb {
-    pub fn into_rgb565(self) -> Rgb565 {
-        Rgb565::new(self.0, self.1, self.2)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct TypeStyle {
-    pub name: &'static str,
-    pub primary: Rgb,
-    pub text: Rgb,
-}
-
-pub const PALETTES: [[Rgb; 16]; 8] = [
-    // Palette Default
-    [
-        Rgb(31, 23, 35),
-        Rgb(60, 47, 82),
-        Rgb(178, 39, 65),
-        Rgb(70, 86, 165),
-        Rgb(245, 70, 76),
-        Rgb(216, 104, 48),
-        Rgb(140, 127, 144),
-        Rgb(73, 149, 243),
-        Rgb(62, 197, 75),
-        Rgb(240, 149, 72),
-        Rgb(188, 176, 179),
-        Rgb(247, 156, 136),
-        Rgb(114, 222, 235),
-        Rgb(180, 230, 86),
-        Rgb(239, 208, 129),
-        Rgb(255, 255, 255),
-    ],
-    // Palette Blueprint
-    [
-        Rgb(83, 67, 127),
-        Rgb(44, 111, 153),
-        Rgb(142, 88, 111),
-        Rgb(0, 188, 170),
-        Rgb(153, 104, 226),
-        Rgb(109, 129, 255),
-        Rgb(255, 84, 112),
-        Rgb(196, 143, 158),
-        Rgb(168, 159, 204),
-        Rgb(190, 155, 255),
-        Rgb(255, 155, 113),
-        Rgb(127, 206, 255),
-        Rgb(255, 155, 182),
-        Rgb(255, 217, 174),
-        Rgb(255, 217, 232),
-        Rgb(255, 255, 255),
-    ],
-    // Palette CYBER
-    [
-        Rgb(0, 0, 0),
-        Rgb(0, 0, 126),
-        Rgb(0, 0, 255),
-        Rgb(126, 0, 0),
-        Rgb(126, 0, 126),
-        Rgb(4, 126, 0),
-        Rgb(254, 0, 0),
-        Rgb(4, 126, 126),
-        Rgb(254, 0, 255),
-        Rgb(126, 126, 0),
-        Rgb(126, 126, 126),
-        Rgb(6, 255, 4),
-        Rgb(6, 255, 255),
-        Rgb(190, 190, 190),
-        Rgb(255, 255, 4),
-        Rgb(255, 255, 255),
-    ],
-    // Palette Nature
-    [
-        Rgb(35, 34, 40),
-        Rgb(40, 66, 97),
-        Rgb(30, 116, 83),
-        Rgb(117, 77, 69),
-        Rgb(95, 88, 84),
-        Rgb(36, 133, 166),
-        Rgb(198, 80, 70),
-        Rgb(85, 160, 88),
-        Rgb(135, 133, 115),
-        Rgb(84, 186, 210),
-        Rgb(161, 191, 65),
-        Rgb(230, 146, 138),
-        Rgb(184, 176, 149),
-        Rgb(227, 192, 84),
-        Rgb(195, 213, 199),
-        Rgb(255, 255, 255),
-    ],
-    // Palette Fossil
-    [
-        Rgb(75, 61, 68),
-        Rgb(119, 66, 81),
-        Rgb(78, 84, 99),
-        Rgb(100, 83, 85),
-        Rgb(156, 82, 78),
-        Rgb(132, 109, 89),
-        Rgb(91, 125, 115),
-        Rgb(125, 123, 98),
-        Rgb(140, 124, 121),
-        Rgb(185, 122, 96),
-        Rgb(168, 138, 94),
-        Rgb(142, 159, 125),
-        Rgb(170, 162, 93),
-        Rgb(169, 156, 141),
-        Rgb(204, 168, 123),
-        Rgb(255, 255, 255),
-    ],
-    // Palette Ghost
-    [
-        Rgb(0, 0, 0),
-        Rgb(24, 24, 24),
-        Rgb(40, 40, 40),
-        Rgb(56, 56, 56),
-        Rgb(71, 71, 71),
-        Rgb(86, 86, 86),
-        Rgb(100, 100, 100),
-        Rgb(113, 113, 113),
-        Rgb(126, 126, 126),
-        Rgb(140, 140, 140),
-        Rgb(155, 155, 155),
-        Rgb(171, 171, 171),
-        Rgb(189, 189, 189),
-        Rgb(209, 209, 209),
-        Rgb(231, 231, 231),
-        Rgb(255, 255, 255),
-    ],
-    // Palette Daemon
-    [
-        Rgb(0, 3, 60),
-        Rgb(96, 0, 136),
-        Rgb(0, 56, 132),
-        Rgb(42, 46, 121),
-        Rgb(0, 82, 96),
-        Rgb(177, 5, 133),
-        Rgb(255, 0, 78),
-        Rgb(172, 41, 206),
-        Rgb(0, 157, 74),
-        Rgb(0, 138, 197),
-        Rgb(78, 110, 168),
-        Rgb(255, 92, 255),
-        Rgb(10, 255, 82),
-        Rgb(0, 247, 255),
-        Rgb(173, 212, 250),
-        Rgb(255, 255, 255),
-    ],
-    // Palette Fairy
-    [
-        Rgb(40, 40, 46),
-        Rgb(108, 86, 113),
-        Rgb(135, 168, 137),
-        Rgb(249, 130, 132),
-        Rgb(176, 169, 228),
-        Rgb(222, 163, 139),
-        Rgb(172, 204, 228),
-        Rgb(254, 170, 228),
-        Rgb(217, 200, 191),
-        Rgb(255, 195, 132),
-        Rgb(176, 235, 147),
-        Rgb(179, 227, 218),
-        Rgb(233, 245, 157),
-        Rgb(255, 230, 198),
-        Rgb(255, 247, 160),
-        Rgb(255, 255, 255),
-    ],
-];
-
-pub const TYPE_STYLES: [TypeStyle; 8] = [
-    TypeStyle {
-        name: "Default",
-        primary: Rgb(0xD8, 0x68, 0x30),
-        text: Rgb(0xFF, 0xFF, 0xFF),
-    },
-    TypeStyle {
-        name: "Blueprint",
-        primary: Rgb(0x6D, 0x81, 0xFF),
-        text: Rgb(0xFF, 0xFF, 0xFF),
-    },
-    TypeStyle {
-        name: "CYBER",
-        primary: Rgb(0xFF, 0xFF, 0x04),
-        text: Rgb(0x00, 0x00, 0x00),
-    },
-    TypeStyle {
-        name: "Nature",
-        primary: Rgb(0x55, 0xA0, 0x58),
-        text: Rgb(0xFF, 0xFF, 0xFF),
-    },
-    TypeStyle {
-        name: "Fossil",
-        primary: Rgb(0xB9, 0x7A, 0x60),
-        text: Rgb(0xFF, 0xFF, 0xFF),
-    },
-    TypeStyle {
-        name: "Ghost",
-        primary: Rgb(0xAB, 0xAB, 0xAB),
-        text: Rgb(0xFF, 0xFF, 0xFF),
-    },
-    TypeStyle {
-        name: "Daemon",
-        primary: Rgb(0x60, 0x00, 0x88),
-        text: Rgb(0xFF, 0xFF, 0xFF),
-    },
-    TypeStyle {
-        name: "Fairy",
-        primary: Rgb(0xB0, 0xA9, 0xE4),
-        text: Rgb(0xFF, 0xFF, 0xFF),
-    },
-];

src/display/primary_lcd.rs

@@ -1,43 +1,56 @@
-use core::cell::RefCell;
 use display_interface_spi::SPIInterface;
 use embedded_graphics::draw_target::DrawTarget;
 use embedded_graphics::pixelcolor::Rgb565;
 use embedded_graphics::prelude::RgbColor;
-use embedded_hal::digital::OutputPin as EhOutputPin;
+use embedded_hal_bus::spi::ExclusiveDevice;
-use embedded_hal_bus::spi::RefCellDevice;
 use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
+use esp_hal::gpio::{Level, Output, OutputConfig};
+use esp_hal::peripherals::{GPIO10, GPIO11, GPIO12, GPIO35, GPIO36, GPIO37, SPI2};
+use esp_hal::spi::{
+    Mode,
+    master::{Config, Spi},
+};
+use esp_hal::time::Rate;
 use ili9341::{DisplaySize240x320, Ili9341, Orientation};
 
-pub type PrimaryLcdDisplay<'a, BUS, DC, RES> = Ili9341<
+pub type PrimaryLcdDisplay<'a> = Ili9341<
-    SPIInterface<
+    SPIInterface<ExclusiveDevice<Spi<'a, esp_hal::Blocking>, Output<'a>, Delay>, Output<'a>>,
-        RefCellDevice<'a, BUS, Output<'a>, Delay>,
+    Output<'a>,
-        DC,
-    >,
-    RES,
 >;
 
-pub fn init_primary_lcd_on_bus<'a, BUS, CS, RES, DC>(
+pub fn init_primary_lcd(
-    spi_bus: &'a RefCell<BUS>,
+    spi2: SPI2<'static>,
-    cs: CS,
+    sck: GPIO36<'static>,
-    reset: RES,
+    mosi: GPIO35<'static>,
-    dc: DC,
+    miso: GPIO37<'static>,
-    delay: &mut Delay,
+    cs: GPIO11<'static>,
-) -> PrimaryLcdDisplay<'a, BUS, DC, RES>
+    reset: GPIO10<'static>,
-where
+    dc: GPIO12<'static>,
-    BUS: embedded_hal::spi::SpiBus,
+) -> PrimaryLcdDisplay<'static> {
-    CS: OutputPin + 'static,
+    let freq = Rate::from_khz(60_000);
-    RES: EhOutputPin,
+    log::info!("Display freq: {freq}");
-    DC: EhOutputPin,
+
-{
+    let spi_bus = Spi::new(
-    let cs_pin = Output::new(cs, Level::High, OutputConfig::default());
+        spi2,
-    let spi_dev = RefCellDevice::new(spi_bus, cs_pin, *delay).unwrap();
+        Config::default().with_frequency(freq).with_mode(Mode::_0),
-    let iface = SPIInterface::new(spi_dev, dc);
+    )
+    .unwrap()
+    .with_sck(sck)
+    .with_mosi(mosi)
+    .with_miso(miso);
+
+    let mut delay = Delay::new();
+
+    let cs_main = Output::new(cs, Level::High, OutputConfig::default());
+    let spi_dev = ExclusiveDevice::new(spi_bus, cs_main, delay).unwrap();
+    let reset_main = Output::new(reset, Level::High, OutputConfig::default());
+    let spi_dc = Output::new(dc, Level::High, OutputConfig::default());
+    let iface = SPIInterface::new(spi_dev, spi_dc);
 
     let mut display = Ili9341::new(
         iface,
-        reset,
+        reset_main,
-        delay,
+        &mut delay,
         Orientation::Portrait,
         DisplaySize240x320,
     )
@@ -46,5 +59,3 @@ where
     display.clear(Rgb565::BLACK).unwrap();
     display
 }
-
-

src/display/secondary_oled.rs

@@ -1,54 +1 @@
-use core::cell::RefCell;
+// Secondary OLED module
-use display_interface_spi::SPIInterface;
-use embedded_graphics::pixelcolor::BinaryColor;
-use embedded_graphics::prelude::*;
-use embedded_hal::digital::OutputPin as EhOutputPin;
-use embedded_hal_bus::spi::RefCellDevice;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
-use ssd1306::mode::BufferedGraphicsMode;
-use ssd1306::prelude::*;
-use ssd1306::Ssd1306;
-
-pub type SecondaryOledDisplay<'a, BUS, DC> = Ssd1306<
-    SPIInterface<
-        RefCellDevice<'a, BUS, Output<'a>, Delay>,
-        DC,
-    >,
-    DisplaySize128x64,
-    BufferedGraphicsMode<DisplaySize128x64>,
->;
-
-pub fn init_secondary_oled_on_bus<'a, BUS, CS, RES, DC>(
-    spi_bus: &'a RefCell<BUS>,
-    cs: CS,
-    mut res: RES,
-    dc: DC,
-    delay: &mut Delay,
-) -> SecondaryOledDisplay<'a, BUS, DC>
-where
-    BUS: embedded_hal::spi::SpiBus,
-    CS: OutputPin + 'static,
-    RES: EhOutputPin,
-    DC: EhOutputPin,
-{
-    let cs_pin = Output::new(cs, Level::High, OutputConfig::default());
-    let spi_dev = RefCellDevice::new(spi_bus, cs_pin, *delay).unwrap();
-    let interface = SPIInterface::new(spi_dev, dc);
-
-    let mut display = Ssd1306::new(
-        interface,
-        DisplaySize128x64,
-        DisplayRotation::Rotate0,
-    )
-    .into_buffered_graphics_mode();
-
-    display.reset(&mut res, delay).unwrap();
-    display.init().unwrap();
-    display.clear(BinaryColor::Off).unwrap();
-    display.flush().unwrap();
-
-    display
-}
-
-

src/display/shared_bus.rs

@@ -1,98 +0,0 @@
-use alloc::boxed::Box;
-use core::cell::RefCell;
-use embedded_hal::digital::{ErrorType, OutputPin as EhOutputPin, PinState};
-use esp_hal::delay::Delay;
-use esp_hal::gpio::interconnect::{PeripheralInput, PeripheralOutput};
-use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
-use esp_hal::spi::master::{Config as SpiConfig, Spi};
-use esp_hal::spi::Mode;
-use esp_hal::time::Rate;
-use crate::display::primary_lcd::{init_primary_lcd_on_bus, PrimaryLcdDisplay};
-
-use crate::display::secondary_oled::{init_secondary_oled_on_bus, SecondaryOledDisplay};
-
-pub struct SharedPin<'a>(pub &'a RefCell<Output<'static>>);
-
-impl<'a> ErrorType for SharedPin<'a> {
-    type Error = core::convert::Infallible;
-}
-
-impl<'a> EhOutputPin for SharedPin<'a> {
-    fn set_low(&mut self) -> Result<(), Self::Error> {
-        self.0.borrow_mut().set_low();
-        Ok(())
-    }
-
-    fn set_high(&mut self) -> Result<(), Self::Error> {
-        self.0.borrow_mut().set_high();
-        Ok(())
-    }
-
-    fn set_state(&mut self, state: PinState) -> Result<(), Self::Error> {
-        self.0.borrow_mut().set_state(state);
-        Ok(())
-    }
-}
-
-pub type DisplaySpiBus = Spi<'static, esp_hal::Blocking>;
-pub type DualPrimaryDisplay<'a> = PrimaryLcdDisplay<'a, DisplaySpiBus, SharedPin<'a>, SharedPin<'a>>;
-pub type DualSecondaryDisplay<'a> = SecondaryOledDisplay<'a, DisplaySpiBus, SharedPin<'a>>;
-
-pub fn init_dual_displays<SPI, SCK, MOSI, MISO, CS1, CS2, RES, DC>(
-    spi_peripheral: SPI,
-    sck: SCK,
-    mosi: MOSI,
-    miso: MISO,
-    cs_primary: CS1,
-    cs_secondary: CS2,
-    reset_pin: RES,
-    dc_pin: DC,
-    delay: &mut Delay,
-) -> (DualPrimaryDisplay<'static>, DualSecondaryDisplay<'static>)
-
-where
-    SPI: esp_hal::spi::master::Instance + 'static,
-    SCK: PeripheralOutput<'static>,
-    MOSI: PeripheralOutput<'static>,
-    MISO: PeripheralInput<'static>,
-    CS1: OutputPin + 'static,
-    CS2: OutputPin + 'static,
-    RES: OutputPin + 'static,
-    DC: OutputPin + 'static,
-{
-    let spi = Spi::new(
-        spi_peripheral,
-        SpiConfig::default().with_frequency(Rate::from_khz(20_000)).with_mode(Mode::_0),
-    )
-    .unwrap()
-    .with_sck(sck)
-    .with_mosi(mosi)
-    .with_miso(miso);
-
-    let bus_static: &'static RefCell<DisplaySpiBus> = Box::leak(Box::new(RefCell::new(spi)));
-    let reset_static: &'static RefCell<Output<'static>> = Box::leak(Box::new(RefCell::new(
-        Output::new(reset_pin, Level::High, OutputConfig::default()),
-    )));
-    let dc_static: &'static RefCell<Output<'static>> = Box::leak(Box::new(RefCell::new(
-        Output::new(dc_pin, Level::High, OutputConfig::default()),
-    )));
-
-    let primary = init_primary_lcd_on_bus(
-        bus_static,
-        cs_primary,
-        SharedPin(reset_static),
-        SharedPin(dc_static),
-        delay,
-    );
-
-    let secondary = init_secondary_oled_on_bus(
-        bus_static,
-        cs_secondary,
-        SharedPin(reset_static),
-        SharedPin(dc_static),
-        delay,
-    );
-
-    (primary, secondary)
-}
-

src/display/sprite.rs

@@ -1,8 +1,10 @@
-use embedded_graphics::{geometry::Size, pixelcolor::Rgb565, primitives::Rectangle, prelude::Point};
+use crate::card::model::Palette;
+use embedded_graphics::{
+    geometry::Size, pixelcolor::Rgb565, prelude::Point, primitives::Rectangle,
+};
 use embedded_graphics_core::draw_target::DrawTarget;
-use crate::display::palette::Rgb;
 
-pub fn render_sprite_onto_ili9341<D>(ili9341: &mut D, sprite: &[u8], palette: &[Rgb; 16])
+pub fn render_sprite_onto_ili9341<D>(ili9341: &mut D, sprite: &[u8], palette: &Palette)
 where
     D: DrawTarget<Color = Rgb565>,
 {
@@ -11,11 +13,6 @@ where
         return;
     }
 
-    // OPTIMIZATION 1: Pre-compute the 16-color palette to Rgb565 once.
-    let mut palette565 = [Rgb565::new(0, 0, 0); 16];
-    for (i, Rgb(r, g, b)) in palette.iter().enumerate() {
-        palette565[i] = Rgb565::new(*r >> 3, *g >> 2, *b >> 3);
-    }
 
     let mut src_width = 1usize;
     while src_width * src_width < pixel_count {
@@ -41,7 +38,7 @@ where
                 pixel_byte & 0x0F
             };
 
-            let color = palette565[color_index as usize];
+            let color = palette[color_index as usize];
 
             let start_x = (x * scale) as i32;
             let start_y = (y * scale) as i32;

src/display/tertiary_lcd.rs

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

src/display/views.rs

@@ -1,3 +0,0 @@
-pub mod card_view;
-pub mod menu_view;
-pub mod status_bar;

src/display/views/card_view.rs

@@ -1,98 +0,0 @@
-use alloc::{format, string::String};
-use embedded_graphics::mono_font::MonoTextStyle;
-use embedded_graphics::mono_font::ascii::FONT_6X10;
-use embedded_graphics::pixelcolor::Rgb565;
-use embedded_graphics::prelude::Point;
-use embedded_graphics::prelude::RgbColor;
-use embedded_graphics::text::Text;
-use embedded_graphics::{Drawable, geometry::Size, primitives::Rectangle};
-use embedded_graphics_core::draw_target::DrawTarget;
-use crate::card::decoder::{decode_known_event, decode_packed_card_text, decode_secret, split_nfc_hex};
-use crate::card::model::NfcPayload;
-use crate::display::palette::{PALETTES, TYPE_STYLES};
-use crate::display::sprite::render_sprite_onto_ili9341;
-
-pub fn render_nfc_payload<D>(display: &mut D, payload: &[u8; 858])
-where
-    D: DrawTarget<Color = Rgb565>,
-    D::Error: core::fmt::Debug,
-{
-    let nfc_payload: Option<NfcPayload<'_>> = split_nfc_hex(payload);
-
-    if let Some(nfc_payload) = nfc_payload {
-        let (name, trait1, trait2, trait3) = decode_packed_card_text(nfc_payload.packed_card_text);
-        let secret = decode_secret(nfc_payload.secret);
-
-        let background = Rectangle::new(
-            Point::new(0, 0),
-            Size::new(240, 320),
-        );
-        let bg_color: Rgb565 = TYPE_STYLES[(nfc_payload.card_type - 1) as usize]
-            .primary
-            .into_rgb565();
-
-        let _ = display.fill_solid(&background, bg_color);
-
-        let style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
-        Text::new(&format!("Name: {}", name), Point::new(20, 240), style)
-            .draw(display)
-            .unwrap();
-        Text::new(
-            &format!(
-                "Type: {}",
-                TYPE_STYLES[(nfc_payload.card_type - 1) as usize].name
-            ),
-            Point::new(20, 250),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!(
-                "Event: {}",
-                decode_known_event(nfc_payload.event_encoding).unwrap_or("Unknown")
-            ),
-            Point::new(20, 260),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!(
-                "UUID: {}",
-                nfc_payload
-                    .card_uuid
-                    .iter()
-                    .map(|b| format!("{:02X}", b))
-                    .collect::<String>()
-            ),
-            Point::new(20, 270),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(&format!("Trait1: {}", trait1), Point::new(20, 280), style)
-            .draw(display)
-            .unwrap();
-        Text::new(&format!("Trait2: {}", trait2), Point::new(20, 290), style)
-            .draw(display)
-            .unwrap();
-        Text::new(&format!("Trait3: {}", trait3), Point::new(20, 300), style)
-            .draw(display)
-            .unwrap();
-        Text::new(&format!("Secret: {}", secret), Point::new(20, 310), style)
-            .draw(display)
-            .unwrap();
-
-        render_sprite_onto_ili9341(
-            display,
-            nfc_payload.sprite,
-            &PALETTES[(nfc_payload.card_type - 1) as usize],
-        );
-    } else {
-        log::error!(
-            "NFC payload too short to decode packed text: {} bytes",
-            payload.len()
-        );
-    }
-}

src/display/views/menu_view.rs

@@ -1 +0,0 @@
-// Menu view module

src/drivers/nfc_pn532.rs

@@ -1,9 +1,7 @@
 use alloc::vec::Vec;
 use core::convert::Infallible;
-use esp_hal::gpio::interconnect::{PeripheralInput, PeripheralOutput};
+use embedded_hal::i2c::I2c;
-use esp_hal::i2c::master::{Config as I2cConfig, I2c};
+use esp_hal::time::{Duration, Instant};
-use esp_hal::peripherals::I2C0;
-use esp_hal::time::{Duration, Instant, Rate};
 use log::{error, info};
 use pn532::i2c::I2CInterface;
 use pn532::requests::SAMMode;
@@ -55,51 +53,46 @@ impl pn532::CountDown for TimerWrapper {
     }
 }
 
-pub type Pn532Device<'a> = Pn532<I2CInterface<I2c<'a, esp_hal::Blocking>>, TimerWrapper, 32>;
+pub type Pn532Device<I2C> = Pn532<I2CInterface<I2C>, (), 32>;
 
 /// PN532 NFC reader driver.
-pub struct NfcPn532Driver<'a> {
+pub struct NfcPn532Driver<I2C>
-    pn532: Pn532Device<'a>,
+where
+    I2C: I2c,
+{
+    pn532: Pn532Device<I2C>,
 }
 
-impl<'a> NfcPn532Driver<'a> {
+impl<I2C> NfcPn532Driver<I2C>
-    pub fn new<SDA, SCL>(i2c0: I2C0<'static>, sda: SDA, scl: SCL) -> Self
+where
-    where
+    I2C: I2c,
-        SDA: PeripheralInput<'static> + PeripheralOutput<'static>,
+{
-        SCL: PeripheralInput<'static> + PeripheralOutput<'static>,
+    pub fn new(i2c: I2C) -> Self {
-    {
+        let pn532 = Pn532::new_async(I2CInterface { i2c });
-        let config = I2cConfig::default().with_frequency(Rate::from_khz(20));
-        let i2c = I2c::new(i2c0, config)
-            .expect("Failed to init I2C")
-            .with_sda(sda)
-            .with_scl(scl);
-
-        let pn532 = Pn532::new(I2CInterface { i2c }, TimerWrapper::new());
         Self { pn532 }
     }
 
-    pub fn configure_sam(&mut self, timeout: Duration) -> Result<(), ()> {
+    pub async fn configure_sam(&mut self) -> Result<(), ()> {
-        if let Err(e) = self.pn532.process(
+        if let Err(e) = self.pn532.process_async(
             &Request::sam_configuration(SAMMode::Normal, false),
             0,
-            timeout,
+        ).await {
-        ) {
+            error!("PN532 SAM configuration failed over I2C: {e:?}");
-            error!("Could not initialize PN532: {e:?}");
             Err(())
         } else {
-            info!("Successfully init'ed PN532");
+            info!("PN532 SAM configuration successful on shared I2C bus");
             Ok(())
         }
     }
 
-    pub fn poll_target(&mut self, timeout: Duration) -> Result<(), ()> {
+    pub async fn poll_target(&mut self) -> Result<(), ()> {
-        match self.pn532.process(&Request::INLIST_ONE_ISO_A_TARGET, 23, timeout) {
+        match self.pn532.process_async(&Request::INLIST_ONE_ISO_A_TARGET, 23).await {
             Ok(uid) => {
-                info!("uid = {uid:?}");
+                info!("PN532 detected NFC target UID: {uid:?}");
                 Ok(())
             }
             Err(e) => {
-                info!("No NFC card found: {e:?}");
+                info!("No NFC card found on shared I2C bus: {e:?}");
                 Err(())
             }
         }
@@ -117,29 +110,36 @@ impl<'a> NfcPn532Driver<'a> {
         }
     }
 
-    pub fn read_card_data(&mut self) -> Result<Vec<u8>, ()> {
+    pub async fn read_card_data(&mut self) -> Result<Vec<u8>, ()> {
-        let ms_1000 = Duration::from_millis(1000);
+        if let Err(e) = self.poll_target().await {
-        self.poll_target(Duration::from_secs(10))?;
+            error!("PN532 I2C target poll failed before reading card data: {e:?}");
+            return Err(e);
+        }
 
         let mut data: Vec<u8> = Vec::with_capacity(858);
 
-        for i in 0x04..=230 {
+        for i in 0x0B..=230 {
             let mut parse_result = Err(());
             while parse_result.is_err() {
-                let Ok(result) = self.pn532.process(&Request::ntag_read(i), 17, ms_1000) else {
+                let Ok(result) = self.pn532.process_async(&Request::ntag_read(i), 17).await else {
                     continue;
                 };
                 parse_result = Self::parse_nfc_page(i, result);
             }
             let bytes = parse_result.unwrap();
+            let bytes = if i == 0x0B {
+                &bytes[1..]
+            } else {
+                &bytes
+            };
             data.extend(bytes);
         }
 
-        info!("Full data: {data:02x?}");
+        info!("PN532 full card payload read over I2C: {:02x?}", data);
         Ok(data)
     }
     
-    pub fn device_mut(&mut self) -> &mut Pn532Device<'a> {
+    pub fn device_mut(&mut self) -> &mut Pn532Device<I2C> {
         &mut self.pn532
     }
 }

src/lib.rs

@@ -8,3 +8,4 @@ pub mod drivers;
 pub mod navigation;
 pub mod network;
 pub mod storage;
+pub mod views;

src/navigation.rs

@@ -1,2 +1,3 @@
-pub mod input;
+pub mod inputs;
+pub mod navigation;
 pub mod state;

src/navigation/input.rs

@@ -1,15 +0,0 @@
-use esp_hal::gpio::{Input, InputConfig, Pull};
-use esp_hal::peripherals::GPIO38;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum NavCommand {
-    NextCard,
-    PrevCard,
-    Select,
-    ScanTag,
-}
-
-pub fn init_navigation_button(pin: GPIO38<'static>) -> Input<'static> {
-    let button_config = InputConfig::default().with_pull(Pull::Up);
-    Input::new(pin, button_config)
-}

src/navigation/inputs.rs

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

src/navigation/navigation.rs

@@ -0,0 +1,92 @@
+use crate::card::model::Card;
+use crate::navigation::inputs::ButtonAction;
+use crate::navigation::state::NavigationState;
+use crate::views::view::View;
+use crate::{display::primary_lcd::PrimaryLcdDisplay, navigation::inputs::Inputs};
+
+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;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Action {
+    Button(ButtonAction),
+    Timer,
+}
+
+pub struct NewState {
+    pub view: View,
+    pub replace_view: bool,
+    pub redraw: bool,
+}
+
+pub trait Navigable {
+    fn display(
+        &self,
+        display: &mut PrimaryLcdDisplay<'static>,
+    ) -> impl core::future::Future<Output = ()> + Send;
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send;
+}
+
+#[embassy_executor::task]
+pub async fn run(mut inputs: Inputs, display: &'static mut PrimaryLcdDisplay<'static>) {
+    log::info!("starting navigation");
+
+    let mut state = NavigationState::new();
+    state.screens.last().unwrap().display(display).await;
+
+    loop {
+        let selection = select(
+            inputs.wait_for_press(),
+            Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)),
+        )
+        .await;
+
+        let action = match selection {
+            Either::First(button) => Action::Button(button),
+            Either::Second(_) => Action::Timer,
+        };
+
+        if Action::Timer != action {
+            log::info!("Action: {:?}", action);
+        }
+
+        let new_state = if action == Action::Button(ButtonAction::Back) {
+            if state.screens.len() > 1 {
+                state.screens.pop();
+            }
+            NewState {
+                view: state.screens.last().expect("no screen on stack").clone(),
+                replace_view: false,
+                redraw: true,
+            }
+        } else {
+            let new_state = state
+                .screens
+                .last()
+                .expect("no screen on stack")
+                .handle_input(action)
+                .await;
+            if action == Action::Timer && !new_state.redraw {
+                continue;
+            }
+            new_state
+        };
+
+        if new_state.replace_view {
+            state.screens.pop();
+        }
+        state.screens.push(new_state.view);
+
+        if action != Action::Timer || new_state.redraw {
+            state.screens.last().unwrap().display(display).await;
+        }
+
+        Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)).await;
+    }
+}

src/navigation/state.rs

@@ -1,23 +1,16 @@
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+use crate::views::{main_menu::MainMenu, view::View};
-pub enum ScreenMode {
+use alloc::vec;
-    CardDetail,
+use alloc::vec::Vec;
-    DexGrid,
-    Settings,
-}
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub struct NavigationState {
-    pub current_screen: ScreenMode,
+    pub screens: Vec<View>,
-    pub card_index: usize,
-    pub use_first_payload: bool,
 }
 
 impl Default for NavigationState {
     fn default() -> Self {
         Self {
-            current_screen: ScreenMode::CardDetail,
+            screens: vec![View::Main(MainMenu { selected: 0 })],
-            card_index: 0,
-            use_first_payload: true,
         }
     }
 }
@@ -27,9 +20,22 @@ impl NavigationState {
         Self::default()
     }
 
-    pub fn toggle_payload(&mut self) -> bool {
+    pub fn back(&mut self) -> &View {
-        let current = self.use_first_payload;
+        match &self.screens.len() {
-        self.use_first_payload = !self.use_first_payload;
+            0 => {
-        current
+                log::info!("No screens to go back to");
+                return self.screens.last().unwrap();
+            }
+            1 => {
+                log::info!("Only one screen on stack, cannot go back");
+                return self.screens.last().unwrap();
+            }
+            _ => {
+                log::info!("Going back to previous screen");
+                self.screens.pop();
+                return self.screens.last().unwrap();
+            }
+            
+        }
     }
 }

src/views.rs

@@ -0,0 +1,8 @@
+pub mod card_view;
+pub mod journal_view;
+pub mod main_menu;
+pub mod menu_item;
+pub mod scan_menu;
+pub mod settings_menu;
+pub mod status_bar;
+pub mod view;

src/views/card_view.rs

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

src/views/journal_view.rs

@@ -0,0 +1,38 @@
+use core::future;
+
+use alloc::vec::Vec;
+
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics_core::draw_target::DrawTarget;
+
+use crate::{
+    card::model::Card, display::primary_lcd::PrimaryLcdDisplay, navigation::navigation::{Action, Navigable, NewState}, views::view::View,
+};
+
+#[derive(Debug, Clone)]
+pub struct JournalView {
+    pub cards: Vec<Card>,
+    pub selected_card: usize,
+}
+
+impl Navigable for JournalView {
+    fn display(
+        &self,
+        display: &mut PrimaryLcdDisplay<'static>,
+    ) -> impl core::future::Future<Output = ()> + Send {
+        display.clear(Rgb565::BLACK).unwrap();
+
+        core::future::ready(())
+    }
+
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
+        let new_state = NewState {
+            view: View::Journal(self.clone()),
+            replace_view: true,
+            redraw: !matches!(input, Action::Timer),
+        };
+
+        future::ready(new_state)
+    }
+}

src/views/main_menu.rs

@@ -0,0 +1,90 @@
+use alloc::vec;
+
+use crate::card::model::Card;
+use crate::card::{decoder::split_nfc_hex, mock::*};
+use crate::display::primary_lcd::PrimaryLcdDisplay;
+
+use crate::navigation::inputs::ButtonAction;
+use crate::views::card_view::CardView;
+use crate::views::journal_view::JournalView;
+use crate::views::{menu_item, settings_menu::SettingsMenu, view::View};
+
+use crate::navigation::navigation::{Action, Navigable, NewState};
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics_core::draw_target::DrawTarget;
+
+pub const MAX_SELECTED: i32 = 4;
+
+#[derive(Debug, Clone)]
+pub struct MainMenu {
+    pub selected: i32,
+}
+
+impl Navigable for MainMenu {
+    fn display(
+        &self,
+        display: &mut PrimaryLcdDisplay<'static>,
+    ) -> impl core::future::Future<Output = ()> + Send {
+        display.clear(Rgb565::BLACK).unwrap();
+
+        menu_item::show(display, "Scan card", 0, self.selected);
+        menu_item::show(display, "Last card", 1, self.selected);
+        menu_item::show(display, "Journal", 2, self.selected);
+        menu_item::show(display, "Settings", 3, self.selected);
+
+        core::future::ready(())
+    }
+
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
+        async move {
+            let Action::Button(input) = input else {
+                // Skip timer inputs
+                return NewState {
+                    view: View::Main(self.clone()),
+                    replace_view: true,
+                    redraw: false,
+                };
+            };
+
+            let card_mock1 = Card::try_from(split_nfc_hex(&MOCK_PAYLOAD3).unwrap()).unwrap();
+            let card_mock2 = Card::try_from(split_nfc_hex(&MOCK_PAYLOAD2).unwrap()).unwrap();
+
+            let new_menu = match input {
+                ButtonAction::Up => {
+                    let new_selected = if (self.selected - 1) < 0 {
+                        MAX_SELECTED - 1
+                    } else {
+                        self.selected - 1
+                    };
+                    View::Main(MainMenu {
+                        selected: new_selected,
+                    })
+                }
+                ButtonAction::Down => {
+                    let new_selected = self.selected.wrapping_add(1) % MAX_SELECTED;
+                    View::Main(MainMenu {
+                        selected: new_selected,
+                    })
+                }
+                ButtonAction::Ok => match self.selected {
+                    0 => View::Scan(crate::views::scan_menu::ScanMenu { progress: 0 }),
+                    1 => View::Card(CardView { card: card_mock1 }),
+                    2 => View::Journal(JournalView {
+                        cards: vec![card_mock1, card_mock2],
+                        selected_card: 0,
+                    }),
+                    3 => View::Settings(SettingsMenu { selected: 0 }),
+                    _ => View::Main(self.clone()),
+                },
+                _ => View::Main(self.clone()),
+            };
+
+            NewState {
+                replace_view: matches!(new_menu, View::Main(_)),
+                view: new_menu,
+                redraw: true,
+            }
+        }
+    }
+}

src/views/menu_item.rs

@@ -0,0 +1,32 @@
+use embedded_graphics::mono_font::MonoTextStyle;
+use embedded_graphics::mono_font::ascii::FONT_10X20;
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::Point;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics::text::Text;
+use embedded_graphics::Drawable;
+
+use crate::display::primary_lcd::PrimaryLcdDisplay;
+
+pub fn show<'a>(
+    display: &mut PrimaryLcdDisplay<'static>,
+    name: &str,
+    position: i32,
+    selected: i32,
+) {
+    let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+    let selected_style = MonoTextStyle::new(&FONT_10X20, Rgb565::BLUE);
+
+    Text::new(
+        name,
+        Point::new(40, 40 + position * 40),
+        if position == selected {
+            selected_style
+        } else {
+            style
+        },
+    )
+    .draw(display)
+    .unwrap();
+}
+

src/views/scan_menu.rs

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

src/views/settings_menu.rs

@@ -0,0 +1,37 @@
+use crate::display::primary_lcd::PrimaryLcdDisplay;
+
+use crate::navigation::navigation::{Action, Navigable, NewState};
+use crate::views::{menu_item, view::View};
+
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics_core::draw_target::DrawTarget;
+pub const MAX_SELECTED: i8 = 2;
+
+#[derive(Debug, Clone)]
+pub struct SettingsMenu {
+    pub selected: i32,
+}
+
+impl Navigable for SettingsMenu {
+    fn display(
+        &self,
+        display: &mut PrimaryLcdDisplay<'static>,
+    ) -> impl core::future::Future<Output = ()> + Send {
+        display.clear(Rgb565::BLACK).unwrap();
+        menu_item::show(display, "System Inforation", 0, self.selected);
+        menu_item::show(display, "Wifi Information", 1, self.selected);
+
+        core::future::ready(())
+    }
+
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {
+        async move {
+            NewState {
+                view: View::Settings(SettingsMenu { selected: 0 }),
+                replace_view: true,
+                redraw: !matches!(input, Action::Timer),
+            }
+        }
+    }
+}

src/views/view.rs

@@ -0,0 +1,48 @@
+use crate::views::card_view::CardView;
+use crate::views::{
+    journal_view::JournalView, main_menu::MainMenu, scan_menu::ScanMenu,
+    settings_menu::SettingsMenu,
+};
+
+use crate::navigation::navigation::{Navigable, NewState};
+
+#[derive(Debug, Clone)]
+pub enum View {
+    Main(MainMenu),
+    Scan(ScanMenu),
+    Settings(SettingsMenu),
+    Journal(JournalView),
+    Card(CardView),
+}
+
+impl Navigable for View {
+    fn display(
+        &self,
+        display: &mut crate::display::primary_lcd::PrimaryLcdDisplay<'static>,
+    ) -> impl core::future::Future<Output = ()> + Send {
+        async move {
+            match self {
+                View::Main(main_menu) => main_menu.display(display).await,
+                View::Scan(scan_menu) => scan_menu.display(display).await,
+                View::Settings(settings_menu) => settings_menu.display(display).await,
+                View::Journal(journal_view) => journal_view.display(display).await,
+                View::Card(card_view) => card_view.display(display).await,
+            }
+        }
+    }
+
+    fn handle_input(
+        &self,
+        input: crate::navigation::navigation::Action,
+    ) -> impl core::future::Future<Output = NewState> + Send {
+        async move {
+            match self {
+                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,
+            }
+        }
+    }
+}