add peripherals module which has shared state of all peripherals

src/peripherals/storage.rs

@@ -0,0 +1,32 @@
+pub struct MemoryRegion {
+    offset: u32,
+    size: usize,
+}
+
+impl MemoryRegion {
+    pub const fn new(offset: u32, size: usize) -> Self {
+        assert!(offset.is_multiple_of(4), "Flash requires 4 bytes alignment");
+        assert!(size.is_multiple_of(4), "Flash requires 4 bytes alignment");
+        Self { offset, size }
+    }
+
+    pub const fn end(&self) -> usize {
+        self.offset as usize + self.size
+    }
+}
+
+const MAX_FLASH: usize = 16 * 1024 * 1024;
+
+const MAGIC_REGION: MemoryRegion = MemoryRegion::new(0, 4);
+
+const SETTINGS_REGION: MemoryRegion = MemoryRegion::new(MAGIC_REGION.end() as u32, 1024);
+
+const CARDSTORE_REGION: MemoryRegion = MemoryRegion::new(
+    SETTINGS_REGION.end() as u32,
+    MAX_FLASH - SETTINGS_REGION.end(),
+);
+
+pub mod cardstore;
+pub mod flash_store;
+pub mod settings;
+pub mod store;

src/peripherals/storage/cardstore.rs

@@ -0,0 +1,221 @@
+use alloc::collections::BTreeMap;
+use alloc::vec::Vec;
+
+use binary_serde::{BinarySerde, DeserializeError, Endianness};
+
+//use crate::card::model::Nfcraw_card;
+
+use crate::card::model::RawCard;
+use crate::peripherals::storage::flash_store::{FlashStore, FlashStoreError};
+
+use crate::peripherals::storage::{CARDSTORE_REGION, MemoryRegion};
+
+const MAX_CARDS: usize = 20000;
+
+pub const COUNT_REGION: MemoryRegion = MemoryRegion::new(CARDSTORE_REGION.offset, size_of::<u32>());
+
+const ALLOCATION_TABLE_REGION: MemoryRegion = MemoryRegion::new(
+    COUNT_REGION.end() as u32,
+    MAX_CARDS * AllocationTableEntry::SERIALIZED_SIZE,
+);
+
+const CARDS_REGION: MemoryRegion = MemoryRegion::new(
+    ALLOCATION_TABLE_REGION.end() as u32,
+    CARDSTORE_REGION.size - ALLOCATION_TABLE_REGION.end(),
+);
+
+#[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],
+    _padding: [u8; 3],
+}
+
+static_assertions::const_assert!(AllocationTableEntry::SERIALIZED_SIZE.is_multiple_of(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: Default::default(),
+            _padding: Default::default(),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum CardStoreError {
+    Store(FlashStoreError),
+    CorruptedEntry(DeserializeError),
+    NoEntry,
+}
+
+impl From<FlashStoreError> for CardStoreError {
+    fn from(error: FlashStoreError) -> CardStoreError {
+        CardStoreError::Store(error)
+    }
+}
+
+impl From<DeserializeError> for CardStoreError {
+    fn from(error: DeserializeError) -> CardStoreError {
+        CardStoreError::CorruptedEntry(error)
+    }
+}
+
+pub struct CardStore {
+    store: &'static FlashStore,
+    count: u32,
+    pub allocation_table: BTreeMap<u32, AllocationTableEntry>,
+}
+
+impl CardStore {
+    pub async fn new(store: &'static FlashStore) -> Result<Self, CardStoreError> {
+        let mut count_bytes: [u8; COUNT_REGION.size] = [0; COUNT_REGION.size];
+
+        store.read(COUNT_REGION.offset, &mut count_bytes).await?;
+
+        let count: u32 = u32::from_ne_bytes(count_bytes);
+
+        log::info!("Found {count} cards in flash.");
+
+        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,
+            )
+            .await?;
+
+        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 async fn get_card_by_uuid(&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).await?;
+
+        Ok(RawCard::binary_deserialize(
+            raw_card.as_ref(),
+            Endianness::Little,
+        )?)
+    }
+
+    pub async 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);
+        log::info!("Saving card with uuid {:x}", uuid);
+
+        // check if we already got the card
+        // if not find the next deleted entry,
+        // if none create a new one at the end
+        let (entry, is_new) = match self.allocation_table.get_mut(&uuid) {
+            Some(entry) => {
+                log::debug!("old entry");
+                (entry, false)
+            }
+            None => match self
+                .allocation_table
+                .values_mut()
+                .find(|entry| entry.deleted)
+            {
+                Some(entry) => {
+                    log::debug!("deleted entry");
+                    (entry, true)
+                }
+                None => {
+                    log::debug!("new entry");
+                    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"),
+                        true,
+                    )
+                }
+            },
+        };
+
+        // only write card data if it is new. else it is already written in flash
+        if is_new {
+            log::debug!("writing RawCard to flash");
+            let mut serialized_card: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE];
+            raw_card.binary_serialize(&mut serialized_card, Endianness::Little);
+            self.store
+                .write_erase(
+                    CARDS_REGION.offset + entry.offset * RawCard::SERIALIZED_SIZE as u32,
+                    &mut serialized_card,
+                )
+                .await?;
+        } else {
+            entry.last_read_date = timestamp;
+            entry.read_count += 1;
+        }
+
+        entry.deleted = false;
+
+        log::debug!("writing AllocationTableEntry to flash");
+        let mut serialized_entry: [u8; AllocationTableEntry::SERIALIZED_SIZE] =
+            [0; AllocationTableEntry::SERIALIZED_SIZE];
+        entry.binary_serialize(&mut serialized_entry, Endianness::Little);
+        self.store
+            .write_erase(
+                ALLOCATION_TABLE_REGION.offset
+                    + entry.offset * AllocationTableEntry::SERIALIZED_SIZE as u32,
+                &mut serialized_entry,
+            )
+            .await?;
+
+        self.count += 1;
+        log::debug!("writing card count to flash");
+        let mut serialized_count: [u8; 4] = self.count.to_le_bytes();
+        self.store
+            .write(COUNT_REGION.offset, serialized_count.as_mut_slice())
+            .await?;
+        Ok(())
+    }
+}

