Full working creature card scan

.cargo/config.toml

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

.envrc

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

.gitignore

@@ -24,6 +24,3 @@ target/
 
 # Ignore .DS_Store file in mac
 **/.DS_Store
-
-# Ignore checked out wiki
-creaturedex.wiki/

Cargo.toml

@@ -9,61 +9,60 @@ name = "creaturedex"
 path = "./src/bin/main.rs"
 
 [dependencies]
-esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
+esp-hal = { version = "~1.1.0", features = ["esp32", "log-04", "unstable"] }
 
 esp-rtos = { version = "0.3.0", features = [
-  "embassy",
   "esp-alloc",
   "esp-radio",
-  "esp32s3",
+  "esp32",
   "log-04",
 ] }
 
-esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32s3", "log-04"] }
+esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32", "log-04"] }
 log                    = "0.4.27"
 
 critical-section = "1.2.0"
 embedded-io = "0.7.1"
-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 = [
+esp-println = { version = "0.17.0", features = ["esp32", "log-04"] }
-  "ap",
+esp-radio = { version = "0.18.0", features = [
-  "esp32s3",
+  "esp-alloc",
+  "esp32",
+  "log-04",
+  "unstable",
+  "wifi",
+] }
+smoltcp = { version = "0.13.0", default-features = false, features = [
+  "log",
+  "medium-ethernet",
+  "multicast",
+  "proto-dhcpv4",
+  "proto-dns",
+  "proto-ipv4",
+  "socket-dns",
+  "socket-icmp",
+  "socket-raw",
+  "socket-tcp",
+  "socket-udp",
 ] }
-esp-println = { version = "0.17.0", features = ["esp32s3", "log-04"] }
 display-interface-spi = "0.5.0"
 ili9341 = "0.6.0"
 embedded-hal = "1.0.0"
 embedded-hal-bus = "0.3.0"
 embedded-graphics = "0.8.2"
 embedded-graphics-core = "0.4.1"
-base64 = { version = "0.22", default-features = false, features = ["alloc"] }
 pn532 = "0.5.0"
-ndef = "0.5.0"
+ndef = { version = "0.5.0", path = "./ndef-rs" }
-num_enum = { version = "0.7.6", default-features = false }
+
-embassy-sync = "0.8.0"
-embedded-hal-async = "1.0.0"
 
 # 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 = 0
+opt-level = "s"
-debug = 2
-
-[profile.dev.package."*"]
-opt-level = 3
-debug = 0
 
 [profile.release]
 codegen-units = 1     # LLVM can perform better optimizations using a single thread
 debug         = 2     # prefer slower builds but better debugging experience
 lto           = 'fat'
 opt-level     = 's'
-
-[features]
-default = []
-wokwi = []

diagram.json

@@ -1,82 +1,44 @@
 {
-"version": 1,
+  "version": 1,
-"author": "CreatureDex",
+  "editor": "wokwi",
-"editor": "wokwi",
+  "parts": [
-"parts": [
+    { "type": "board-esp32-s3-devkitc-1", "id": "esp1", "top": 67.2, "left": -263.96, "attrs": {} },
-  {
+    {
-    "type": "board-esp32-s3-devkitc-1",
+      "type": "board-ili9341-cap-touch",
-    "id": "esp1",
+      "id": "lcd1",
-    "top": 67.2,
+      "top": -191.24,
-    "left": -263.96,
+      "left": -0.38,
-    "attrs": {}
+      "attrs": {}
-  },
+    },
-  { "type": "wokwi-ili9341", "id": "lcd1", "top": -200.8, "left": 354.9, "attrs": {} },
+    {
-  {
+      "type": "wokwi-led",
-    "type": "wokwi-pushbutton",
+      "id": "led1",
-    "id": "btn-up",
+      "top": -82.89,
-    "top": -99.4,
+      "left": 196.26,
-    "left": -76.8,
+      "attrs": { "color": "red" }
-    "attrs": { "color": "RebeccaPurple", "xray": "1", "key": "1", "label": "Up" }
+    },
-  },
+    {
-  {
+      "type": "wokwi-resistor",
-    "type": "wokwi-pushbutton",
+      "id": "r1",
-    "id": "btn-down",
+      "top": 183.86,
-    "top": 25.4,
+      "left": 154.06,
-    "left": -76.8,
+      "attrs": { "value": "220" }
-    "attrs": { "color": "green", "xray": "1", "key": "1", "label": "Down" }
+    }
-  },
+  ],
-  {
+    "connections": [
-    "type": "wokwi-pushbutton",
+    [ "lcd1:VCC", "esp1:3V3", "red", [ "v19.2", "h-57.6", "v-105.6", "h-124.95" ] ],
-    "id": "btn-left",
+    [ "lcd1:GND", "esp1:GND.2", "black", [ "v28.8", "h-76.8", "v-76.8" ] ],
-    "top": -32.2,
+    [ "lcd1:CS", "esp1:11", "orange", [ "v0" ] ],
-    "left": -163.2,
+    [ "lcd1:D/C", "esp1:12", "gold", [ "v0" ] ],
-    "attrs": { "color": "yellow", "xray": "1", "key": "1", "label": "Left" }
+    [ "lcd1:RESET", "esp1:10", "brown", [ "v0" ] ],
-  },
+    [ "lcd1:MOSI", "esp1:35", "violet", [ "v105.6", "h-124.8", "v-144" ] ],
-  {
+    [ "lcd1:SCK", "esp1:36", "white", [ "v115.2", "h-144", "v-86.4" ] ],
-    "type": "wokwi-pushbutton",
+    [ "esp1:37", "lcd1:MISO", "magenta", [ "h57.6", "v105.6", "h172.8" ] ],
-    "id": "btn-right",
+    [ "esp1:22", "lcd1:SCL", "yellow", [ "h48", "v163.2", "h192" ] ],
-    "top": -32.2,
+    [ "esp1:21", "lcd1:SDA", "cyan", [ "h38.4", "v144", "h211.2" ] ],
-    "left": 19.2,
+    [ "r1:2", "led1:A", "green", [ "h8.4", "v-230.4" ] ],
-    "attrs": { "color": "red", "xray": "1", "key": "1", "label": "Right" }
+    [ "esp1:GND.2", "led1:C", "black", [ "v0", "h86.4", "v76.8", "h278.4" ] ],
-  },
+    [ "esp1:17", "r1:1", "green", [ "h0" ] ]
-  {
-    "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" }
-  }
 ],
-"connections": [
+  "dependencies": {}
-  [ "esp1:TX", "$serialMonitor:RX", "", [] ],
-  [ "esp1:RX", "$serialMonitor:TX", "", [] ],
-  [ "lcd1:VCC", "esp1:3V3", "red", [ "v19.2", "h-57.6", "v-105.6", "h-124.95" ] ],
-  [ "lcd1:GND", "esp1:GND.2", "black", [ "v28.8", "h-76.8", "v-76.8" ] ],
-  [ "lcd1:CS", "esp1:11", "orange", [ "v0" ] ],
-  [ "lcd1:D/C", "esp1:12", "gold", [ "v0" ] ],
-  [ "lcd1:RESET", "esp1:10", "brown", [ "v0" ] ],
-  [ "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" ] ],
-  [ "btn-up:2.l", "esp1:38", "purple", [ "h-9.6", "v19.4" ] ],
-  [ "btn-up:1.l", "esp1:GND.2", "black", [ "h0" ] ],
-  [ "btn-down:1.l", "esp1:GND.2", "black", [ "h0" ] ],
-  [ "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" ] ]
-],
-"dependencies": {}
 }

