card model: save uuid as u32

.gitignore

@@ -31,3 +31,4 @@ creaturedex.wiki/
 # KiCad
 *.zip
 *.lck
+schematics/.history/

Cargo.lock

@@ -53,6 +53,12 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c583acf993cf4245c4acb0a2cc2ab1f9cc097de73411bb6d3647ff6af2b1013d"
 
+[[package]]
+name = "array-init"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d62b7694a562cdf5a74227903507c56ab2cc8bdd1f781ed5cb4cf9c9f810bfc"
+
 [[package]]
 name = "autocfg"
 version = "1.5.1"
@@ -96,6 +102,29 @@ dependencies = [
  "vsimd",
 ]
 
+[[package]]
+name = "binary_serde"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4b2fe974c561ed04fb89673dd221bed36fc4794b71ca6ae96ffe19949045686"
+dependencies = [
+ "array-init",
+ "binary_serde_macros",
+ "recursive_array",
+ "thiserror-no-std",
+]
+
+[[package]]
+name = "binary_serde_macros"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4790b8dbcfa9d3adf2020ebf5fd36c6bc89a77d434131615ea349bc9620e8831"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "bitfield"
 version = "0.17.0"
@@ -319,6 +348,7 @@ name = "creaturedex"
 version = "0.1.0"
 dependencies = [
  "base64 0.22.1",
+ "binary_serde",
  "ch1115",
  "critical-section",
  "display-interface-spi",
@@ -332,12 +362,14 @@ dependencies = [
  "embedded-hal-async",
  "embedded-hal-bus",
  "embedded-io 0.7.1",
+ "embedded-storage",
  "esp-alloc",
  "esp-bootloader-esp-idf",
  "esp-hal",
  "esp-hal-wifimanager",
  "esp-println",
  "esp-rtos",
+ "esp-storage",
  "i2c-character-display",
  "ili9341",
  "log",
@@ -2828,6 +2860,12 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "recursive_array"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69bad83913c3b39011ad9d43b7ac0cae139cec5d7e7288fbea5bb4b4e3cc78f6"
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -3305,6 +3343,26 @@ dependencies = [
  "syn 3.0.3",
 ]
 
+[[package]]
+name = "thiserror-impl-no-std"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58e6318948b519ba6dc2b442a6d0b904ebfb8d411a3ad3e07843615a72249758"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "thiserror-no-std"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3ad459d94dd517257cc96add8a43190ee620011bb6e6cdc82dafd97dfafafea"
+dependencies = [
+ "thiserror-impl-no-std",
+]
+
 [[package]]
 name = "thread_local"
 version = "1.1.10"

Cargo.toml

@@ -48,6 +48,9 @@ embassy-sync = "0.8.0"
 embedded-hal-async = "1.0.0"
 i2c-character-display = "0.5.1"
 ch1115 = { version = "0.1.2", features = ["graphics"] }
+esp-storage = "0.9.0"
+embedded-storage = "0.3.1"
+binary_serde = "1.0.25"
 
 
 [patch.crates-io]

schematics/creaturedex.kicad_prl

@@ -15,6 +15,7 @@
       "vias": 1.0,
       "zones": 0.6
     },
+    "prototype_zone_fills": false,
     "selection_filter": {
       "dimensions": true,
       "footprints": true,
@@ -54,6 +55,7 @@
     "zone_display_mode": 0
   },
   "git": {
+    "integration_disabled": false,
     "repo_type": "",
     "repo_username": "",
     "ssh_key": ""
@@ -73,6 +75,7 @@
     "filter_text": "",
     "group_by_constraint": false,
     "group_by_netclass": false,
+    "show_time_domain_details": false,
     "show_unconnected_nets": false,
     "show_zero_pad_nets": false,
     "sort_ascending": true,
@@ -83,6 +86,7 @@
     "files": []
   },
   "schematic": {
+    "hierarchy_collapsed": [],
     "selection_filter": {
       "graphics": true,
       "images": true,
@@ -90,6 +94,7 @@
       "lockedItems": false,
       "otherItems": true,
       "pins": true,
+      "ruleAreas": true,
       "symbols": true,
       "text": true,
       "wires": true

schematics/creaturedex.kicad_pro

@@ -10,17 +10,28 @@
       "via_dimensions": []
     },
     "ipc2581": {
+      "bom_rev": "",
       "dist": "",
       "distpn": "",
       "internal_id": "",
       "mfg": "",
-      "mpn": ""
+      "mpn": "",
+      "sch_revision": ""
     },
     "layer_pairs": [],
     "layer_presets": [],
     "viewports": []
   },
   "boards": [],
+  "component_class_settings": {
+    "assignments": [],
+    "meta": {
+      "version": 0
+    },
+    "sheet_component_classes": {
+      "enabled": false
+    }
+  },
   "cvpcb": {
     "equivalence_files": []
   },
@@ -210,11 +221,14 @@
       "duplicate_sheet_names": "error",
       "endpoint_off_grid": "warning",
       "extra_units": "error",
+      "field_name_whitespace": "warning",
       "footprint_filter": "ignore",
       "footprint_link_issues": "warning",
       "four_way_junction": "ignore",
       "global_label_dangling": "warning",
+      "ground_pin_not_ground": "warning",
       "hier_label_mismatch": "error",
+      "isolated_pin_label": "warning",
       "label_dangling": "error",
       "label_multiple_wires": "warning",
       "lib_symbol_issues": "warning",
@@ -237,6 +251,7 @@
       "similar_power": "warning",
       "simulation_model_issue": "ignore",
       "single_global_label": "ignore",
+      "stacked_pin_name": "warning",
       "unannotated": "error",
       "unconnected_wire_endpoint": "warning",
       "undefined_netclass": "error",
@@ -269,13 +284,14 @@
         "priority": 2147483647,
         "schematic_color": "rgba(0, 0, 0, 0.000)",
         "track_width": 0.2,
+        "tuning_profile": "",
         "via_diameter": 0.6,
         "via_drill": 0.3,
         "wire_width": 6
       }
     ],
     "meta": {
-      "version": 4
+      "version": 5
     },
     "net_colors": null,
     "netclass_assignments": null,
