implement journal view skelleton

Cargo.lock

@@ -306,6 +306,7 @@ dependencies = [
  "critical-section",
  "display-interface-spi",
  "embassy-executor",
+ "embassy-futures",
  "embassy-time",
  "embedded-graphics",
  "embedded-graphics-core",
@@ -1530,27 +1531,27 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "futures-core"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cd50c473c80f6d7c3670a752354b8e569b1a7cbfdc0419ec88e5edad85e0dc7"
+checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e"
 
 [[package]]
 name = "futures-sink"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e34418ac499d6305c2fb5ad0ed2f6ac998c5f8ca209b4510f7f94242c647e307"
+checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d"
 
 [[package]]
 name = "futures-task"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b231ed28831efb4a61a08580c4bc233ec56bc009f4cd8f52da2c3cb97df0c109"
+checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd"
 
 [[package]]
 name = "futures-util"
-version = "0.3.33"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a77a90a256fce34da66415271e30f94ee91c57b04b8a2c042d9cf3220179deaa"
+checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc"
 dependencies = [
  "futures-core",
  "futures-task",

Cargo.toml

@@ -9,7 +9,7 @@ name = "creaturedex"
 path = "./src/bin/main.rs"
 
 [dependencies]
-esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] }
+esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
 
 esp-rtos = { version = "0.3.0", features = [
   "embassy",
@@ -24,8 +24,10 @@ log                    = "0.4.27"
 
 critical-section = "1.2.0"
 embedded-io = "0.7.1"
-embassy-executor = { version = "0.10.0", default-features = false }
+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 = [
   "ap",
@@ -42,9 +44,6 @@ base64 = { version = "0.22", default-features = false, features = ["alloc"] }
 pn532 = "0.5.0"
 ndef = "0.5.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.
@@ -59,4 +58,4 @@ opt-level     = 's'
 
 [features]
 default = []
-wokwi = []
+wokwi = []

diagram.json

@@ -1,37 +1,82 @@
 {
-  "version": 1,
-  "author": "CreatureDex",
-  "editor": "wokwi",
-  "parts": [
-    {
-      "type": "board-esp32-s3-devkitc-1",
-      "id": "esp1",
-      "top": 67.2,
-      "left": -263.96,
-      "attrs": {}
-    },
-    { "type": "wokwi-ili9341", "id": "lcd1", "top": -191.24, "left": -0.38, "attrs": {} },
-    {
-      "type": "wokwi-pushbutton",
-      "id": "btn1",
-      "top": 131,
-      "left": -124.8,
-      "attrs": { "color": "green", "xray": "1", "key": "1" }
-    }
-  ],
-  "connections": [
-    [ "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" ] ],
-    [ "btn1:1.l", "esp1:GND.2", "green", [ "h-9.6", "v-48" ] ],
-    [ "btn1:2.l", "esp1:38", "green", [ "h-9.6", "v19.4" ] ]
-  ],
-  "dependencies": {}
-}
+"version": 1,
+"author": "CreatureDex",
+"editor": "wokwi",
+"parts": [
+  {
+    "type": "board-esp32-s3-devkitc-1",
+    "id": "esp1",
+    "top": 67.2,
+    "left": -263.96,
+    "attrs": {}
+  },
+  { "type": "wokwi-ili9341", "id": "lcd1", "top": -200.8, "left": 354.9, "attrs": {} },
+  {
+    "type": "wokwi-pushbutton",
+    "id": "btn-up",
+    "top": -99.4,
+    "left": -76.8,
+    "attrs": { "color": "RebeccaPurple", "xray": "1", "key": "1", "label": "Up" }
+  },
+  {
+    "type": "wokwi-pushbutton",
+    "id": "btn-down",
+    "top": 25.4,
+    "left": -76.8,
+    "attrs": { "color": "green", "xray": "1", "key": "1", "label": "Down" }
+  },
+  {
+    "type": "wokwi-pushbutton",
+    "id": "btn-left",
+    "top": -32.2,
+    "left": -163.2,
+    "attrs": { "color": "yellow", "xray": "1", "key": "1", "label": "Left" }
+  },
+  {
+    "type": "wokwi-pushbutton",
+    "id": "btn-right",
+    "top": -32.2,
+    "left": 19.2,
+    "attrs": { "color": "red", "xray": "1", "key": "1", "label": "Right" }
+  },
+  {
+    "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": [
+  [ "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": {}
+}

src/bin/main.rs

@@ -7,21 +7,24 @@
 )]
 #![deny(clippy::large_stack_frames)]
 
+use alloc::boxed::Box;
 use creaturedex::card::mock::{MOCK_PAYLOAD, MOCK_PAYLOAD2};
-use creaturedex::display::primary_lcd::init_primary_lcd;
-use creaturedex::display::views::card_view::render_nfc_payload;
+use creaturedex::display::primary_lcd::{PrimaryLcdDisplay, init_primary_lcd};
 use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
-use creaturedex::navigation::input::init_navigation_button;
+use creaturedex::navigation::inputs::Inputs;
+use creaturedex::navigation::navigation;
 use creaturedex::navigation::state::NavigationState;
 use creaturedex::network::wifi::setup_wifi;
+use creaturedex::views::card_view::render_nfc_payload;
 use embassy_executor::Spawner;
 use embassy_time::Timer;
 use embedded_graphics::draw_target::DrawTarget;
 use embedded_graphics::pixelcolor::Rgb565;
 use embedded_graphics::prelude::RgbColor;
-use esp_hal::time::Duration;
 use esp_hal::clock::CpuClock;
 use esp_hal::delay::Delay;
+use esp_hal::gpio::{Input, InputConfig, Pull};
+use esp_hal::time::Duration;
 use esp_hal::timer::timg::TimerGroup;
 use log::error;
 
@@ -33,6 +36,8 @@ 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!();
@@ -48,27 +53,14 @@ async fn main(spawner: Spawner) {
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
     let peripherals = esp_hal::init(config);
 
-    // The following GPIO pins are in use by some feature of the module and should not be used.
-    let _ = peripherals.GPIO27;
-    let _ = peripherals.GPIO28;
-    let _ = peripherals.GPIO29;
-    let _ = peripherals.GPIO30;
-    let _ = peripherals.GPIO31;
-    let _ = peripherals.GPIO32;
-    let _ = peripherals.GPIO33;
-    let _ = peripherals.GPIO34;
+    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: HEAP_SIZE);
 
-    esp_alloc::heap_allocator!(#[esp_hal::ram(reclaimed)] size: 73744);
-
-    let mut delay = Delay::new();
-    let button1 = init_navigation_button(peripherals.GPIO38);
-
-    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 display = init_primary_lcd(
+    let display: &mut PrimaryLcdDisplay = Box::leak(Box::new(init_primary_lcd(
         peripherals.SPI2,
         peripherals.GPIO36,
         peripherals.GPIO35,
@@ -76,16 +68,12 @@ async fn main(spawner: Spawner) {
         peripherals.GPIO11,
         peripherals.GPIO10,
         peripherals.GPIO12,
-        &mut delay,
-    );
+    )));
 
-    setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
+    //setup_wifi(peripherals.WIFI, peripherals.FLASH, &spawner).await;
 
-    log::info!("Setup complete, entering main loop");
-
-    let mut nav_state = NavigationState::new();
-
-    let mut nfc_driver  = NfcPn532Driver::new(peripherals.I2C0, peripherals.GPIO17, peripherals.GPIO18);
+    let mut nfc_driver =
+        NfcPn532Driver::new(peripherals.I2C0, peripherals.GPIO17, peripherals.GPIO18);
     let timeout = Duration::from_millis(1000);
     if nfc_driver.configure_sam(timeout).is_ok() {
         log::info!("NFC SAM configuration successful");
@@ -93,22 +81,18 @@ async fn main(spawner: Spawner) {
         log::error!("NFC SAM configuration failed");
     }
 
-    loop {
-        if let Ok(card_data) = nfc_driver.read_card_data() {
-            log::info!("NFC Card Read: {:?}", card_data);
-        }
+    let mut nav_state = NavigationState::new();
 
-        if button1.is_low() {
-            log::info!("Button pressed!");
-            display.clear(Rgb565::BLACK).unwrap();
-            let payload = if nav_state.toggle_payload() {
-                &MOCK_PAYLOAD
-            } else {
-                &MOCK_PAYLOAD2
-            };
+    let button_config = InputConfig::default().with_pull(Pull::Up);
+    let inputs = Inputs {
+        up: Input::new(peripherals.GPIO38, button_config.clone()),
+        down: Input::new(peripherals.GPIO39, button_config.clone()),
+        left: Input::new(peripherals.GPIO40, button_config.clone()),
+        right: Input::new(peripherals.GPIO41, button_config.clone()),
+        back: Input::new(peripherals.GPIO42, button_config.clone()),
+        ok: Input::new(peripherals.GPIO45, button_config.clone()),
+    };
 
-            render_nfc_payload(&mut display, payload);
-        }
-        Timer::after_millis(10).await;
-    }
+    log::info!("Setup complete, entering main loop");
+    spawner.spawn(navigation::run(inputs, display).expect("run task failed"));
 }

src/card/model.rs

@@ -1,3 +1,5 @@
+use alloc::{string::String, vec::Vec};
+
 #[derive(Debug, Clone, Copy)]
 pub struct NfcPayload<'a> {
     pub event_encoding: &'a [u8],
@@ -9,3 +11,34 @@ pub struct NfcPayload<'a> {
     pub secret: &'a [u8],
     pub _opaque_trailer: &'a [u8],
 }
+
+#[derive(Debug, Clone)]
+pub enum CardType {
+    Default,
+    Blueprint,
+    CYBER,
+    Nature,
+    Fossil,
+    Ghost,
+    Daemon,
+    Fairy,
+}
+
+#[derive(Debug, Clone)]
+pub struct Sprite {
+    pub data: Vec<u8>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Card {
+    pub uuid: String,
+    pub name: String,
+    pub cardtype: CardType,
+
+    pub trait1: String,
+    pub trait2: String,
+    pub trait3: String,
+    pub secret: String,
+
+    pub sprite: Sprite,
+}

src/display.rs

@@ -3,4 +3,3 @@ pub mod primary_lcd;
 pub mod secondary_oled;
 pub mod sprite;
 pub mod tertiary_lcd;
-pub mod views;

src/display/primary_lcd.rs

@@ -6,15 +6,15 @@ 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::{master::{Config, Spi}, Mode};
+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>,
-    >,
+    SPIInterface<ExclusiveDevice<Spi<'a, esp_hal::Blocking>, Output<'a>, Delay>, Output<'a>>,
     Output<'a>,
 >;
 
@@ -26,7 +26,6 @@ pub fn init_primary_lcd(
     cs: GPIO11<'static>,
     reset: GPIO10<'static>,
     dc: GPIO12<'static>,
-    delay: &mut Delay,
 ) -> PrimaryLcdDisplay<'static> {
     let freq = Rate::from_khz(60_000);
     log::info!("Display freq: {freq}");
@@ -40,8 +39,10 @@ pub fn init_primary_lcd(
     .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 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);
@@ -49,7 +50,7 @@ pub fn init_primary_lcd(
     let mut display = Ili9341::new(
         iface,
         reset_main,
-        delay,
+        &mut delay,
         Orientation::Portrait,
         DisplaySize240x320,
     )

src/display/views.rs

@@ -1,3 +0,0 @@
-pub mod card_view;
-pub mod menu_view;
-pub mod status_bar;

src/display/views/menu_view.rs

@@ -1 +0,0 @@
-// Menu view module

src/lib.rs

@@ -8,3 +8,4 @@ pub mod drivers;
 pub mod navigation;
 pub mod network;
 pub mod storage;
+pub mod views;

src/navigation.rs

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

src/navigation/input.rs

@@ -1,15 +0,0 @@
-use esp_hal::gpio::{Input, InputConfig, Pull};
-use esp_hal::peripherals::GPIO38;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum NavCommand {
-    NextCard,
-    PrevCard,
-    Select,
-    ScanTag,
-}
-
-pub fn init_navigation_button(pin: GPIO38<'static>) -> Input<'static> {
-    let button_config = InputConfig::default().with_pull(Pull::Up);
-    Input::new(pin, button_config)
-}

src/navigation/inputs.rs

@@ -0,0 +1,19 @@
+use esp_hal::gpio::{Input, InputConfig, Pull};
+use esp_hal::peripherals::Peripherals;
+
+#[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>,
+}

src/navigation/navigation.rs

@@ -0,0 +1,75 @@
+use crate::navigation::state::NavigationState;
+use crate::views::view::View;
+use crate::{display::primary_lcd::PrimaryLcdDisplay, navigation::inputs::Inputs};
+
+use embassy_futures::select::Either6;
+use embassy_futures::select::select6;
+use embassy_time::{Duration, Timer};
+
+const DEBOUNCE_DURATION_MILLIS: u64 = 100;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Action {
+    Up,
+    Down,
+    Left,
+    Right,
+    Ok,
+    Back,
+}
+
+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 = View> + 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 = select6(
+            inputs.up.wait_for_low(),
+            inputs.down.wait_for_low(),
+            inputs.left.wait_for_low(),
+            inputs.right.wait_for_low(),
+            inputs.ok.wait_for_low(),
+            inputs.back.wait_for_low(),
+        )
+        .await;
+
+        let action = match selection {
+            Either6::First(_) => Action::Up,
+            Either6::Second(_) => Action::Down,
+            Either6::Third(_) => Action::Left,
+            Either6::Fourth(_) => Action::Right,
+            Either6::Fifth(_) => Action::Ok,
+            Either6::Sixth(_) => Action::Back,
+        };
+
+        log::info!("Action: {:?}", action);
+
+        let screen = match action {
+            Action::Back => state.back(),
+            _ => {
+                state
+                    .screens
+                    .last()
+                    .expect("no screen on stack")
+                    .handle_input(action)
+                    .await
+            }
+        };
+
+        screen.display(display).await;
+        state.screens.push(screen);
+
+        Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)).await;
+    }
+}

src/navigation/state.rs

@@ -1,23 +1,16 @@
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ScreenMode {
-    CardDetail,
-    DexGrid,
-    Settings,
-}
+use crate::views::{main_menu::MainMenu, view::View};
+use alloc::vec;
+use alloc::vec::Vec;
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub struct NavigationState {
-    pub current_screen: ScreenMode,
-    pub card_index: usize,
-    pub use_first_payload: bool,
+    pub screens: Vec<View>,
 }
 
 impl Default for NavigationState {
     fn default() -> Self {
         Self {
-            current_screen: ScreenMode::CardDetail,
-            card_index: 0,
-            use_first_payload: true,
+            screens: vec![View::Main(MainMenu { selected: 0 })],
         }
     }
 }
@@ -27,9 +20,12 @@ impl NavigationState {
         Self::default()
     }
 
-    pub fn toggle_payload(&mut self) -> bool {
-        let current = self.use_first_payload;
-        self.use_first_payload = !self.use_first_payload;
-        current
+    pub fn back(&mut self) -> View {
+        let screen = self.screens.pop().unwrap();
+        if self.screens.is_empty() {
+            log::info!("last screen");
+            return screen;
+        }
+        self.screens.pop().unwrap()
     }
 }

src/views.rs

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

@@ -0,0 +1,40 @@
+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},
+    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 = View> + Send {
+        let new_menu = match input {
+            Action::Ok => View::Journal(self.clone()),
+            _ => View::Journal(self.clone()),
+        };
+
+        future::ready(new_menu)
+    }
+}