model/right-half.scad

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

src/bin/main.rs

@@ -7,19 +7,37 @@
 )]
 #![deny(clippy::large_stack_frames)]
 
-use alloc::boxed::Box;
+use core::convert::Infallible;
-use creaturedex::card::decoder::split_nfc_hex;
+
-use creaturedex::card::model::Card;
+use alloc::vec::Vec;
-use creaturedex::display::primary_lcd::{PrimaryLcdDisplay, init_primary_lcd};
+use display_interface_spi::SPIInterface;
-use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
+use embedded_graphics::Drawable;
-use creaturedex::navigation::inputs::Inputs;
+use embedded_graphics::mono_font::MonoTextStyle;
-use creaturedex::navigation::navigation::{self, CARD_DATA};
+use embedded_graphics::mono_font::ascii::FONT_6X10;
-use creaturedex::network::wifi::setup_wifi;
+use embedded_graphics::pixelcolor::Rgb565;
-use embassy_executor::Spawner;
+use embedded_graphics::prelude::Point;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics::text::Text;
+use embedded_graphics_core::draw_target::DrawTarget;
+use embedded_hal_bus::spi::ExclusiveDevice;
 use esp_hal::clock::CpuClock;
-use esp_hal::gpio::{Input, InputConfig, Pull};
+use esp_hal::delay::Delay;
+use esp_hal::gpio::Level;
+use esp_hal::gpio::Output;
+use esp_hal::gpio::OutputConfig;
+use esp_hal::main;
+use esp_hal::spi::{
+    Mode,
+    master::{Config, Spi},
+};
+use esp_hal::time::{Duration, Instant};
 use esp_hal::timer::timg::TimerGroup;
