implement simple card storage retreival

src/bin/main.rs

@@ -19,6 +19,8 @@ use creaturedex::navigation::inputs::Inputs;
 use creaturedex::navigation::navigation::{self};
 use creaturedex::navigation::outputs::Outputs;
 use creaturedex::network::wifi::setup_wifi;
+use creaturedex::storage::cardstore::CardStore;
+use creaturedex::storage::store::Store;
 use embassy_executor::Spawner;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::{
@@ -102,7 +104,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() {

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,73 @@
+use alloc::collections::BTreeMap; use embedded_storage::nor_flash::ReadNorFlash;
+use alloc::vec::Vec;
+
+use binary_serde::{BinarySerde, Endianness};
+
+//use crate::card::model::NfcPayload;
+
+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, Default, PartialEq, Eq)]
+#[repr(C)]
+struct AllocationTableEntry {
+    uuid: u32,
+    offset: u32,
+
+    creation_date: u64,
+    last_read_date: u64,
+    
+    // how often a card has been read
+    read_count: u32,
+
+    deleted: bool,
+
+    reserved: [u64; 4],
+}
+
+const ALLOCATION_TABLE_SIZE: usize = size_of::<AllocationTableEntry>();
+
+const ALLOCATION_TABLE_REGION: MemoryRegion = MemoryRegion {offset: COUNT_REGION.end() as u32, size: MAX_CARDS * size_of::<AllocationTableEntry>()};
+
+const CARDS_REGION: MemoryRegion = MemoryRegion { offset: ALLOCATION_TABLE_REGION.end() as u32, size: CARDSTORE_REGION.size - ALLOCATION_TABLE_REGION.end()};
+
+pub struct CardStore {
+    store: Store,
+    count: usize,
+    allocation_table: BTreeMap<u32, AllocationTableEntry>
+}
+
+impl CardStore {
+    pub fn new(mut store: Store) -> Result<Self, StoreError> {
+        let mut count_bytes: [u8; COUNT_REGION.size] = [0; COUNT_REGION.size];
+
+        store.read(COUNT_REGION.offset,  &mut count_bytes)?;
+
+        let count: usize = usize::from_ne_bytes(count_bytes);
+
+        let mut allocation_table_entries: Vec<u8> = Vec::with_capacity(ALLOCATION_TABLE_SIZE * count);
+
+        store
+            .read(ALLOCATION_TABLE_REGION.offset, &mut allocation_table_entries)?;
+
+        let chunks = allocation_table_entries.into_chunks::<ALLOCATION_TABLE_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).unwrap();
+            allocation_table.insert(allocation_table_entry.uuid, allocation_table_entry);
+        }
+
+        Ok(Self { store, count, allocation_table })
+    }
+
+    //fn get_card_by_uuid(uuid: &str) {}
+
+    //fn get_card_by_position(position: usize) {}
+    
+}

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,40 @@
+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)
+    }
+}