@@ -297,6 +313,10 @@
   },
   "schematic": {
     "annotate_start_num": 0,
+    "annotation": {
+      "method": 0,
+      "sort_order": 0
+    },
     "bom_export_filename": "${PROJECTNAME}.csv",
     "bom_fmt_presets": [],
     "bom_fmt_settings": {
@@ -368,6 +388,7 @@
       "sort_asc": true,
       "sort_field": "Reference"
     },
+    "bus_aliases": {},
     "connection_grid_size": 50.0,
     "drawing": {
       "dashed_lines_dash_length_ratio": 12.0,
@@ -375,6 +396,7 @@
       "default_line_thickness": 6.0,
       "default_text_size": 50.0,
       "field_names": [],
+      "hop_over_size_choice": 0,
       "intersheets_ref_own_page": false,
       "intersheets_ref_prefix": "",
       "intersheets_ref_short": false,
@@ -398,6 +420,7 @@
     "net_format_name": "",
     "page_layout_descr_file": "",
     "plot_directory": "",
+    "reuse_designators": true,
     "space_save_all_events": true,
     "spice_current_sheet_as_root": false,
     "spice_external_command": "spice \"%I\"",
@@ -406,13 +429,28 @@
     "spice_save_all_dissipations": false,
     "spice_save_all_voltages": false,
     "subpart_first_id": 65,
-    "subpart_id_separator": 0
+    "subpart_id_separator": 0,
+    "top_level_sheets": [
+      {
+        "filename": "creaturedex.kicad_sch",
+        "name": "creaturedex",
+        "uuid": "f0cf9cac-01dc-4071-b72f-ebf42dbd12d6"
+      }
+    ],
+    "used_designators": "",
+    "variants": []
   },
   "sheets": [
     [
       "f0cf9cac-01dc-4071-b72f-ebf42dbd12d6",
-      "Root"
+      "creaturedex"
     ]
   ],
-  "text_variables": {}
+  "text_variables": {},
+  "tuning_profiles": {
+    "meta": {
+      "version": 0
+    },
+    "tuning_profiles_impedance_geometric": []
+  }
 }

src/bin/main.rs