src/views/main_menu.rs

@@ -0,0 +1,66 @@
+use alloc::vec;
+use core::future;
+
+use crate::display::primary_lcd::PrimaryLcdDisplay;
+
+use crate::views::journal_view::JournalView;
+use crate::views::{menu_item, settings_menu::SettingsMenu, view::View};
+
+use crate::navigation::navigation::{Action, Navigable};
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+use embedded_graphics_core::draw_target::DrawTarget;
+
+pub const MAX_SELECTED: i32 = 3;
+
+#[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, "Last card", 0, self.selected);
+        menu_item::show(display, "Journal", 1, self.selected);
+        menu_item::show(display, "Settings", 2, self.selected);
+
+        core::future::ready(())
+    }
+
+    fn handle_input(&self, input: Action) -> impl core::future::Future<Output = View> + Send {
+        let new_menu = match input {
+            Action::Up => {
+                let new_selected = if (self.selected - 1) < 0 {
+                    MAX_SELECTED - 1
+                } else {
+                    self.selected - 1
+                };
+                View::Main(MainMenu {
+                    selected: new_selected,
+                })
+            }
+            Action::Down => {
+                let new_selected = self.selected.wrapping_add(1) % MAX_SELECTED;
+                View::Main(MainMenu {
+                    selected: new_selected,
+                })
+            }
+            Action::Ok => match self.selected {
+                1 => View::Journal(JournalView {
+                    cards: vec![],
+                    selected_card: 0,
+                }),
+                2 => View::Settings(SettingsMenu { selected: 0 }),
+                _ => View::Main(self.clone()),
+            },
+            _ => View::Main(self.clone()),
+        };
+
+        future::ready(new_menu)
+    }
+}