-use log::error;
+use esp_println::dbg;
+use ili9341::Ili9341;
+use ili9341::Orientation;
+use log::{error, info};
+use pn532::i2c::I2CInterface;
+use pn532::nb;
 
 #[panic_handler]
 fn panic(panic_info: &core::panic::PanicInfo) -> ! {
@@ -29,8 +47,6 @@ 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!();
@@ -39,74 +55,230 @@ esp_bootloader_esp_idf::esp_app_desc!();
     clippy::large_stack_frames,
     reason = "it's not unusual to allocate larger buffers etc. in main"
 )]
-#[esp_rtos::main]
+#[main]
-async fn main(spawner: Spawner) {
+fn main() -> ! {
+    // generator version: 1.3.0
+    // generator parameters: --chip esp32s3 -o esp32s3-wroom-1-octal-psram -o unstable-hal -o alloc -o wifi -o log -o wokwi -o neovim -o vscode -o esp
+
     esp_println::logger::init_logger_from_env();
 
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
     let peripherals = esp_hal::init(config);
 
-    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: HEAP_SIZE);
+    let sck = peripherals.GPIO18;
+    let mosi = peripherals.GPIO23;
+    let miso = peripherals.GPIO19;
+    let cs_main = peripherals.GPIO5;
+    let dc = peripherals.GPIO17;
+    let reset_main = peripherals.GPIO16;
 
+    let sda = peripherals.GPIO21;
+    let scl = peripherals.GPIO22;
+
+    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: 73744);
+
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
     let sw_interrupt =
         esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
+    let (mut _wifi_controller, _interfaces) =
+        esp_radio::wifi::new(peripherals.WIFI, Default::default())
+            .expect("Failed to initialize Wi-Fi controller");
 
-    let display: &mut PrimaryLcdDisplay = Box::leak(Box::new(init_primary_lcd(
+    let spi_bus = Spi::new(
         peripherals.SPI2,
-        peripherals.GPIO36, // sck
+        Config::default()
-        peripherals.GPIO35, // mosi
+            .with_frequency(Rate::from_khz(100))
-        peripherals.GPIO37, // miso
+            .with_mode(Mode::_0),
-        peripherals.GPIO11, // primary cs
+    )
-        peripherals.GPIO10, // shared reset
+    .unwrap()
-        peripherals.GPIO12, // shared dc
+    .with_sck(sck)
-    )));
+    .with_mosi(mosi)
+    .with_miso(miso);
 
-    setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
+    let cs_main = Output::new(cs_main, Level::High, OutputConfig::default());
 
-    let mut nfc_driver =
+    let mut delay = Delay::new();
-        NfcPn532Driver::new(peripherals.I2C0, peripherals.GPIO17, peripherals.GPIO18);
+    let spi_dev = ExclusiveDevice::new(spi_bus, cs_main, delay).unwrap();
-    if nfc_driver.configure_sam().await.is_ok() {
+    let reset_main = Output::new(reset_main, Level::High, OutputConfig::default());
-        log::info!("NFC SAM configuration successful");
+    let spi_dc = Output::new(dc, Level::High, OutputConfig::default());
-    } else {
+    let iface = SPIInterface::new(spi_dev, spi_dc);
-        log::error!("NFC SAM configuration failed");
-    }
 