@@ -16,6 +16,8 @@ use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
 use creaturedex::navigation::inputs::Inputs;
 use creaturedex::navigation::navigation::{self, CARD_DATA};
 use creaturedex::network::wifi::setup_wifi;
+use creaturedex::storage::cardstore::CardStore;
+use creaturedex::storage::store::Store;
 use embassy_executor::Spawner;
 use embassy_time::Instant;
 use embedded_graphics::pixelcolor::BinaryColor;
@@ -28,7 +30,7 @@ use embedded_hal_bus::i2c::AtomicDevice;
 use embedded_hal_bus::util::AtomicCell;
 use esp_hal::Blocking;
 use esp_hal::clock::CpuClock;
-use esp_hal::gpio::{Input, InputConfig, Pull};
+use esp_hal::gpio::{Input, InputConfig, Level, Output, OutputConfig, Pull};
 use esp_hal::i2c::master::{Config as I2cConfig, I2c};
 use esp_hal::timer::timg::TimerGroup;
 use log::error;
@@ -72,10 +74,22 @@ async fn main(spawner: Spawner) {
         peripherals.GPIO37, // miso
         peripherals.GPIO11, // primary cs
         peripherals.GPIO13, // oled cs
-        peripherals.GPIO10, // shared reset
+        peripherals.GPIO10, // primary reset
+        peripherals.GPIO47, // secondary reset
         peripherals.GPIO12, // shared dc
     )));
 
+    let _secondary_oled_cs_2 = Output::new(
+        peripherals.GPIO14,
+        Level::High,
+        OutputConfig::default(),
+    );
+    let _secondary_oled_cs_3 = Output::new(
+        peripherals.GPIO21,
+        Level::High,
+        OutputConfig::default(),
+    );
+
     let config = I2cConfig::default().with_frequency(esp_hal::time::Rate::from_khz(400));
     let i2c = match I2c::new(peripherals.I2C0, config) {
         Ok(bus) => bus
@@ -96,7 +110,9 @@ async fn main(spawner: Spawner) {
         );
     }
 