src/peripherals/storage/flash_store.rs

@@ -0,0 +1,81 @@
+use crate::navigation::navigation::Mutex;
+use embedded_storage::nor_flash::NorFlash;
+use embedded_storage::nor_flash::ReadNorFlash;
+use esp_storage::{FlashStorage, FlashStorageError};
+
+use crate::peripherals::storage::MAGIC_REGION;
+
+pub type FlashStoreError = FlashStorageError;
+
+const FLASH_ADDR: u32 = 0x9000;
+
+const INITIALIZATION_SIZE: usize = 0x1000;
+const FLASH_INITIALIZE_MAGIC: u32 = 0xde6de6de;
+
+pub struct FlashStore {
+    pub storage: Mutex<FlashStorage<'static>>,
+}
+
+impl FlashStore {
+    pub fn new(flash: esp_hal::peripherals::FLASH<'static>) -> Result<Self, FlashStoreError> {
+        let mut storage = FlashStorage::new(flash);
+
+        let mut magic: [u8; 4] = [0, 0, 0, 0];
+        storage.read(FLASH_ADDR + MAGIC_REGION.offset, &mut magic)?;
+        log::debug!("Magic bytes are {magic:?}");
+
+        if Self::has_magic_bytes(&mut storage)? {
+            log::info!("Skipped flash initialization, magic bytes already present.");
+        } else {
+            log::info!("Initializing flash because no magic bytes found.");
+            Self::initialize_flash(&mut storage)?;
+        }
+
+        Ok(Self {
+            storage: Mutex::new(storage),
+        })
+    }
+
+    pub async fn read(&self, offset: u32, bytes: &mut [u8]) -> Result<(), FlashStoreError> {
+        self.storage.lock().await.read(FLASH_ADDR + offset, bytes)
+    }
+
+    pub async fn write(&self, offset: u32, bytes: &mut [u8]) -> Result<(), FlashStoreError> {
+        log::debug!("Writing {} bytes at offset 0x{offset:08x}", bytes.len());
+        self.storage.lock().await.write(FLASH_ADDR + offset, bytes)
+    }
+
+    pub async fn write_erase(&self, offset: u32, bytes: &mut [u8]) -> Result<(), FlashStoreError> {
+        log::debug!(
+            "Erasing and Writing {} bytes at offset 0x{offset:08x}",
+            bytes.len()
+        );
+        let mut lock = self.storage.lock().await;
+        lock.erase(FLASH_ADDR + offset, FLASH_ADDR + bytes.len() as u32)?;
+        lock.write(FLASH_ADDR + offset, bytes)
+    }
+
+    pub fn has_magic_bytes(storage: &mut FlashStorage) -> Result<bool, FlashStoreError> {
+        let mut magic: [u8; 4] = [0, 0, 0, 0];
+        storage.read(FLASH_ADDR + MAGIC_REGION.offset, &mut magic)?;
+        log::debug!("Magic bytes are {magic:?}");
+
+        Ok(u32::from_ne_bytes(magic) == FLASH_INITIALIZE_MAGIC)
+    }
+
+    pub fn initialize_flash(storage: &mut FlashStorage) -> Result<(), FlashStoreError> {
+        storage.erase(FLASH_ADDR, FLASH_ADDR + INITIALIZATION_SIZE as u32)?;
+        let zeros: [u8; INITIALIZATION_SIZE] = [0; INITIALIZATION_SIZE];
+        storage.write(FLASH_ADDR + MAGIC_REGION.end() as u32, &zeros)?;
+        storage.write(
+            FLASH_ADDR + MAGIC_REGION.offset,
+            &FLASH_INITIALIZE_MAGIC.to_ne_bytes(),
+        )?;
+
+        if Self::has_magic_bytes(storage)? {
+            Ok(())
+        } else {
+            Err(FlashStoreError::Other(FLASH_INITIALIZE_MAGIC as i32))
+        }
+    }
+}

src/peripherals/storage/store.rs

@@ -0,0 +1,7 @@
+use crate::peripherals::storage::cardstore::CardStore;
+use crate::peripherals::storage::flash_store::FlashStore;
+
+pub struct Store {
+    pub flash_store: &'static FlashStore,
+    pub card_store: CardStore,
+}