-    let button_config = InputConfig::default().with_pull(Pull::Up);
+    let mut display = Ili9341::new(
-    let inputs = Inputs {
+        iface,
-        up: Input::new(peripherals.GPIO38, button_config),
+        reset_main,
-        down: Input::new(peripherals.GPIO39, button_config),
+        &mut delay,
-        left: Input::new(peripherals.GPIO40, button_config),
+        Orientation::Landscape,
-        right: Input::new(peripherals.GPIO41, button_config),
+        ili9341::DisplaySize240x320,
-        back: Input::new(peripherals.GPIO42, button_config),
+    )
-        ok: Input::new(peripherals.GPIO45, button_config),
+    .unwrap();
+
+    // display.clear(Rgb565::BLACK).unwrap();
+
+    let style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
+    Text::new("Hello, ESP32!", Point::new(20, 100), style)
+        .draw(&mut display)
+        .unwrap();
+
+    use pn532::{Pn532, Request, requests::SAMMode};
+
+    // spi is a struct implementing embedded_hal::spi::SpiDevice
+    // timer is a struct implementing pn532::CountDown
+
+    use esp_hal::{
+        i2c::master::{Config as I2cConfig, I2c},
+        time::Rate,
     };
 
-    log::info!("Setup complete, entering main loop");
+    let config = I2cConfig::default().with_frequency(Rate::from_khz(20));
-    spawner.spawn(navigation::run(inputs, display).expect("run task failed"));
+    let i2c = I2c::new(peripherals.I2C0, config)
-    spawner.spawn(nfc_driver_task(nfc_driver).expect("nfc driver task failed"));
+        .expect("Failed to init I2C")
-}
+        .with_sda(sda)
+        .with_scl(scl);
 
+    let mut pn532: Pn532<_, _, 32> = Pn532::new(I2CInterface { i2c }, TimerWrapper::new());
+
+    let ms_50 = Duration::from_millis(50);
+    let ms_1000 = Duration::from_millis(1000);
+
+    let delay_start = Instant::now();
+    while delay_start.elapsed() < Duration::from_millis(500) {}
+
+    let mut data: Vec<u8> = Vec::with_capacity(858);
+
+    if let Err(e) = pn532.process(
+        &Request::sam_configuration(SAMMode::Normal, false),
+        0,
+        Duration::from_millis(5000),
+    ) {
+        error!("Could not initialize PN532: {e:?}")
+    } else {
+        info!("Successfully init'ed PN532");
+    }
 