-    setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
+    let store = Store::new(peripherals.FLASH).expect("Could not initialize Flash Store");
+    let card_store = CardStore::new(store).expect("Could not initialize Card Store");
+    //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() {
@@ -138,7 +154,7 @@ async fn nfc_driver_task(
                     CARD_DATA
                         .lock()
                         .await
-                        .replace(Card::try_from(split_data).unwrap());
+                        .replace(Card::try_from(split_data).expect("Invalid card data"));
                     let elapsed_ms = start.elapsed().as_millis();
                     log::info!(
                         "NFC read duration: {} ms, card data length: {}",

src/card/decoder.rs

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

src/card/model.rs

@@ -6,16 +6,19 @@ 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],
+use binary_serde::BinarySerde;
+
+#[derive(Debug, BinarySerde, PartialEq, Eq, Clone, Copy)]
+#[repr(C)]
+pub struct RawCard {
+    pub event_encoding: [u8; 2],
     pub card_type: u8,
-    pub card_uuid: &'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],
+    pub card_uuid: [u8; 2],
+    pub _reserved: [u8; 4],
+    pub sprite: [u8; 722],
+    pub packed_card_text: [u8; 54],
+    pub secret: [u8; 24],
+    pub _opaque_trailer: [u8; 49],
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, FromPrimitive)]
@@ -222,7 +225,7 @@ pub struct Sprite {
 
 #[derive(Debug, Clone)]
 pub struct Card {
-    pub uuid: String,
+    pub uuid: u32,
     pub event: Events,
     pub cardtype: CardType,
     pub name: String,
@@ -235,17 +238,19 @@ pub struct Card {
     pub sprite: Sprite,
 }
 
-impl<'a> TryFrom<NfcPayload<'a>> for Card {
+impl<'a> TryFrom<RawCard> 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);
+    fn try_from(raw_card: RawCard) -> Result<Self, Self::Error> {
+        let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16
+            | (u16::from_ne_bytes(raw_card.card_uuid) as u32);
+
+        let event = decode_known_event(&raw_card.event_encoding);
+        let cardtype = CardType::from(raw_card.card_type);
+        let (name, trait1, trait2, trait3) = decode_packed_card_text(&raw_card.packed_card_text);
+        let secret = decode_secret(&raw_card.secret);
         let sprite = Sprite {
-            data: payload.sprite.to_vec(),
+            data: raw_card.sprite.to_vec(),
         };
         Ok(Self {
             uuid,

src/display/shared_bus.rs

@@ -1,4 +1,3 @@
-use crate::display::primary_lcd::{PrimaryLcdDisplay, init_primary_lcd_on_bus};
 use alloc::boxed::Box;
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embedded_hal::digital::ErrorType;
@@ -12,6 +11,7 @@ use esp_hal::spi::master::{Config as SpiConfig, Spi};
 use esp_hal::time::Rate;
 
 use crate::display::secondary_oled::{SecondaryOledDisplay, init_secondary_oled_on_bus};
+use crate::display::primary_lcd::{PrimaryLcdDisplay, init_primary_lcd_on_bus};
 
 use core::cell::RefCell;
 use embassy_sync::blocking_mutex::Mutex as BlockingMutex;
@@ -52,14 +52,15 @@ pub type DualPrimaryDisplay<'a> =
 pub type DualSecondaryDisplay<'a> =
     SecondaryOledDisplay<'a, DisplaySpiBus, SharedPin<'a, Output<'a>>, SharedPin<'a, Output<'a>>>;
 
-pub fn init_dual_displays<SPI, SCK, MOSI, MISO, CS1, CS2, RES, DC>(
+pub fn init_dual_displays<SPI, SCK, MOSI, MISO, CS1, CS2, RES1, RES2, DC>(
     spi_peripheral: SPI,
     sck: SCK,
     mosi: MOSI,
     miso: MISO,
     cs_primary: CS1,
     cs_secondary: CS2,
-    reset_pin: RES,
+    reset_primary: RES1,
+    reset_secondary: RES2,
     dc_pin: DC,
 ) -> (DualPrimaryDisplay<'static>, DualSecondaryDisplay<'static>)
 where
@@ -69,7 +70,8 @@ where
     MISO: PeripheralInput<'static>,
     CS1: OutputPin + 'static,
     CS2: OutputPin + 'static,
-    RES: OutputPin + 'static,
+    RES1: OutputPin + 'static,
+    RES2: OutputPin + 'static,
     DC: OutputPin + 'static,
 {
     let spi = Spi::new(
@@ -84,15 +86,17 @@ where
     .with_miso(miso);
 
     let bus_static: &'static AtomicCell<_> = Box::leak(Box::new(AtomicCell::new(spi)));
-    let reset_static =
-        SharedPin::pre_wrap(Output::new(reset_pin, Level::High, OutputConfig::default()));
+    let reset_primary_static =
+        SharedPin::pre_wrap(Output::new(reset_primary, Level::High, OutputConfig::default()));
+    let reset_secondary_static =
+        SharedPin::pre_wrap(Output::new(reset_secondary, Level::High, OutputConfig::default()));
     let dc_static = SharedPin::pre_wrap(Output::new(dc_pin, Level::High, OutputConfig::default()));
     let mut delay = Delay::new();
 
     let primary = init_primary_lcd_on_bus(
         bus_static,
         cs_primary,
-        SharedPin::new(reset_static),
+        SharedPin::new(reset_primary_static),
         SharedPin::new(dc_static),
         &mut delay,
     );
@@ -100,7 +104,7 @@ where
     let secondary = init_secondary_oled_on_bus(
         bus_static,
         cs_secondary,
-        SharedPin::new(reset_static),
+        SharedPin::new(reset_secondary_static),
         SharedPin::new(dc_static),
         &mut delay,
     );

src/lib.rs

@@ -1,4 +1,5 @@
 #![no_std]
+#![feature(vec_into_chunks)]
 
 extern crate alloc;
 

src/storage.rs

@@ -1,2 +1,28 @@
-pub mod dex_db;
-pub mod nvs;
+struct MemoryRegion {
+    offset: u32,
+    size: usize,
+}
+
+impl MemoryRegion {
+    const fn end(&self) -> usize {
+        self.offset as usize + self.size
+    }
+}
+
+const MAX_FLASH: usize = 16 * 1024 * 1024;
+
+const MAGIC_REGION: MemoryRegion = MemoryRegion { offset: 0, size: 4 };
+
+const SETTINGS_REGION: MemoryRegion = MemoryRegion {
+    offset: MAGIC_REGION.end() as u32,
+    size: 1024,
+};
+
+const CARDSTORE_REGION: MemoryRegion = MemoryRegion {
+    offset: SETTINGS_REGION.end() as u32,
+    size: MAX_FLASH - SETTINGS_REGION.end(),
+};
+
+pub mod cardstore;
+pub mod settings;
+pub mod store;

src/storage/cardstore.rs

@@ -0,0 +1,133 @@
+use alloc::collections::BTreeMap; 
+use alloc::vec::Vec;
+
+use binary_serde::{BinarySerde, Endianness, DeserializeError};
+
+//use crate::card::model::Nfcraw_card;
+
+use crate::card::model::RawCard;
+use crate::storage::store::{Store, StoreError};
+
+use crate::storage::{MemoryRegion,CARDSTORE_REGION};
+
+const MAX_CARDS: usize = 20000;
+
+const COUNT_REGION: MemoryRegion = MemoryRegion { offset: CARDSTORE_REGION.offset, size: size_of::<u32>()};
+
+#[derive(Debug, BinarySerde, PartialEq, Eq, Clone)]
+#[repr(C)]
+pub struct AllocationTableEntry {
+    uuid: u32,
+    // this is the numeric offset of the AllocationTableEntry 
+    // as well as the card entry in flash memory
+    // size_of::<AllocationTableEntry>() * offset
+    // size_of::<RawCard>() * offset
+    offset: u32,
+
+    creation_date: u64,
+    last_read_date: u64,
+    
+    // how often a card has been read by nfc
+    read_count: u32,
+
+    deleted: bool,
+
+    reserved: [u64; 4],
+}
+
+impl AllocationTableEntry {
+    fn new(uuid: u32, offset: u32, timestamp: u64) -> Self {
+        Self {
+            uuid, offset, creation_date: timestamp, last_read_date: timestamp, read_count: 0, deleted: true, reserved: [0; 4]
+        }
+    }
+}
+
+
+const ALLOCATION_TABLE_REGION: MemoryRegion = MemoryRegion {offset: COUNT_REGION.end() as u32, size: MAX_CARDS * AllocationTableEntry::SERIALIZED_SIZE};
+
+const CARDS_REGION: MemoryRegion = MemoryRegion { offset: ALLOCATION_TABLE_REGION.end() as u32, size: CARDSTORE_REGION.size - ALLOCATION_TABLE_REGION.end()};
+
+#[derive(Debug)]
+pub enum CardStoreError {
+    Store(StoreError),
+    CorruptedEntry(DeserializeError),
+    NoEntry
+}
+
+impl From<StoreError> for CardStoreError {    
+    fn from(error: StoreError) -> CardStoreError { 
+        CardStoreError::Store(error)    
+    }
+}
+
+impl From<DeserializeError> for CardStoreError {    
+    fn from(error: DeserializeError) -> CardStoreError { 
+        CardStoreError::CorruptedEntry(error)    
+    }
+}
+
+pub struct CardStore {
+    store: Store,
+    count: u32,
+    pub allocation_table: BTreeMap<u32, AllocationTableEntry>
+}
+
+impl CardStore {
+    pub fn new(mut store: Store) -> Result<Self, CardStoreError> {
+        let mut count_bytes: [u8; COUNT_REGION.size] = [0; COUNT_REGION.size];
+
+        store.read(COUNT_REGION.offset,  &mut count_bytes)?;
+
+        let count: u32 = u32::from_ne_bytes(count_bytes);
+
+        let mut allocation_table_entries: Vec<u8> = Vec::with_capacity(AllocationTableEntry::SERIALIZED_SIZE * count as usize);
+
+        store
+            .read(ALLOCATION_TABLE_REGION.offset, &mut allocation_table_entries)?;
+
+        let chunks = allocation_table_entries.into_chunks::<{ AllocationTableEntry::SERIALIZED_SIZE }>();
+
+        let mut allocation_table = BTreeMap::<u32, AllocationTableEntry>::new();
+        for chunk in chunks {
+            let allocation_table_entry = AllocationTableEntry::binary_deserialize(chunk.as_ref(), Endianness::Little)?;
+            allocation_table.insert(allocation_table_entry.uuid, allocation_table_entry);
+        }
+
+        Ok(Self { store, count, allocation_table })
+    }
+
+    pub fn get_card_by_uuid(&mut self, uuid: u32) -> Result<RawCard, CardStoreError> {
+        let entry = self.allocation_table.get(&uuid).ok_or(CardStoreError::NoEntry)?;
+
+        let mut raw_card: [u8; size_of::<RawCard>()] = [0; size_of::<RawCard>()];
+        self.store.read(entry.offset, &mut raw_card)?;
+
+        Ok(RawCard::binary_deserialize(raw_card.as_ref(), Endianness::Little)?)
+    }
+
+    pub fn save_raw_card(&mut self, raw_card: RawCard, timestamp: u64) -> Result<(), CardStoreError> {
+
+        let uuid: u32 = (u16::from_ne_bytes(raw_card.event_encoding) as u32) << 16 | (u16::from_ne_bytes(raw_card.card_uuid) as u32);
+        let entry = match self.allocation_table.values_mut().find(|entry| entry.deleted) {
+            Some(entry) => entry,
+            None => {
+                let entry = AllocationTableEntry::new(uuid, self.count + 1, timestamp);
+                self.allocation_table.insert(uuid, entry);
+                self.allocation_table.get_mut(&uuid).expect("entry was just inserted")
+            }
+        };
+        entry.deleted = false;
+
+        let mut serialized_card: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE];
+        raw_card.binary_serialize(&mut serialized_card, Endianness::Little);
+        self.store.write(CARDS_REGION.offset + entry.offset * RawCard::SERIALIZED_SIZE as u32, &mut serialized_card)?;
+
+        let mut serialized_entry: [u8; AllocationTableEntry::SERIALIZED_SIZE] = [0; AllocationTableEntry::SERIALIZED_SIZE];
+        entry.binary_serialize(&mut serialized_entry, Endianness::Little);
+        self.store.write(ALLOCATION_TABLE_REGION.offset + entry.offset * AllocationTableEntry::SERIALIZED_SIZE as u32, &mut serialized_entry)?;
+
+        self.count += 1;
+        Ok(())
+    }
+}

src/storage/dex_db.rs

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

src/storage/nvs.rs

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

src/storage/store.rs

@@ -0,0 +1,44 @@
+use embedded_storage::nor_flash::NorFlash;
+use embedded_storage::nor_flash::ReadNorFlash;
+use esp_storage::{FlashStorage, FlashStorageError};
+
+pub type StoreError = FlashStorageError;
+
+const FLASH_ADDR: u32 = 0x9000;
+
+const INITIALIZATION_SIZE: usize = 0x1004;
+const FLASH_INITIALIZE_MAGIC: u32 = 0xde6de6de;
+
+pub struct Store {
+    pub storage: FlashStorage<'static>,
+}
+
+fn initialize_flash(storage: &mut FlashStorage) -> Result<(), StoreError> {
+    let zeros: [u8; INITIALIZATION_SIZE] = [0; INITIALIZATION_SIZE];
+    storage.write(FLASH_ADDR, &zeros)?;
+    storage.write(FLASH_ADDR, &FLASH_INITIALIZE_MAGIC.to_ne_bytes())?;
+    Ok(())
+}
+
+impl Store {
+    pub fn new(flash: esp_hal::peripherals::FLASH<'static>) -> Result<Self, StoreError> {
+        let mut storage = FlashStorage::new(flash);
+
+        let mut magic: [u8; 4] = [0, 0, 0, 0];
+        storage.read(FLASH_ADDR, &mut magic)?;
+
+        if (u32::from_ne_bytes(magic)) != FLASH_INITIALIZE_MAGIC {
+            initialize_flash(&mut storage)?;
+        }
+
+        Ok(Self { storage })
+    }
+
+    pub fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
+        self.storage.read(FLASH_ADDR + offset, bytes)
+    }
+
+    pub fn write(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), StoreError> {
+        self.storage.write(FLASH_ADDR + offset, bytes)
+    }
+}