Add shared reset pin

Cargo.lock

@@ -1702,8 +1702,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 [[package]]
 name = "i2c-character-display"
 version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86a620ec16541e28c0e52ce21cd23d734a5d7efaae3d609b2a58694b0ef67739"
+source = "git+https://github.com/ede1998/i2c-character-display.git?rev=57aef1f49da183c120b8e995ef77549e3515d3c6#57aef1f49da183c120b8e995ef77549e3515d3c6"
 dependencies = [
  "bitfield 0.17.0",
  "embedded-hal 1.0.0",

Cargo.toml

@@ -52,6 +52,7 @@ ch1115 = { version = "0.1.2", features = ["graphics"] }
 
 [patch.crates-io]
 ch1115 = { git = "https://github.com/ede1998/ch1115.git", rev = "2d3a3ba38050efe012e6a210afe3e125ec280c37" }
+i2c-character-display = { git = "https://github.com/ede1998/i2c-character-display.git", rev = "57aef1f49da183c120b8e995ef77549e3515d3c6" }
 
 # For fine tuning these settings, please refer to https://doc.rust-lang.org/cargo/reference/profiles.html
 [profile.dev]

src/bin/main.rs

@@ -10,11 +10,12 @@
 use alloc::boxed::Box;
 use creaturedex::card::decoder::split_nfc_hex;
 use creaturedex::card::model::Card;
-use creaturedex::display::shared_bus::{DualSecondaryDisplay, init_dual_displays};
-use creaturedex::display::tertiary_lcd::{init_tertiary_lcd, write_wrapped};
+use creaturedex::display::shared_bus::{self, DualSecondaryDisplay};
+use creaturedex::display::tertiary_lcd::{TertiaryI2cLcd, init_tertiary_lcd, write_wrapped};
 use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
 use creaturedex::navigation::inputs::Inputs;
 use creaturedex::navigation::navigation::{self, CARD_DATA};
+use creaturedex::navigation::outputs::Outputs;
 use creaturedex::network::wifi::setup_wifi;
 use embassy_executor::Spawner;
 use embassy_time::Instant;
@@ -28,7 +29,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, Level, Output, OutputConfig, Pull};
+use esp_hal::gpio::{Input, InputConfig, Pull};
 use esp_hal::i2c::master::{Config as I2cConfig, I2c};
 use esp_hal::timer::timg::TimerGroup;
 use log::error;