src/views/menu_item.rs

@@ -0,0 +1,33 @@
+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, geometry::Size, primitives::Rectangle};
+use embedded_graphics_core::draw_target::DrawTarget;
+
+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

@@ -0,0 +1,97 @@
+use crate::display::primary_lcd::PrimaryLcdDisplay;
+
+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 = View> + Send {
+        async move {
+            let new_progress = match input {
+                Action::Up => self.progress.wrapping_add(5),
+                _ => self.progress,
+            };
+
+            View::Scan(ScanMenu {
+                progress: new_progress,
+            })
+        }
+    }
+}

src/views/settings_menu.rs

@@ -0,0 +1,31 @@
+use crate::display::primary_lcd::PrimaryLcdDisplay;
+
+use crate::navigation::navigation::{Action, Navigable};
+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 = View> + Send {
+        async move { View::Settings(SettingsMenu { selected: 0 }) }
+    }
+}

src/views/view.rs

@@ -0,0 +1,44 @@
+use crate::views::{
+    journal_view::JournalView, main_menu::MainMenu, scan_menu::ScanMenu,
+    settings_menu::SettingsMenu,
+};
+
+use crate::navigation::navigation::Navigable;
+
+#[derive(Debug, Clone)]
+pub enum View {
+    Main(MainMenu),
+    Scan(ScanMenu),
+    Settings(SettingsMenu),
+    Journal(JournalView),
+}
+
+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,
+            }
+        }
+    }
+
+    fn handle_input(
+        &self,
+        input: crate::navigation::navigation::Action,
+    ) -> impl core::future::Future<Output = Self> + 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,
+            }
+        }
+    }
+}