-#[embassy_executor::task]
-async fn nfc_driver_task(mut nfc_driver: NfcPn532Driver<'static>) {
     loop {
-        while CARD_DATA.lock().await.is_none() {
+        info!("Hello world!");
-            match nfc_driver.read_card_data().await {
+
-                Ok(card_data) => {
+        match pn532.process(
-                    log::info!("NFC Card Data Read: {:?}", card_data);
+            &Request::INLIST_ONE_ISO_A_TARGET,
-                    let Some(split_data) = split_nfc_hex(&card_data) else {
+            23,
-                        log::error!("Failed to split NFC card data");
+            Duration::from_secs(10),
-                        continue;
+        ) {
-                    };
+            Ok(uid) => {
-                    CARD_DATA.lock().await.replace(Card::try_from(split_data).unwrap());
+                info!("uid = {uid:?}");
+                for i in (0x04..=230) {
+                    let mut parse_result = Err(());
+                    while parse_result.is_err() {
+                        let Ok(result) = pn532.process(&Request::ntag_read(i), 17, ms_1000) else {
+                            continue;
+                        };
+                        parse_result = parse_nfc(i, result);
+                    }
+                    let bytes = parse_result.unwrap();
+                    data.extend(bytes);
                 }
-                Err(_) => {
+                info!("Full data: {data:02x?}");
-                    log::info!("No NFC card found");
+                match ndef::Message::try_from(&data[4..4 + 883]) {
+                    Ok(m) => info!("Parsed: {m:02x?}"),
+                    Err(e) => info!("Failed to parse: {e:?}"),
                 }
+                data.clear();
+            }
+            Err(e) => {
+                info!("No NFC card found: {e:?}");
             }
         }
-        embassy_time::Timer::after(embassy_time::Duration::from_millis(1000)).await;
+
+        let delay_start = Instant::now();
+        while delay_start.elapsed() < Duration::from_millis(500) {}
+    }
+
+    // for inspiration have a look at the examples at https://github.com/esp-rs/esp-hal/tree/esp-hal-v1.1.0/examples
+}
+
+fn parse_nfc(iteration: u8, bytes: &[u8]) -> Result<[u8; 4], ()> {
+    let success = bytes.first().is_some_and(|x| *x == 0);
+    if success {
+        // info!("page {i}: {:02x?}", result);
+        let mut arr = [0; 4];
+        arr.copy_from_slice(&bytes[1..5]);
+        Ok(arr)
+    } else {
+        info!("err  {iteration}: {:02x?}", bytes);
+        Err(())
     }
 }
+
+struct TimerWrapper {
+    // TODO Is that timer accurate enough?
+    start: Instant,
+    duration: Duration,
+    counter: u32,
+}
+
+impl TimerWrapper {
+    pub fn new() -> Self {
+        Self {
+            start: Instant::now(),
+            duration: Duration::ZERO,
+            counter: 0,
+        }
+    }
+}
+
+impl pn532::CountDown for TimerWrapper {
+    type Time = Duration;
+
+    fn start<T>(&mut self, timeout: T)
+    where
+        T: Into<Self::Time>,
+    {
+        // without this debug log, it works worse: stuck in NFC card search without ever returning.
+        self.start = Instant::now();
+        self.duration = timeout.into();
+        self.counter = 0;
+    }
+
+    fn wait(&mut self) -> nb::Result<(), Infallible> {
+        let elapsed = self.start.elapsed();
+        self.counter += 1;
+        if self.counter.is_multiple_of(1) {
+            // info!("Elapsed: {elapsed}");
+        }
+        if elapsed >= self.duration {
+            Ok(())
+        } else {
+            Err(nb::Error::WouldBlock)
+        }
+    }
+}
+
+/*
+struct TimerWrapper<'a, T>
+where
+    T: esp_hal::DriverMode,
+{
+    timer: esp_hal::timer::PeriodicTimer<'a, T>,
+}
+
+impl<'a, TIM> pn532::CountDown for TimerWrapper<'a, TIM>
+where
+    TIM: esp_hal::DriverMode,
+{
+    type Time = Duration;
+    fn start<T>(&mut self, timeout: T)
+    where
+        T: Into<Self::Time>,
+    {
+        self.timer.start(timeout.into()).unwrap();
+    }
+
+    fn wait(&mut self) -> nb::Result<(), Infallible> {
+        // convert nb::Result<(), void::Void> to nb::Result<(), Infallible>
+        match self.timer.wait() {
+            Ok(_) => Ok(()),
+            Err(_) => Err(nb::Error::WouldBlock),
+        }
+    }
+}
+ */

src/card.rs

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

src/card/decoder.rs

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

src/card/mock.rs

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

src/card/model.rs

@@ -1,262 +0,0 @@
-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],
-    pub card_type: u8,
-    pub card_uuid: &'a [u8],
-    pub _reserved: &'a [u8],
-    pub sprite: &'a [u8],
-    pub packed_card_text: &'a [u8],
-    pub secret: &'a [u8],
-    pub _opaque_trailer: &'a [u8],
-}
-
-#[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,4 +0,0 @@
-pub mod primary_lcd;
-pub mod secondary_oled;
-pub mod sprite;
-pub mod tertiary_lcd;

src/display/primary_lcd.rs

@@ -1,61 +0,0 @@
-use display_interface_spi::SPIInterface;
-use embedded_graphics::draw_target::DrawTarget;
-use embedded_graphics::pixelcolor::Rgb565;
-use embedded_graphics::prelude::RgbColor;
-use embedded_hal_bus::spi::ExclusiveDevice;
-use esp_hal::delay::Delay;
-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> = Ili9341<
-    SPIInterface<ExclusiveDevice<Spi<'a, esp_hal::Blocking>, Output<'a>, Delay>, Output<'a>>,
-    Output<'a>,
->;
-
-pub fn init_primary_lcd(
-    spi2: SPI2<'static>,
-    sck: GPIO36<'static>,
-    mosi: GPIO35<'static>,
-    miso: GPIO37<'static>,
-    cs: GPIO11<'static>,
-    reset: GPIO10<'static>,
-    dc: GPIO12<'static>,
-) -> PrimaryLcdDisplay<'static> {
-    let freq = Rate::from_khz(60_000);
-    log::info!("Display freq: {freq}");
-
-    let spi_bus = Spi::new(
-        spi2,
-        Config::default().with_frequency(freq).with_mode(Mode::_0),
-    )
-    .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_main,
-        &mut delay,
-        Orientation::Portrait,
-        DisplaySize240x320,
-    )
-    .unwrap();
-
-    display.clear(Rgb565::BLACK).unwrap();
-    display
-}

src/display/secondary_oled.rs

@@ -1 +0,0 @@
-// Secondary OLED module

src/display/sprite.rs

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

src/display/tertiary_lcd.rs

@@ -1 +0,0 @@
-// Tertiary LCD module

src/drivers.rs

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

src/drivers/nfc_pn532.rs