@@ -65,28 +66,20 @@ async fn main(spawner: Spawner) {
     let timg0 = TimerGroup::new(peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
 
-    let (display, oled) = Box::leak(Box::new(init_dual_displays(
-        peripherals.SPI2,
-        peripherals.GPIO36, // sck
-        peripherals.GPIO35, // mosi
-        peripherals.GPIO37, // miso
-        peripherals.GPIO11, // primary cs
-        peripherals.GPIO13, // oled cs
-        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 (display, mut oled) = shared_bus::DisplayPinConfiguration {
+        spi_peripheral: peripherals.SPI2,
+        sck: peripherals.GPIO36,
+        mosi: peripherals.GPIO35,
+        miso: peripherals.GPIO37,
+        cs_primary: peripherals.GPIO11,
+        cs_secondary_1: peripherals.GPIO13,
+        cs_secondary_2: peripherals.GPIO14,
+        cs_secondary_3: peripherals.GPIO21,
+        reset_primary: peripherals.GPIO10,
+        reset_secondary: peripherals.GPIO47,
+        dc_pin: peripherals.GPIO12,
+    }
+    .build();
 
     let config = I2cConfig::default().with_frequency(esp_hal::time::Rate::from_khz(400));
     let i2c = match I2c::new(peripherals.I2C0, config) {
@@ -101,10 +94,10 @@ async fn main(spawner: Spawner) {
     let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
     log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
 
-    let mut lcd = init_tertiary_lcd(AtomicDevice::new(shared_i2c));
-    if let Err(_) = write_wrapped(&mut lcd, "Testing more than 16 chars what happens now?") {
+    let mut lcd: TertiaryI2cLcd = init_tertiary_lcd(AtomicDevice::new(shared_i2c));
+    if let Err(e) = write_wrapped(&mut lcd, "Testing more than 16 chars what happens now?") {
         log::error!(
-            "Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses"
+            "Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses: {e}"
         );
     }
 
@@ -127,14 +120,27 @@ async fn main(spawner: Spawner) {
         ok: Input::new(peripherals.GPIO0, button_config),
     };
 
-    display_shit(oled);
+    display_shit(&mut oled);
+
+    let outputs = Outputs {
+        primary_display: display,
+        secondary_display_1: oled,
+        // secondary_display_2: todo!(),
+        // secondary_display_3: todo!(),
+        tertiary_display: lcd,
+        _led_a: (),
+    };
 
     log::info!("Setup complete, entering main loop");
-    spawner.spawn(navigation::run(inputs, display).expect("run task failed"));
+    spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
     spawner.spawn(nfc_driver_task(nfc_driver).expect("nfc driver task failed"));
 }
 
 #[embassy_executor::task]
+#[allow(
+    clippy::large_stack_frames,
+    reason = "ignoring this for now because it still works"
+)]
 async fn nfc_driver_task(
     mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>,
 ) {

src/card/model.rs

@@ -48,9 +48,9 @@ impl Display for CardType {
 }
 
 pub type PrimaryColor = Rgb565;
-impl Into<PrimaryColor> for CardType {
-    fn into(self) -> PrimaryColor {
-        match self {
+impl From<CardType> for PrimaryColor {
+    fn from(val: CardType) -> Self {
+        match val {
             CardType::Default => Rgb888::new(0xD8, 0x68, 0x30).into(),
             CardType::Blueprint => Rgb888::new(0x6D, 0x81, 0xFF).into(),
             CardType::CYBER => Rgb888::new(0xFF, 0xFF, 0x04).into(),
@@ -64,9 +64,9 @@ impl Into<PrimaryColor> for CardType {
 }
 
 pub type Palette = [Rgb565; 16];
-impl Into<Palette> for CardType {
-    fn into(self) -> Palette {
-        match self {
+impl From<CardType> for Palette {
+    fn from(val: CardType) -> Self {
+        match val {
             CardType::Default => [
                 Rgb888::new(31, 23, 35).into(),
                 Rgb888::new(60, 47, 82).into(),

src/display/shared_bus.rs

@@ -10,25 +10,27 @@ use esp_hal::spi::Mode;
 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 crate::display::secondary_oled::{SecondaryOledDisplay, init_secondary_oled_on_bus};
 
 use core::cell::RefCell;
 use embassy_sync::blocking_mutex::Mutex as BlockingMutex;
 
-#[derive(Clone)]
 pub struct SharedPin<'a, P> {
     mutex: &'a BlockingMutex<CriticalSectionRawMutex, RefCell<P>>,
 }
 
-impl<'a, P> SharedPin<'a, P> {
-    pub fn new(mutex: &'a BlockingMutex<CriticalSectionRawMutex, RefCell<P>>) -> Self {
-        Self { mutex }
+impl<'a, P> Clone for SharedPin<'a, P> {
+    fn clone(&self) -> Self {
+        Self { mutex: self.mutex }
     }
+}
 
-    pub fn pre_wrap(pin: P) -> &'static BlockingMutex<CriticalSectionRawMutex, RefCell<P>> {
+impl<'a, P> SharedPin<'a, P> {
+    pub fn new(pin: P) -> Self {
         let mutexed = BlockingMutex::new(RefCell::new(pin));
-        Box::leak(Box::new(mutexed))
+        let mutex = Box::leak(Box::new(mutexed));
+        Self { mutex }
     }
 }
 
@@ -46,68 +48,144 @@ impl<'a, P: EhOutputPin> EhOutputPin for SharedPin<'a, P> {
     }
 }
 
+pub struct SharedResetPin<'a, P> {
+    mutex: &'a BlockingMutex<CriticalSectionRawMutex, RefCell<(P, bool)>>,
+}
+
+impl<'a, P> SharedResetPin<'a, P> {
+    pub fn new(pin: P, disabled: bool) -> Self {
+        let mutexed = BlockingMutex::new(RefCell::new((pin, disabled)));
+        let mutex = Box::leak(Box::new(mutexed));
+        Self { mutex }
+    }
+
+    pub fn disable(&self, disabled: bool) {
+        self.mutex.lock(|p| {
+            p.borrow_mut().1 = disabled;
+        });
+        if disabled {
+            log::debug!("Reset pin disabled (masked). No more resets now.");
+        } else {
+            log::debug!("Reset pin enabled (unmasked). Reset now possible.");
+        }
+    }
+}
+
+impl<'a, P> Clone for SharedResetPin<'a, P> {
+    fn clone(&self) -> Self {
+        Self { mutex: self.mutex }
+    }
+}
+
+impl<'a, P: EhOutputPin> ErrorType for SharedResetPin<'a, P> {
+    type Error = P::Error;
+}
+
+impl<'a, P: EhOutputPin> EhOutputPin for SharedResetPin<'a, P> {
+    fn set_low(&mut self) -> Result<(), Self::Error> {
+        self.mutex.lock(|p| {
+            let mut guard = p.borrow_mut();
+            let disabled = guard.1;
+            let pin = &mut guard.0;
+            if !disabled { pin.set_low() } else { Ok(()) }
+        })
+    }
+
+    fn set_high(&mut self) -> Result<(), Self::Error> {
+        self.mutex.lock(|p| {
+            let mut guard = p.borrow_mut();
+            let disabled = guard.1;
+            let pin = &mut guard.0;
+            if !disabled { pin.set_high() } else { Ok(()) }
+        })
+    }
+}
+
+type SharedOutput<'a> = SharedPin<'a, Output<'a>>;
+type SharedReset<'a> = SharedResetPin<'a, Output<'a>>;
 pub type DisplaySpiBus = Spi<'static, esp_hal::Blocking>;
 pub type DualPrimaryDisplay<'a> =
-    PrimaryLcdDisplay<'a, DisplaySpiBus, SharedPin<'a, Output<'a>>, SharedPin<'a, Output<'a>>>;
+    PrimaryLcdDisplay<'a, DisplaySpiBus, SharedOutput<'a>, Output<'a>>;
 pub type DualSecondaryDisplay<'a> =
-    SecondaryOledDisplay<'a, DisplaySpiBus, SharedPin<'a, Output<'a>>, SharedPin<'a, Output<'a>>>;
+    SecondaryOledDisplay<'a, DisplaySpiBus, SharedReset<'a>, SharedOutput<'a>>;
 
-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_primary: RES1,
-    reset_secondary: RES2,
-    dc_pin: DC,
-) -> (DualPrimaryDisplay<'static>, DualSecondaryDisplay<'static>)
+pub struct DisplayPinConfiguration<SPI, SCK, MOSI, MISO, CS0, CS1, CS2, CS3, RES1, RES2, DC> {
+    pub spi_peripheral: SPI,
+    pub sck: SCK,
+    pub mosi: MOSI,
+    pub miso: MISO,
+    pub cs_primary: CS0,
+    pub cs_secondary_1: CS1,
+    pub cs_secondary_2: CS2,
+    pub cs_secondary_3: CS3,
+    pub reset_primary: RES1,
+    pub reset_secondary: RES2,
+    pub dc_pin: DC,
+}
+
+impl<SPI, SCK, MOSI, MISO, CS0, CS1, CS2, CS3, RES1, RES2, DC>
+    DisplayPinConfiguration<SPI, SCK, MOSI, MISO, CS0, CS1, CS2, CS3, RES1, RES2, DC>
 where
     SPI: esp_hal::spi::master::Instance + 'static,
     SCK: PeripheralOutput<'static>,
     MOSI: PeripheralOutput<'static>,
     MISO: PeripheralInput<'static>,
+    CS0: OutputPin + 'static,
     CS1: OutputPin + 'static,
     CS2: OutputPin + 'static,
+    CS3: OutputPin + 'static,
     RES1: OutputPin + 'static,
     RES2: OutputPin + 'static,
     DC: OutputPin + 'static,
 {
-    let spi = Spi::new(
-        spi_peripheral,
-        SpiConfig::default()
-            .with_frequency(Rate::from_khz(20_000))
-            .with_mode(Mode::_0),
-    )
-    .unwrap()
-    .with_sck(sck)
-    .with_mosi(mosi)
-    .with_miso(miso);
+    pub fn build(self) -> (DualPrimaryDisplay<'static>, DualSecondaryDisplay<'static>) {
+        let spi = Spi::new(
+            self.spi_peripheral,
+            SpiConfig::default()
+                .with_frequency(Rate::from_khz(20_000))
+                .with_mode(Mode::_0),
+        )
+        .unwrap()
+        .with_sck(self.sck)
+        .with_mosi(self.mosi)
+        .with_miso(self.miso);
 
-    let bus_static: &'static AtomicCell<_> = Box::leak(Box::new(AtomicCell::new(spi)));
-    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 bus_static: &'static AtomicCell<_> = Box::leak(Box::new(AtomicCell::new(spi)));
+        let reset_primary = Output::new(self.reset_primary, Level::High, OutputConfig::default());
+        let reset_secondary = SharedResetPin::new(
+            Output::new(self.reset_secondary, Level::High, OutputConfig::default()),
+            false,
+        );
+        let dc = SharedPin::new(Output::new(
+            self.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_primary_static),
-        SharedPin::new(dc_static),
-        &mut delay,
-    );
+        let primary = init_primary_lcd_on_bus(
+            bus_static,
+            self.cs_primary,
+            reset_primary,
+            dc.clone(),
+            &mut delay,
+        );
 
-    let secondary = init_secondary_oled_on_bus(
-        bus_static,
-        cs_secondary,
-        SharedPin::new(reset_secondary_static),
-        SharedPin::new(dc_static),
-        &mut delay,
-    );
+        // TODO
+        // Build display
+        // Trigger reset
+        // disable init
+        // rest of init code
 
-    (primary, secondary)
+
+        let secondary = init_secondary_oled_on_bus(
+            bus_static,
+            self.cs_secondary_1,
+            reset_secondary,
+            dc,
+            &mut delay,
+        );
+
+        (primary, secondary)
+    }
 }

src/display/tertiary_lcd.rs

@@ -1,9 +1,11 @@
 use embedded_hal::i2c::I2c;
+use embedded_hal_bus::i2c::AtomicDevice;
 use esp_hal::delay::Delay;
 use i2c_character_display::{CharacterDisplayPCF8574T, LcdDisplayType};
 use log::error;
 
 pub type TertiaryLcd<I2C> = CharacterDisplayPCF8574T<I2C, Delay>;
+pub type TertiaryI2cLcd<'a> = TertiaryLcd<AtomicDevice<'a, esp_hal::i2c::master::I2c<'a, esp_hal::Blocking>>>;
 
 pub fn init_tertiary_lcd<I2C>(i2c: I2C) -> TertiaryLcd<I2C>
 where

src/navigation.rs

@@ -1,3 +1,4 @@
 pub mod inputs;
 pub mod navigation;
 pub mod state;
+pub mod outputs;

src/navigation/navigation.rs

@@ -1,15 +1,13 @@
 use crate::card::model::Card;
-use crate::display::shared_bus::DualPrimaryDisplay;
 use crate::navigation::inputs::ButtonAction;
 use crate::navigation::inputs::Inputs;
+use crate::navigation::outputs::Outputs;
 use crate::navigation::state::NavigationState;
 use crate::views::view::View;
 
 use embassy_futures::select::{Either, select};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_time::{Duration, Timer};
-use embedded_graphics::draw_target::DrawTarget;
-use embedded_graphics::pixelcolor::Rgb565;
 
 pub type Mutex<T> = embassy_sync::mutex::Mutex<CriticalSectionRawMutex, T>;
 pub type Signal<T> = embassy_sync::signal::Signal<CriticalSectionRawMutex, T>;
@@ -29,19 +27,16 @@ pub struct NewState {
 }
 
 pub trait Navigable {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565> + Send,
-        D::Error: core::fmt::Debug;
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send;
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send;
 }
 
 #[embassy_executor::task]
-pub async fn run(mut inputs: Inputs, display: &'static mut DualPrimaryDisplay<'static>) {
+pub async fn run(mut inputs: Inputs, mut outputs: Outputs) {
     log::info!("starting navigation");
 
     let mut state = NavigationState::new();
-    state.screens.last().unwrap().display(display).await;
+    state.screens.last().unwrap().display(&mut outputs).await;
 
     loop {
         let selection = select(
@@ -87,7 +82,7 @@ pub async fn run(mut inputs: Inputs, display: &'static mut DualPrimaryDisplay<'s
         state.screens.push(new_state.view);
 
         if action != Action::Timer || new_state.redraw {
-            state.screens.last().unwrap().display(display).await;
+            state.screens.last().unwrap().display(&mut outputs).await;
         }
 
         Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)).await;

src/navigation/outputs.rs

@@ -0,0 +1,28 @@
+use embedded_graphics::{
+    draw_target::DrawTarget as _,
+    pixelcolor::{Rgb565, RgbColor as _},
+};
+
+use crate::display::{
+    shared_bus::{DualPrimaryDisplay, DualSecondaryDisplay},
+    tertiary_lcd::TertiaryI2cLcd,
+};
+
+pub struct Outputs {
+    pub primary_display: DualPrimaryDisplay<'static>,
+    pub secondary_display_1: DualSecondaryDisplay<'static>,
+    // pub secondary_display_2: DualSecondaryDisplay<'static>,
+    // pub secondary_display_3: DualSecondaryDisplay<'static>,
+    pub tertiary_display: TertiaryI2cLcd<'static>,
+    pub _led_a: (),
+}
+
+impl Outputs {
+    pub fn clear_screens(&mut self) {
+        self.primary_display.clear(Rgb565::BLACK).unwrap();
+        self.secondary_display_1.clear().unwrap();
+        // self.secondary_display_2.clear().unwrap();
+        // self.secondary_display_3.clear().unwrap();
+        self.tertiary_display.clear().unwrap();
+    }
+}

src/navigation/state.rs

@@ -24,16 +24,16 @@ impl NavigationState {
         match &self.screens.len() {
             0 => {
                 log::info!("No screens to go back to");
-                return self.screens.last().unwrap();
+                self.screens.last().unwrap()
             }
             1 => {
                 log::info!("Only one screen on stack, cannot go back");
-                return self.screens.last().unwrap();
+                self.screens.last().unwrap()
             }
             _ => {
                 log::info!("Going back to previous screen");
                 self.screens.pop();
-                return self.screens.last().unwrap();
+                self.screens.last().unwrap()
             }
         }
     }

src/views/card_view.rs

@@ -1,5 +1,6 @@
 use crate::display::sprite::render_sprite_onto_ili9341;
 use crate::navigation::navigation::NewState;
+use crate::navigation::outputs::Outputs;
 use alloc::format;
 use embedded_graphics::mono_font::MonoTextStyle;
 use embedded_graphics::mono_font::ascii::FONT_6X10;
@@ -24,80 +25,77 @@ pub struct CardView {
 }
 
 impl Navigable for CardView {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
-    {
-        display.clear(Rgb565::BLACK).unwrap();
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        async move {
+            let display = &mut outputs.primary_display;
+            display.clear(Rgb565::BLACK).unwrap();
 
-        let background = Rectangle::new(Point::new(0, 0), Size::new(240, 320));
-        let bg_color = self.card.cardtype.clone().into();
+            let background = Rectangle::new(Point::new(0, 0), Size::new(240, 320));
+            let bg_color = self.card.cardtype.clone().into();
 
-        let _ = display.fill_solid(&background, bg_color);
+            let _ = display.fill_solid(&background, bg_color);
 
-        let style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
-        Text::new(
-            &format!("Name: {}", self.card.name),
-            Point::new(20, 240),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!("Type: {}", self.card.cardtype),
-            Point::new(20, 250),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!("Event: {}", self.card.event),
-            Point::new(20, 260),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!("UUID: {}", self.card.uuid),
-            Point::new(20, 270),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!("Trait1: {}", self.card.trait1),
-            Point::new(20, 280),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!("Trait2: {}", self.card.trait2),
-            Point::new(20, 290),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!("Trait3: {}", self.card.trait3),
-            Point::new(20, 300),
-            style,
-        )
-        .draw(display)
-        .unwrap();
-        Text::new(
-            &format!("Secret: {}", self.card.secret),
-            Point::new(20, 310),
-            style,
-        )
-        .draw(display)
-        .unwrap();
+            let style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
+            Text::new(
+                &format!("Name: {}", self.card.name),
+                Point::new(20, 240),
+                style,
+            )
+            .draw(display)
+            .unwrap();
+            Text::new(
+                &format!("Type: {}", self.card.cardtype),
+                Point::new(20, 250),
+                style,
+            )
+            .draw(display)
+            .unwrap();
+            Text::new(
+                &format!("Event: {}", self.card.event),
+                Point::new(20, 260),
+                style,
+            )
+            .draw(display)
+            .unwrap();
+            Text::new(
+                &format!("UUID: {}", self.card.uuid),
+                Point::new(20, 270),
+                style,
+            )
+            .draw(display)
+            .unwrap();
+            Text::new(
+                &format!("Trait1: {}", self.card.trait1),
+                Point::new(20, 280),
+                style,
+            )
+            .draw(display)
+            .unwrap();
+            Text::new(
+                &format!("Trait2: {}", self.card.trait2),
+                Point::new(20, 290),
+                style,
+            )
+            .draw(display)
+            .unwrap();
+            Text::new(
+                &format!("Trait3: {}", self.card.trait3),
+                Point::new(20, 300),
+                style,
+            )
+            .draw(display)
+            .unwrap();
+            Text::new(
+                &format!("Secret: {}", self.card.secret),
+                Point::new(20, 310),
+                style,
+            )
+            .draw(display)
+            .unwrap();
 
-        let palette: Palette = self.card.cardtype.clone().into();
-        render_sprite_onto_ili9341(display, self.card.sprite.data.as_slice(), &palette);
-
-        core::future::ready(())
+            let palette: Palette = self.card.cardtype.clone().into();
+            render_sprite_onto_ili9341(display, self.card.sprite.data.as_slice(), &palette);
+        }
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/journal_view.rs

@@ -7,9 +7,7 @@ use embedded_graphics::prelude::RgbColor;
 use embedded_graphics_core::draw_target::DrawTarget;
 
 use crate::{
-    card::model::Card,
-    navigation::navigation::{Action, Navigable, NewState},
-    views::view::View,
+    card::model::Card, navigation::{navigation::{Action, Navigable, NewState}, outputs::Outputs}, views::view::View,
 };
 
 #[derive(Debug, Clone)]
@@ -19,14 +17,10 @@ pub struct JournalView {
 }
 
 impl Navigable for JournalView {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
-    {
-        display.clear(Rgb565::BLACK).unwrap();
-
-        core::future::ready(())
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        async move {
+            outputs.primary_display.clear(Rgb565::BLACK).unwrap();
+        }
     }
 
     fn handle_input(&self, input: Action) -> impl core::future::Future<Output = NewState> + Send {

src/views/main_menu.rs

@@ -4,6 +4,7 @@ use crate::card::model::Card;
 use crate::card::{decoder::split_nfc_hex, mock::*};
 
 use crate::navigation::inputs::ButtonAction;
+use crate::navigation::outputs::Outputs;
 use crate::views::card_view::CardView;
 use crate::views::journal_view::JournalView;
 use crate::views::{menu_item, settings_menu::SettingsMenu, view::View};
@@ -21,11 +22,9 @@ pub struct MainMenu {
 }
 
 impl Navigable for MainMenu {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send
     {
+        let display = &mut outputs.primary_display;
         display.clear(Rgb565::BLACK).unwrap();
 
         menu_item::show(display, "Scan card", 0, self.selected);

src/views/menu_item.rs

@@ -7,7 +7,7 @@ use embedded_graphics::prelude::Point;
 use embedded_graphics::prelude::RgbColor;
 use embedded_graphics::text::Text;
 
-pub fn show<'a, D>(display: &mut D, name: &str, position: i32, selected: i32)
+pub fn show<D>(display: &mut D, name: &str, position: i32, selected: i32)
 where
     D: DrawTarget<Color = Rgb565>,
     D::Error: core::fmt::Debug,

src/views/scan_menu.rs

@@ -1,10 +1,12 @@
 use crate::navigation::inputs::ButtonAction;
 use crate::navigation::navigation::CARD_DATA;
 use crate::navigation::navigation::NewState;
+use crate::navigation::outputs::Outputs;
 
 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;
@@ -31,11 +33,9 @@ pub struct ScanMenu {
 }
 
 impl Navigable for ScanMenu {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send
     {
+        let display = &mut outputs.primary_display;
         let style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
         display.clear(Rgb565::BLACK).unwrap();
 

src/views/settings_menu.rs

@@ -1,4 +1,5 @@
 use crate::navigation::navigation::{Action, Navigable, NewState};
+use crate::navigation::outputs::Outputs;
 use crate::views::{menu_item, view::View};
 
 use embedded_graphics::pixelcolor::Rgb565;
@@ -12,11 +13,8 @@ pub struct SettingsMenu {
 }
 
 impl Navigable for SettingsMenu {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565>,
-        D::Error: core::fmt::Debug,
-    {
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
+        let display = &mut outputs.primary_display;
         display.clear(Rgb565::BLACK).unwrap();
         menu_item::show(display, "System Inforation", 0, self.selected);
         menu_item::show(display, "Wifi Information", 1, self.selected);

src/views/view.rs

@@ -1,6 +1,5 @@
-use embedded_graphics::draw_target::DrawTarget;
-use embedded_graphics::pixelcolor::Rgb565;
 
+use crate::navigation::outputs::Outputs;
 use crate::views::card_view::CardView;
 use crate::views::{
     journal_view::JournalView, main_menu::MainMenu, scan_menu::ScanMenu,
@@ -19,18 +18,15 @@ pub enum View {
 }
 
 impl Navigable for View {
-    fn display<D>(&self, display: &mut D) -> impl core::future::Future<Output = ()> + Send
-    where
-        D: DrawTarget<Color = Rgb565> + Send,
-        D::Error: core::fmt::Debug,
+    fn display(&self, outputs: &mut Outputs) -> 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,
-                View::Card(card_view) => card_view.display(display).await,
+                View::Main(main_menu) => main_menu.display(outputs).await,
+                View::Scan(scan_menu) => scan_menu.display(outputs).await,
+                View::Settings(settings_menu) => settings_menu.display(outputs).await,
+                View::Journal(journal_view) => journal_view.display(outputs).await,
+                View::Card(card_view) => card_view.display(outputs).await,
             }
         }
     }