From 0aa1370a2b66e891b78dc2b66d19c43c1a2fae4f Mon Sep 17 00:00:00 2001 From: rhetenor Date: Mon, 31 Aug 2026 20:16:42 +0200 Subject: [PATCH] rework card storage to use nvs --- src/background_tasks/nfc.rs | 5 +- src/bin/main.rs | 32 +- src/card/model.rs | 34 ++ src/peripherals/storage.rs | 5 +- src/peripherals/storage/cardstore.rs | 423 ++++++++++++++----------- src/peripherals/storage/flash_store.rs | 14 +- src/peripherals/storage/store.rs | 2 - src/views/flash_info_view.rs | 27 +- 8 files changed, 320 insertions(+), 222 deletions(-) diff --git a/src/background_tasks/nfc.rs b/src/background_tasks/nfc.rs index 5aed664..155a382 100644 --- a/src/background_tasks/nfc.rs +++ b/src/background_tasks/nfc.rs @@ -42,12 +42,13 @@ pub async fn nfc_scanner( }; CARD_DATA.lock().await.replace(card); + log::debug!("saving card to flash"); match peripherals .store .lock() .await .card_store - .save_raw_card(split_data, peripherals.rtc.current_time_us()) + .save_raw_card(&split_data, peripherals.rtc.current_time_us()) .await { Ok(()) => {} @@ -75,6 +76,6 @@ pub async fn nfc_scanner( } } } - embassy_time::Timer::after(embassy_time::Duration::from_millis(1000)).await; + embassy_time::Timer::after(embassy_time::Duration::from_millis(10)).await; } } diff --git a/src/bin/main.rs b/src/bin/main.rs index e833a09..7795f69 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -17,14 +17,13 @@ use creaturedex::drivers::spi_bus; use creaturedex::drivers::tertiary_lcd::{ BOX, EMPTY, EXAMPLE, HEART, TertiaryDisplay, TertiaryDisplayPinConfiguration, }; -use creaturedex::navigation::navigation::Mutex; use creaturedex::navigation::inputs::Inputs; +use creaturedex::navigation::navigation::Mutex; use creaturedex::navigation::navigation::{self}; -use creaturedex::navigation::state::NavigationState; use creaturedex::navigation::outputs::Outputs; +use creaturedex::navigation::state::NavigationState; use creaturedex::peripherals::Peripherals; use creaturedex::peripherals::storage::cardstore::CardStore; -use creaturedex::peripherals::storage::flash_store::FlashStore; use creaturedex::peripherals::storage::store::Store; use embassy_executor::Spawner; use embedded_graphics::pixelcolor::BinaryColor; @@ -51,6 +50,9 @@ extern crate alloc; const HEAP_SIZE: usize = 73744; +const NVS_PARTITION_OFFSET: usize = 0x10000; +const NVS_PARTITION_SIZE: usize = 0xfa000; + // This creates a default app-descriptor required by the esp-idf bootloader. // For more information see: esp_bootloader_esp_idf::esp_app_desc!(); @@ -122,18 +124,18 @@ async fn main(spawner: Spawner) { ); } - let flash_store = Box::leak(Box::new( - FlashStore::new(esp_peripherals.FLASH).expect("Could not initialize Flash Store"), - )); + let storage = esp_storage::FlashStorage::new(esp_peripherals.FLASH); - let card_store = CardStore::new(flash_store) + let nvs = Mutex::new( + esp_nvs::Nvs::new(NVS_PARTITION_OFFSET, NVS_PARTITION_SIZE, storage) + .expect("failed to create nvs"), + ); + + let card_store = CardStore::new(nvs) .await .expect("Could not initialize Card Store"); - let store = Store { - flash_store, - card_store, - }; + let store = Store { card_store }; let rtc = Rtc::new(esp_peripherals.LPWR); //setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await; @@ -179,10 +181,14 @@ async fn main(spawner: Spawner) { let navigation_state = Box::leak(Box::new(Mutex::new(NavigationState::new()))); log::info!("Setup complete, entering main loop"); - spawner.spawn(navigation::run(inputs, outputs, peripherals, navigation_state).expect("run task failed")); spawner.spawn( - background_tasks::nfc_scanner(nfc_driver, outputs, peripherals, navigation_state).expect("nfc scanner task failed"), + navigation::run(inputs, outputs, peripherals, navigation_state).expect("run task failed"), ); + spawner.spawn( + background_tasks::nfc_scanner(nfc_driver, outputs, peripherals, navigation_state) + .expect("nfc scanner task failed"), + ); + core::future::pending::<()>().await } diff --git a/src/card/model.rs b/src/card/model.rs index 101152e..47f5329 100644 --- a/src/card/model.rs +++ b/src/card/model.rs @@ -1,4 +1,6 @@ +use base64::prelude::*; use core::fmt::Display; +use esp_nvs::Key; use alloc::{string::String, vec::Vec}; use num_enum::FromPrimitive; @@ -22,6 +24,38 @@ pub struct RawCard { pub _padding: [u8; 2], } +impl Default for RawCard { + fn default() -> Self { + Self { + event_encoding: Default::default(), + card_type: Default::default(), + card_uuid: Default::default(), + _reserved: Default::default(), + sprite: [0; 722], + packed_card_text: [0; 54], + secret: Default::default(), + _opaque_trailer: [0; 49], + _padding: Default::default(), + } + } +} + +impl RawCard { + pub fn get_uuid(&self) -> u32 { + ((u16::from_ne_bytes(self.event_encoding) as u32) << 16) + | (u16::from_ne_bytes(self.card_uuid) as u32) + } + + pub fn get_nvs_key(&self) -> Key { + let uuid = self.get_uuid(); + Self::nvs_key_from_uuid(uuid) + } + + pub fn nvs_key_from_uuid(uuid: u32) -> Key { + let base64 = BASE64_STANDARD.encode(uuid.to_ne_bytes()); + Key::from_str(&base64) + } +} static_assertions::const_assert!(RawCard::SERIALIZED_SIZE.is_multiple_of(4)); #[derive(Debug, Clone, Eq, PartialEq, FromPrimitive)] diff --git a/src/peripherals/storage.rs b/src/peripherals/storage.rs index 9e4b528..9e491df 100644 --- a/src/peripherals/storage.rs +++ b/src/peripherals/storage.rs @@ -1,3 +1,5 @@ +use esp_storage::FlashStorage; + pub struct MemoryRegion { pub offset: u32, pub size: usize, @@ -26,7 +28,8 @@ pub const CARDSTORE_REGION: MemoryRegion = MemoryRegion::new( MAX_FLASH - SETTINGS_REGION.end(), ); +pub type Nvs = esp_nvs::Nvs>; + pub mod cardstore; -pub mod flash_store; pub mod settings; pub mod store; diff --git a/src/peripherals/storage/cardstore.rs b/src/peripherals/storage/cardstore.rs index 4d9f2e3..3c1c8ed 100644 --- a/src/peripherals/storage/cardstore.rs +++ b/src/peripherals/storage/cardstore.rs @@ -1,73 +1,24 @@ -use alloc::collections::BTreeMap; +use crate::card::model::RawCard; +use crate::peripherals::Mutex; +use crate::peripherals::storage::Nvs; use alloc::vec::Vec; +use binary_serde::{BinarySerde, DeserializeError, Endianness}; use core::error::Error; use core::fmt::Display; +use esp_nvs::Key; -use binary_serde::{BinarySerde, DeserializeError, Endianness}; +const NVS_NAMESPACE_CARDSTORE: Key = Key::from_str("CARDSTORE"); +const NVS_NAMESPACE_CARDSTORE_METADATA: Key = Key::from_str("CSMETA"); +const NVS_NAMESPACE_CARDSTORE_CARDS: Key = Key::from_str("CSCARDS"); -//use crate::card::model::Nfcraw_card; +const NVS_CARDSTORE_INITIALIZED_KEY: Key = Key::from_str("INITIALIZED"); +const NVS_CARDSTORE_CARDCOUNT_KEY: Key = Key::from_str("CARDCOUNT"); -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::()); - -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::() * offset - // size_of::() * 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(), - } - } -} +const NVS_CARDSTORE_DUMMY_KEY: Key = Key::from_str("DUMMY"); #[derive(Debug)] pub enum CardStoreError { - Store(FlashStoreError), + Store(esp_nvs::error::Error), CorruptedEntry(DeserializeError), NoEntry(u32), } @@ -84,8 +35,8 @@ impl Display for CardStoreError { } } -impl From for CardStoreError { - fn from(error: FlashStoreError) -> CardStoreError { +impl From for CardStoreError { + fn from(error: esp_nvs::error::Error) -> CardStoreError { CardStoreError::Store(error) } } @@ -96,140 +47,256 @@ impl From for CardStoreError { } } +#[derive(Debug, BinarySerde, PartialEq, Eq, Clone)] +pub struct CardStoreMetaData { + pub creation_date: u64, + pub last_read_date: u64, + + // how often a card has been read by nfc + pub read_count: u32, +} + +impl CardStoreMetaData { + fn new(creation_date: u64) -> Self { + Self { + creation_date: creation_date, + last_read_date: creation_date, + read_count: 0, + } + } +} + pub struct CardStore { - store: &'static FlashStore, - count: u32, - pub allocation_table: BTreeMap, + nvs: Mutex, } impl CardStore { - pub async fn new(store: &'static FlashStore) -> Result { - 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 = - 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::::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); + pub async fn new(nvs: Mutex) -> Result { + if !Self::is_initialized(&nvs).await? { + log::info!("CardStore has not been initialized"); + Self::initialize(&nvs).await?; } - Ok(Self { - store, - count, - allocation_table, - }) + log::info!("CardStore has been initialized"); + let card_count = nvs + .lock() + .await + .get::(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?; + log::info!("Cards stored in flash: {card_count}"); + + Ok(Self { nvs }) } - pub async fn get_card_by_uuid(&self, uuid: u32) -> Result { - let entry = self - .allocation_table - .get(&uuid) - .ok_or(CardStoreError::NoEntry(uuid))?; + async fn is_initialized(nvs: &Mutex) -> Result { + log::info!("check initialization"); + let mut nvs_lock = nvs.lock().await; + match nvs_lock.get::(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_INITIALIZED_KEY) { + Ok(initialized) => { + log::debug!("initialization_check: initialized {initialized:?}"); + return Ok(true); + } + Err(esp_nvs::error::Error::NamespaceNotFound) => { + log::debug!("initialization_check: error: namespace not found"); + return Ok(false); + } + Err(esp_nvs::error::Error::KeyNotFound) => { + log::debug!("initialization_check: error: key not found"); + return Ok(false); + } + Err(error) => return Err(error.into()), + }; + } - let mut raw_card: [u8; size_of::()] = [0; size_of::()]; - self.store.read(entry.offset, &mut raw_card).await?; + // initializing cardstore with 0 cards, so that all namespaces exist and there + // are only keynotfound errors in the future + async fn initialize(nvs: &Mutex) -> Result<(), CardStoreError> { + log::info!("initializing card store"); - Ok(RawCard::binary_deserialize( - raw_card.as_ref(), - Endianness::Little, - )?) + Self::delete_all_cards(nvs).await?; + + let mut nvs_lock = nvs.lock().await; + + log::debug!("initialization: write card count"); + // initialize card count + nvs_lock.set::(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY, 0)?; + + // initialize card namespace + let dummy_card = RawCard::default(); + let mut carddata_serialized: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE]; + dummy_card.binary_serialize(&mut carddata_serialized, Endianness::Little); + + log::debug!("initialization: write dummy card"); + nvs_lock.set::<&[u8]>( + &NVS_NAMESPACE_CARDSTORE_CARDS, + &NVS_CARDSTORE_DUMMY_KEY, + &carddata_serialized, + )?; + + // initialize metadata namespace + log::debug!("initialization: write dummy metadata"); + let dummy_metadata = CardStoreMetaData::new(0); + + let mut metadata_serialized: [u8; CardStoreMetaData::SERIALIZED_SIZE] = + [0; CardStoreMetaData::SERIALIZED_SIZE]; + + dummy_metadata.binary_serialize(&mut metadata_serialized, Endianness::Little); + + nvs_lock.set::<&[u8]>( + &NVS_NAMESPACE_CARDSTORE_METADATA, + &NVS_CARDSTORE_DUMMY_KEY, + &metadata_serialized, + )?; + + // set initialized + log::debug!("initialization: write initialized"); + nvs_lock.set::( + &NVS_NAMESPACE_CARDSTORE, + &NVS_CARDSTORE_INITIALIZED_KEY, + true, + )?; + + Ok(()) + } + + async fn delete_all_cards(nvs: &Mutex) -> Result<(), CardStoreError> { + log::info!("delete all cards"); + let mut nvs_lock = nvs.lock().await; + let keys = nvs_lock.keys().collect::, _>>()?; + for (namespace, key) in keys { + if namespace == NVS_NAMESPACE_CARDSTORE || namespace == NVS_NAMESPACE_CARDSTORE_METADATA + { + nvs_lock.delete(&namespace, &key)?; + } + } + Ok(()) + } + + pub async fn load_card_count(&self) -> Result { + log::debug!("load card count"); + let mut nvs_lock = self.nvs.lock().await; + let result = nvs_lock.get::(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?; + log::debug!("card count: {result}"); + Ok(result) + } + + pub async fn load_raw_card(&self, uuid: u32) -> Result, CardStoreError> { + log::debug!("load raw card\nuuid: 0x{uuid:x}"); + let nvs_key = RawCard::nvs_key_from_uuid(uuid); + let mut nvs_lock = self.nvs.lock().await; + + let carddata_binary: Vec = match nvs_lock.get(&NVS_NAMESPACE_CARDSTORE_CARDS, &nvs_key) + { + Ok(carddata) => carddata, + Err(esp_nvs::error::Error::KeyNotFound) => return Ok(None), + Err(error) => return Err(error.into()), + }; + + let carddata = RawCard::binary_deserialize(carddata_binary.as_ref(), Endianness::Little)?; + Ok(Some(carddata)) + } + + async fn write_card(&self, nvs_key: Key, card: &RawCard) -> Result<(), CardStoreError> { + log::debug!("writing card...\nkey: {nvs_key:?}"); + let mut carddata_serialized: [u8; RawCard::SERIALIZED_SIZE] = [0; RawCard::SERIALIZED_SIZE]; + card.binary_serialize(&mut carddata_serialized, Endianness::Little); + + self.nvs.lock().await.set::<&[u8]>( + &NVS_NAMESPACE_CARDSTORE_CARDS, + &nvs_key, + &carddata_serialized, + )?; + + Ok(()) + } + + async fn update_card_metadata( + &self, + nvs_key: Key, + timestamp: u64, + ) -> Result { + log::debug!("updating card metadata...\nkey: {nvs_key:?}\ntimestamp: {timestamp}"); + let mut is_new = false; + // update metadata + let metadata: CardStoreMetaData = + if let Some(mut metadata) = self.load_card_metadata(nvs_key).await? { + log::debug!("found existing card"); + metadata.last_read_date = timestamp; + metadata.read_count += 1; + metadata + } else { + log::debug!("new card"); + is_new = true; + CardStoreMetaData::new(timestamp) + }; + + let mut metadata_serialized: [u8; CardStoreMetaData::SERIALIZED_SIZE] = + [0; CardStoreMetaData::SERIALIZED_SIZE]; + + metadata.binary_serialize(&mut metadata_serialized, Endianness::Little); + + self.nvs.lock().await.set::<&[u8]>( + &NVS_NAMESPACE_CARDSTORE_METADATA, + &nvs_key, + &metadata_serialized, + )?; + + Ok(is_new) + } + + async fn increment_card_count(&self) -> Result<(), CardStoreError> { + log::debug!("incrementing card count"); + let card_count: u32 = self.load_card_count().await?; + log::debug!("previous card count: {card_count}"); + self.nvs.lock().await.set::( + &NVS_NAMESPACE_CARDSTORE, + &NVS_CARDSTORE_CARDCOUNT_KEY, + card_count + 1, + )?; + + let card_count = self + .nvs + .lock() + .await + .get::(&NVS_NAMESPACE_CARDSTORE, &NVS_CARDSTORE_CARDCOUNT_KEY)?; + log::info!("Cards stored in flash: {card_count}"); + Ok(()) } pub async fn save_raw_card( - &mut self, - raw_card: RawCard, + &self, + 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); + log::debug!("saving raw card\ntimestamp: {timestamp}"); + let nvs_key = card.get_nvs_key(); - // 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, - ) - } - }, - }; + self.write_card(nvs_key, card).await?; - // 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; + let new_card = self.update_card_metadata(nvs_key, timestamp).await?; + + if new_card { + self.increment_card_count().await?; } - 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(()) } + + pub async fn load_card_metadata( + &self, + nvs_key: Key, + ) -> Result, CardStoreError> { + log::debug!("load card meta data\nkey: {nvs_key:?}"); + let mut nvs_lock = self.nvs.lock().await; + let metadata_binary: Vec = + match nvs_lock.get(&NVS_NAMESPACE_CARDSTORE_METADATA, &nvs_key) { + Ok(metadata) => metadata, + Err(esp_nvs::error::Error::KeyNotFound) => return Ok(None), + Err(error) => return Err(error.into()), + }; + + let metadata = + CardStoreMetaData::binary_deserialize(metadata_binary.as_ref(), Endianness::Little)?; + + Ok(Some(metadata)) + } } diff --git a/src/peripherals/storage/flash_store.rs b/src/peripherals/storage/flash_store.rs index 031afad..60ed958 100644 --- a/src/peripherals/storage/flash_store.rs +++ b/src/peripherals/storage/flash_store.rs @@ -25,7 +25,7 @@ impl Display for FlashStoreError { } } -const FLASH_ADDR: u32 = 0x9000; +const FLASH_ADDR: u32 = 0x200000; const INITIALIZATION_SIZE: usize = 0x1000; const FLASH_INITIALIZE_MAGIC: u32 = 0xde6de6de; @@ -74,11 +74,13 @@ impl FlashStore { bytes.len() ); let mut lock = self.storage.lock().await; - lock.erase( - FLASH_ADDR + offset, - FLASH_ADDR + offset + bytes.len() as u32, - )?; - lock.write(FLASH_ADDR + offset, bytes)?; + let addr = FLASH_ADDR + offset; + let to = FLASH_ADDR + offset + bytes.len() as u32; + log::debug!("Erasing from 0x{addr:x} to 0x{to:x}"); + //lock.erase(addr, to)?; + + log::debug!("Writing bytes..."); + lock.write(addr, bytes)?; Ok(()) } diff --git a/src/peripherals/storage/store.rs b/src/peripherals/storage/store.rs index ddc22bb..211c364 100644 --- a/src/peripherals/storage/store.rs +++ b/src/peripherals/storage/store.rs @@ -1,7 +1,5 @@ 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, } diff --git a/src/views/flash_info_view.rs b/src/views/flash_info_view.rs index ee7b4f9..470712b 100644 --- a/src/views/flash_info_view.rs +++ b/src/views/flash_info_view.rs @@ -5,7 +5,6 @@ use crate::navigation::navigation::NewState; use crate::navigation::outputs::Outputs; use crate::peripherals::Peripherals; use crate::peripherals::storage::MAGIC_REGION; -use crate::peripherals::storage::cardstore::COUNT_REGION; use crate::views::view::View; use alloc::boxed::Box; use core::error; @@ -39,22 +38,6 @@ impl Navigable for FlashInfoView { .clear(Rgb565::BLACK) .map_err(PrimaryDisplayError::from)?; let _style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE); - let mut magic_bytes: [u8; MAGIC_REGION.size] = [0; MAGIC_REGION.size]; - peripherals - .store - .lock() - .await - .flash_store - .read(MAGIC_REGION.offset, &mut magic_bytes) - .await?; - let mut card_count_bytes: [u8; COUNT_REGION.size] = [0; COUNT_REGION.size]; - peripherals - .store - .lock() - .await - .flash_store - .read(COUNT_REGION.offset, &mut card_count_bytes) - .await?; let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE); let textbox_style = TextBoxStyleBuilder::new() @@ -65,14 +48,18 @@ impl Navigable for FlashInfoView { let display_area = outputs.primary_display.bounding_box(); let bounds = Rectangle::new(Point::new(0, 30), display_area.size); + log::debug!("locking store"); + let store = peripherals.store.lock().await; + + log::debug!("getting card count"); + let card_count = store.card_store.load_card_count().await?; + TextBox::with_textbox_style( &format!( " -Flash Init Magic: 0x{:x}\n Card Count: {}\n ", - u32::from_le_bytes(magic_bytes), - u32::from_le_bytes(card_count_bytes) + card_count ), bounds, style, -- 2.39.5