@@ -1,150 +0,0 @@
-use alloc::vec::Vec;
-use core::convert::Infallible;
-use esp_hal::gpio::interconnect::{PeripheralInput, PeripheralOutput};
-use esp_hal::i2c::master::{Config as I2cConfig, I2c};
-use esp_hal::peripherals::I2C0;
-use esp_hal::time::{Duration, Instant, Rate};
-use log::{error, info};
-use pn532::i2c::I2CInterface;
-use pn532::requests::SAMMode;
-use pn532::{nb, Pn532, Request};
-
-/// Timer implementation required by `pn532::CountDown`.
-pub struct TimerWrapper {
-    start: Instant,
-    duration: Duration,
-    counter: u32,
-}
-
-impl TimerWrapper {
-    pub fn new() -> Self {
-        Self {
-            start: Instant::now(),
-            duration: Duration::ZERO,
-            counter: 0,
-        }
-    }
-}
-
-impl Default for TimerWrapper {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl pn532::CountDown for TimerWrapper {
-    type Time = Duration;
-
-    fn start<T>(&mut self, timeout: T)
-    where
-        T: Into<Self::Time>,
-    {
-        self.start = Instant::now();
-        self.duration = timeout.into();
-        self.counter = 0;
-    }
-
-    fn wait(&mut self) -> nb::Result<(), Infallible> {
-        let elapsed = self.start.elapsed();
-        self.counter += 1;
-        if elapsed >= self.duration {
-            Ok(())
-        } else {
-            Err(nb::Error::WouldBlock)
-        }
-    }
-}
-
-pub type Pn532Device<'a> = Pn532<I2CInterface<I2c<'a, esp_hal::Blocking>>, (), 32>;
-
-/// PN532 NFC reader driver.
-pub struct NfcPn532Driver<'a> {
-    pn532: Pn532Device<'a>,
-}
-
-impl<'a> NfcPn532Driver<'a> {
-    pub fn new<SDA, SCL>(i2c0: I2C0<'static>, sda: SDA, scl: SCL) -> Self
-    where
-        SDA: PeripheralInput<'static> + PeripheralOutput<'static>,
-        SCL: PeripheralInput<'static> + PeripheralOutput<'static>,
-    {
-        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_async(I2CInterface { i2c });
-        Self { pn532 }
-    }
-
-    pub async fn configure_sam(&mut self) -> Result<(), ()> {
-        if let Err(e) = self.pn532.process_async(
-            &Request::sam_configuration(SAMMode::Normal, false),
-            0,
-        ).await {
-            error!("Could not initialize PN532: {e:?}");
-            Err(())
-        } else {
-            info!("Successfully init'ed PN532");
-            Ok(())
-        }
-    }
-
-    pub async fn poll_target(&mut self) -> Result<(), ()> {
-        match self.pn532.process_async(&Request::INLIST_ONE_ISO_A_TARGET, 23).await {
-            Ok(uid) => {
-                info!("uid = {uid:?}");
-                Ok(())
-            }
-            Err(e) => {
-                info!("No NFC card found: {e:?}");
-                Err(())
-            }
-        }
-    }
-
-    pub fn parse_nfc_page(iteration: u8, bytes: &[u8]) -> Result<[u8; 4], ()> {
-        let success = bytes.first().is_some_and(|x| *x == 0);
-        if success {
-            let mut arr = [0; 4];
-            arr.copy_from_slice(&bytes[1..5]);
-            Ok(arr)
-        } else {
-            info!("err  {iteration}: {:02x?}", bytes);
-            Err(())
-        }
-    }
-
-    pub async fn read_card_data(&mut self) -> Result<Vec<u8>, ()> {
-        self.poll_target().await?;
-
-        let mut data: Vec<u8> = Vec::with_capacity(858);
-
-        for i in 0x0B..=230 {
-
-            let mut parse_result = Err(());
-            while parse_result.is_err() {
-                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?}");
-        Ok(data)
-    }
-    
-    pub fn device_mut(&mut self) -> &mut Pn532Device<'a> {
-        &mut self.pn532
-    }
-}
-

src/lib.rs

@@ -1,11 +1 @@
 #![no_std]
-
-extern crate alloc;
-
-pub mod card;
-pub mod display;
-pub mod drivers;
-pub mod navigation;
-pub mod network;
-pub mod storage;
-pub mod views;

src/navigation.rs

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

src/navigation/inputs.rs

@@ -1,81 +0,0 @@
-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::Back,
-            3 => ButtonAction::Ok,
-            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

@@ -1,92 +0,0 @@
-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,41 +0,0 @@
-use crate::views::{main_menu::MainMenu, view::View};
-use alloc::vec;
-use alloc::vec::Vec;
-
-#[derive(Debug, Clone)]
-pub struct NavigationState {
-    pub screens: Vec<View>,
-}
-
-impl Default for NavigationState {
-    fn default() -> Self {
-        Self {
-            screens: vec![View::Main(MainMenu { selected: 0 })],
-        }
-    }
-}
-
-impl NavigationState {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn back(&mut self) -> &View {
-        match &self.screens.len() {
-            0 => {
-                log::info!("No screens to go back to");
-                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/network.rs

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

src/network/api_client.rs

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

src/network/wifi.rs

@@ -1,67 +0,0 @@
-use embassy_executor::Spawner;
-
-#[cfg(not(feature = "wokwi"))]
-pub async fn setup_wifi(
-    wifi: esp_hal::peripherals::WIFI<'static>,
-    flash: esp_hal::peripherals::FLASH<'static>,
-    spawner: &Spawner,
-) {
-    let nvs = esp_hal_wifimanager::Nvs::new(0x9000, 0x6000, flash).unwrap();
-
-    let mut wm_settings = esp_hal_wifimanager::WmSettings::default();
-
-    wm_settings.ssid.clear();
-    _ = core::fmt::write(
-        &mut wm_settings.ssid,
-        format_args!("CreatureDex-{:X}", esp_hal_wifimanager::get_efuse_mac()),
-    );
-
-    wm_settings.wifi_conn_timeout = 30000;
-    wm_settings.esp_reset_timeout = Some(300000); // 5min
-
-    let wifi_res = esp_hal_wifimanager::init_wm(wm_settings, spawner, Some(&nvs), wifi, None).await;
-
-    log::info!("wifi_res: {wifi_res:?}");
-}
-
-#[cfg(feature = "wokwi")]
-pub async fn setup_wifi(
-    wifi: esp_hal::peripherals::WIFI<'static>,
-    flash: esp_hal::peripherals::FLASH<'static>,
-    spawner: &Spawner,
-) {
-    log::info!("Wokwi mode active: pre-seeding WiFi Manager with Wokwi credentials");
-
-    // Preload connection data so init_wm can connect immediately without AP setup.
-    let nvs = match esp_hal_wifimanager::Nvs::new(0x9000, 0x6000, flash) {
-        Ok(nvs) => nvs,
-        Err(e) => {
-            log::error!("Failed to initialize NVS for Wokwi: {e:?}");
-            return;
-        }
-    };
-
-    if let Err(e) = nvs
-        .set(
-            esp_hal_wifimanager::WIFI_NVS_KEY,
-            "{\"ssid\":\"Wokwi-GUEST\",\"psk\":\"\",\"data\":{}}",
-        )
-        .await
-    {
-        log::error!("Failed to store Wokwi WiFi config in NVS: {e:?}");
-        return;
-    }
-
-    let mut wm_settings = esp_hal_wifimanager::WmSettings::default();
-
-    // Wokwi simulation uses a default open network called "Wokwi-GUEST"
-    wm_settings.ssid.clear();
-    _ = core::fmt::write(&mut wm_settings.ssid, format_args!("Wokwi-GUEST"));
-
-    wm_settings.wifi_conn_timeout = 30000;
-
-    // Initialize Wi-Fi connection through WiFi Manager using the pre-seeded NVS data.
-    let wifi_res = esp_hal_wifimanager::init_wm(wm_settings, spawner, Some(&nvs), wifi, None).await;
-
-    log::info!("Wokwi wifi_res: {wifi_res:?}");
-}

src/storage.rs

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

src/storage/dex_db.rs

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

src/storage/nvs.rs

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

src/views.rs

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

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

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

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

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

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

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

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

src/views/view.rs

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

wokwi.toml

@@ -1,5 +1,5 @@
 [wokwi]
 version = 1
 gdbServerPort = 3333
-elf = "target/xtensa-esp32s3-none-elf/debug/creaturedex"
+elf = "target/xtensa-esp32-none-elf/debug/creaturedex"
-firmware = "target/xtensa-esp32s3-none-elf/debug/creaturedex"
+firmware = "target/xtensa-esp32-none-elf/debug/creaturedex"