prepare alternative display driver support

rework tertiary display API again
improved char display API
2026-08-26 21:51:01 +02:00 · 2026-08-26 19:39:33 +02:00 · 2026-08-25 01:05:23 +02:00 · 2026-08-24 21:05:59 +02:00 · 2026-08-24 20:55:03 +02:00 · 2026-08-24 20:07:54 +02:00
24 changed files with 1101 additions and 379 deletions
@@ -73,9 +73,9 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"

 [[package]]
 name = "base64"
-version = "0.22.1"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"

 [[package]]
 name = "base64-simd"
@@ -318,9 +318,10 @@ dependencies = [
 name = "creaturedex"
 version = "0.1.0"
 dependencies = [
- "base64 0.22.1",
+ "base64 0.23.1",
 "ch1115",
 "critical-section",
+ "display-interface",
 "display-interface-spi",
 "embassy-executor",
 "embassy-futures",
@@ -341,9 +342,9 @@ dependencies = [
 "i2c-character-display",
 "ili9341",
 "log",
- "ndef",
 "num_enum",
 "pn532",
+ "ssd1306",
 ]

 [[package]]
@@ -592,26 +593,6 @@ dependencies = [
 "syn 2.0.119",
 ]

-[[package]]
-name = "derive_more"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05"
-dependencies = [
- "derive_more-impl",
-]
-
-[[package]]
-name = "derive_more-impl"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.119",
-]
-
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -628,6 +609,17 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ba2aab1ef3793e6f7804162debb5ac5edb93b3d650fbcc5aeb72fcd0e6c03a0"

+[[package]]
+name = "display-interface-i2c"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d964fa85bbbb5a6ecd06e58699407ac5dc3e3ad72dac0ab7e6b0d00a1cd262d"
+dependencies = [
+ "display-interface",
+ "embedded-hal 1.0.0",
+ "embedded-hal-async",
+]
+
 [[package]]
 name = "display-interface-spi"
 version = "0.5.0"
@@ -1701,8 +1693,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

 [[package]]
 name = "i2c-character-display"
-version = "0.5.1"
-source = "git+https://github.com/ede1998/i2c-character-display.git?rev=57aef1f49da183c120b8e995ef77549e3515d3c6#57aef1f49da183c120b8e995ef77549e3515d3c6"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6170902cbfd6e5855a1fa8a75dc68991bb98220c24135a5cf23ce74d32ddcccf"
 dependencies = [
 "bitfield 0.17.0",
 "embedded-hal 1.0.0",
@@ -1962,6 +1955,19 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"

+[[package]]
+name = "maybe-async-cfg"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e083394889336bc66a4eaf1011ffbfa74893e910f902a9f271fa624c61e1b2"
+dependencies = [
+ "proc-macro-error",
+ "proc-macro2",
+ "pulldown-cmark",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "memchr"
 version = "2.8.3"
@@ -2033,17 +2039,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d5439c4ad607c3c23abf66de8c8bf57ba8adcd1f129e699851a6e43935d339d"

-[[package]]
-name = "ndef"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39081400340c14a9fcbb0122c311aca4e34ec2d19e3136613638ae7e2a362dbc"
-dependencies = [
- "derive_more",
- "heapless 0.8.0",
- "rustversion",
-]
-
 [[package]]
 name = "nonmax"
 version = "0.5.5"
@@ -2721,6 +2716,30 @@ dependencies = [
 "toml_edit",
 ]

+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.107"
@@ -2750,6 +2769,17 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "pulldown-cmark"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "679341d22c78c6c649893cbd6c3278dcbe9fc4faa62fea3a9296ae2b50c14625"
+dependencies = [
+ "bitflags 2.13.1",
+ "memchr",
+ "unicase",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.47"
@@ -3164,6 +3194,20 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0f368519fc6c85fc1afdb769fb5a51123f6158013e143656e25a3485a0d401c"

+[[package]]
+name = "ssd1306"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ea6aac2d078bbc71d9b8ac3f657335311f3b6625e9a1a96ccc29f5abfa77c56"
+dependencies = [
+ "display-interface",
+ "display-interface-i2c",
+ "display-interface-spi",
+ "embedded-graphics-core",
+ "embedded-hal 1.0.0",
+ "maybe-async-cfg",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -3431,6 +3475,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e87a2ed6b42ec5e28cc3b94c09982969e9227600b2e3dcbc1db927a84c06bd69"

+[[package]]
+name = "unicase"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+
 [[package]]
 name = "unicode-id-start"
 version = "1.4.0"
@@ -35,24 +35,24 @@ esp-hal-wifimanager = { git = "https://github.com/InvisibleUSA/esp-hal-wifimanag
 ] }
 esp-println = { version = "0.17.0", features = ["esp32s3", "log-04"] }
 display-interface-spi = "0.5.0"
+display-interface = "*"
 ili9341 = "0.6.0"
 embedded-hal = "1.0.0"
 embedded-hal-bus = "0.3.0"
 embedded-graphics = "0.8.2"
 embedded-graphics-core = "0.4.1"
-base64 = { version = "0.22", default-features = false, features = ["alloc"] }
+base64 = { version = "0.23.1", default-features = false, features = ["alloc"] }
 pn532 = "0.5.0"
-ndef = "0.5.0"
 num_enum = { version = "0.7.6", default-features = false }
 embassy-sync = "0.8.0"
 embedded-hal-async = "1.0.0"
 i2c-character-display = "0.5.1"
 ch1115 = { version = "0.1.2", features = ["graphics"] }
+ssd1306 = { version = "0.10.0", features = [] }


 [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]
@@ -0,0 +1,3 @@
+mod nfc;
+
+pub use nfc::nfc_scanner;
@@ -0,0 +1,45 @@
+use embedded_hal_bus::i2c::AtomicDevice;
+use esp_hal::{Blocking, i2c::master::I2c, time::Instant};
+
+use crate::{
+    card::{decoder::split_nfc_hex, model::Card},
+    drivers::nfc_pn532::NfcPn532Driver,
+    navigation::navigation::CARD_DATA,
+};
+
+#[embassy_executor::task]
+#[allow(
+    clippy::large_stack_frames,
+    reason = "ignoring this for now because it still works"
+)]
+pub async fn nfc_scanner(
+    mut nfc_driver: NfcPn532Driver<AtomicDevice<'static, I2c<'static, Blocking>>>,
+) {
+    loop {
+        while CARD_DATA.lock().await.is_none() {
+            let start = Instant::now();
+            match nfc_driver.read_card_data().await {
+                Ok(card_data) => {
+                    let Some(split_data) = split_nfc_hex(&card_data) else {
+                        log::error!("Failed to split NFC card data");
+                        continue;
+                    };
+                    CARD_DATA
+                        .lock()
+                        .await
+                        .replace(Card::try_from(split_data).unwrap());
+                    let elapsed_ms = start.elapsed().as_millis();
+                    log::info!(
+                        "NFC read duration: {} ms, card data length: {}",
+                        elapsed_ms,
+                        card_data.len()
+                    );
+                }
+                Err(e) => {
+                    log::error!("NFC read failed: {e}");
+                }
+            }
+        }
+        embassy_time::Timer::after(embassy_time::Duration::from_millis(1000)).await;
+    }
+}
@@ -7,18 +7,19 @@
 )]
 #![deny(clippy::large_stack_frames)]

-use alloc::boxed::Box;
-use creaturedex::card::decoder::split_nfc_hex;
-use creaturedex::card::model::Card;
-use creaturedex::display::shared_bus::{self, DualSecondaryDisplay};
-use creaturedex::display::tertiary_lcd::{TertiaryI2cLcd, init_tertiary_lcd, write_wrapped};
+use creaturedex::background_tasks;
+use creaturedex::drivers::i2c_bus::I2cBusPinConfiguration;
 use creaturedex::drivers::nfc_pn532::NfcPn532Driver;
+use creaturedex::drivers::secondary_oled::SecondaryDisplay;
+use creaturedex::drivers::spi_bus;
+use creaturedex::drivers::tertiary_lcd::{
+    BOX, EMPTY, EXAMPLE, HEART, TertiaryDisplay, TertiaryDisplayPinConfiguration,
+};
 use creaturedex::navigation::inputs::Inputs;
-use creaturedex::navigation::navigation::{self, CARD_DATA};
+use creaturedex::navigation::navigation::{self};
 use creaturedex::navigation::outputs::Outputs;
 use creaturedex::network::wifi::setup_wifi;
 use embassy_executor::Spawner;
-use embassy_time::Instant;
 use embedded_graphics::pixelcolor::BinaryColor;
 use embedded_graphics::{
    mono_font::{MonoTextStyle, ascii::FONT_6X10},
@@ -26,11 +27,8 @@ use embedded_graphics::{
    text::Text,
 };
 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, Pull};
-use esp_hal::i2c::master::{Config as I2cConfig, I2c};
 use esp_hal::timer::timg::TimerGroup;
 use log::error;

@@ -66,7 +64,7 @@ async fn main(spawner: Spawner) {
    let timg0 = TimerGroup::new(peripherals.TIMG0);
    esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);

-    let (display, mut oled) = shared_bus::DisplayPinConfiguration {
+    let (primary, mut secondaries) = spi_bus::DisplayPinConfiguration {
        spi_peripheral: peripherals.SPI2,
        sck: peripherals.GPIO36,
        mosi: peripherals.GPIO35,
@@ -81,21 +79,22 @@ async fn main(spawner: Spawner) {
    }
    .build();

-    let config = I2cConfig::default().with_frequency(esp_hal::time::Rate::from_khz(400));
-    let i2c = match I2c::new(peripherals.I2C0, config) {
-        Ok(bus) => bus
-            .with_sda(peripherals.GPIO17)
-            .with_scl(peripherals.GPIO18),
-        Err(e) => {
-            log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
-            panic!("Shared I2C bus initialization failed");
-        }
+    // Initialize the shared I2C bus using the refactored i2c_bus module.
+    let shared_i2c = {
+        let config = I2cBusPinConfiguration {
+            i2c_peripheral: peripherals.I2C0,
+            scl: peripherals.GPIO18,
+            sda: peripherals.GPIO17,
+        };
+        config.build()
    };
-    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: TertiaryI2cLcd = init_tertiary_lcd(AtomicDevice::new(shared_i2c));
-    if let Err(e) = write_wrapped(&mut lcd, "Testing more than 16 chars what happens now?") {
+    let mut lcd: TertiaryDisplay = TertiaryDisplayPinConfiguration { i2c: shared_i2c }.build();
+    lcd.load_charset(EXAMPLE).unwrap();
+    let h = EXAMPLE[HEART];
+    let e = EXAMPLE[EMPTY];
+    let b = EXAMPLE[BOX];
+    if let Err(e) = lcd.write(&alloc::format!("Custom symbols: {h}{e}{b} And more stuff to wrap and cut off please.")) {
        log::error!(
            "Tertiary LCD startup text write failed over shared I2C bus; check the shared bus, wiring, and device responses: {e}"
        );
@@ -120,64 +119,32 @@ async fn main(spawner: Spawner) {
        ok: Input::new(peripherals.GPIO0, button_config),
    };

-    display_shit(&mut oled);
+    display_shit(&mut secondaries[0], "foo 1");
+    display_shit(&mut secondaries[1], "bar 1");
+    display_shit(&mut secondaries[2], "baz 1");

-    let outputs = Outputs {
-        primary_display: display,
-        secondary_display_1: oled,
-        // secondary_display_2: todo!(),
-        // secondary_display_3: todo!(),
-        tertiary_display: lcd,
-        _led_a: (),
+    let outputs = {
+        let [sec_1, sec_2, sec_3] = secondaries;
+        Outputs {
+            primary_display: primary,
+            secondary_display_1: sec_1,
+            secondary_display_2: sec_2,
+            secondary_display_3: sec_3,
+            tertiary_display: lcd,
+            _led_a: (),
+        }
    };

    log::info!("Setup complete, entering main loop");
    spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
-    spawner.spawn(nfc_driver_task(nfc_driver).expect("nfc driver task failed"));
+    spawner.spawn(background_tasks::nfc_scanner(nfc_driver).expect("nfc scanner 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>>>,
-) {
-    loop {
-        while CARD_DATA.lock().await.is_none() {
-            let start = Instant::now();
-            match nfc_driver.read_card_data().await {
-                Ok(card_data) => {
-                    let Some(split_data) = split_nfc_hex(&card_data) else {
-                        log::error!("Failed to split NFC card data");
-                        continue;
-                    };
-                    CARD_DATA
-                        .lock()
-                        .await
-                        .replace(Card::try_from(split_data).unwrap());
-                    let elapsed_ms = start.elapsed().as_millis();
-                    log::info!(
-                        "NFC read duration: {} ms, card data length: {}",
-                        elapsed_ms,
-                        card_data.len()
-                    );
-                }
-                Err(_) => {
-                    log::info!("No NFC card found");
-                }
-            }
-        }
-        embassy_time::Timer::after(embassy_time::Duration::from_millis(1000)).await;
-    }
-}
-
-fn display_shit(oled: &mut DualSecondaryDisplay<'static>) {
-    oled.clear().unwrap();
+fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
+    oled.clear(BinaryColor::Off).unwrap();

    let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
-    Text::new("Hello OLED", Point::new(10, 20), text_style)
+    Text::new(text, Point::new(10, 20), text_style)
        .draw(oled)
        .unwrap();
    oled.flush().unwrap();
@@ -1,5 +1 @@
-pub mod primary_lcd;
-pub mod secondary_oled;
-pub mod shared_bus;
 pub mod sprite;
-pub mod tertiary_lcd;
@@ -1,43 +0,0 @@
-use display_interface_spi::SPIInterface;
-use embedded_graphics::draw_target::DrawTarget;
-use embedded_graphics::pixelcolor::Rgb565;
-use embedded_graphics::prelude::RgbColor;
-use embedded_hal::digital::OutputPin as EhOutputPin;
-use embedded_hal_bus::spi::AtomicDevice;
-use embedded_hal_bus::util::AtomicCell;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
-use ili9341::{DisplaySize240x320, Ili9341, Orientation};
-
-pub type PrimaryLcdDisplay<'a, BUS, DC, RES> =
-    Ili9341<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RES>;
-
-pub fn init_primary_lcd_on_bus<'a, BUS, CS, RES, DC>(
-    spi_bus: &'a AtomicCell<BUS>,
-    cs: CS,
-    reset: RES,
-    dc: DC,
-    delay: &mut Delay,
-) -> PrimaryLcdDisplay<'a, BUS, DC, RES>
-where
-    BUS: embedded_hal::spi::SpiBus,
-    CS: OutputPin + 'static,
-    RES: EhOutputPin,
-    DC: EhOutputPin,
-{
-    let cs_pin = Output::new(cs, Level::High, OutputConfig::default());
-    let spi_dev = AtomicDevice::new(spi_bus, cs_pin, *delay).unwrap();
-    let iface = SPIInterface::new(spi_dev, dc);
-
-    let mut display = Ili9341::new(
-        iface,
-        reset,
-        delay,
-        Orientation::Portrait,
-        DisplaySize240x320,
-    )
-    .unwrap();
-
-    display.clear(Rgb565::BLACK).unwrap();
-    display
-}
@@ -1,34 +0,0 @@
-use ch1115::{Ch1115, Size128x64};
-use display_interface_spi::SPIInterface;
-use embedded_hal::digital::OutputPin as EhOutputPin;
-use embedded_hal_bus::spi::AtomicDevice;
-use embedded_hal_bus::util::AtomicCell;
-use esp_hal::delay::Delay;
-use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
-
-pub type SecondaryOledDisplay<'a, BUS, RST, DC> =
-    Ch1115<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RST, Size128x64>;
-
-pub fn init_secondary_oled_on_bus<'a, BUS, CS, RES, DC>(
-    spi_bus: &'a AtomicCell<BUS>,
-    cs: CS,
-    res: RES,
-    dc: DC,
-    delay: &mut Delay,
-) -> SecondaryOledDisplay<'a, BUS, RES, DC>
-where
-    BUS: embedded_hal::spi::SpiBus,
-    CS: OutputPin + 'static,
-    RES: EhOutputPin,
-    DC: EhOutputPin,
-{
-    let cs_pin = Output::new(cs, Level::High, OutputConfig::default());
-    let spi_dev = AtomicDevice::new(spi_bus, cs_pin, *delay).unwrap();
-    let interface = SPIInterface::new(spi_dev, dc);
-
-    let mut display = Ch1115::new(interface, res, Size128x64);
-
-    display.init(&mut Delay::new()).unwrap();
-
-    display
-}
@@ -47,10 +47,7 @@ where
            let width = u32::try_from(end_x - start_x).unwrap();
            let height = u32::try_from(end_y - start_y).unwrap();

-            let area = Rectangle::new(
-                Point::new(start_x.try_into().unwrap(), start_y.try_into().unwrap()),
-                Size::new(width, height),
-            );
+            let area = Rectangle::new(Point::new(start_x, start_y), Size::new(width, height));

            let _ = ili9341.fill_solid(&area, color);
        }
@@ -1,102 +0,0 @@
-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
-    I2C: I2c,
-{
-    let mut lcd = CharacterDisplayPCF8574T::new(i2c, LcdDisplayType::Lcd16x2, Delay::new());
-    match lcd.init() {
-        Ok(()) => {
-            log::info!("I2C tertiary LCD initialized on PCF8574T at address 0x27");
-            lcd
-        }
-        Err(_) => {
-            error!(
-                "I2C tertiary LCD init failed on PCF8574T at address 0x27; check bus wiring, power, and device address"
-            );
-            panic!("tertiary LCD initialization failed");
-        }
-    }
-}
-
-pub fn write_line<I2C>(
-    lcd: &mut TertiaryLcd<I2C>,
-    line: u8,
-    text: &str,
-) -> Result<(), i2c_character_display::CharacterDisplayError<I2C>>
-where
-    I2C: I2c,
-{
-    if let Err(e) = lcd.set_cursor(0, line) {
-        error!("I2C LCD cursor move failed on line {line}; bus or device may be unavailable");
-        return Err(e);
-    }
-    if let Err(e) = lcd.print(text) {
-        error!(
-            "I2C LCD print failed on line {line}; payload length={} and device may be busy or disconnected",
-            text.len()
-        );
-        return Err(e);
-    }
-    Ok(())
-}
-
-pub fn write_wrapped<I2C>(
-    lcd: &mut TertiaryLcd<I2C>,
-    text: &str,
-) -> Result<(), i2c_character_display::CharacterDisplayError<I2C>>
-where
-    I2C: I2c,
-{
-    const DISPLAY_WIDTH: usize = 16;
-    const DISPLAY_ROWS: usize = 2;
-
-    if let Err(e) = lcd.clear() {
-        error!(
-            "I2C LCD clear failed before wrapped write; check the shared bus and display response"
-        );
-        return Err(e);
-    }
-
-    let mut offset = 0;
-    for row in 0..DISPLAY_ROWS {
-        let remaining = &text[offset..];
-        if remaining.is_empty() {
-            return Ok(());
-        }
-
-        let chunk = if remaining.len() > DISPLAY_WIDTH {
-            &remaining[..DISPLAY_WIDTH]
-        } else {
-            remaining
-        };
-
-        if let Err(e) = lcd.set_cursor(0, row as u8) {
-            error!(
-                "I2C LCD cursor move failed while writing wrapped row {row}; bus may be busy or device unresponsive"
-            );
-            return Err(e);
-        }
-        if let Err(e) = lcd.print(chunk) {
-            error!(
-                "I2C LCD wrapped write failed on row {row}; chunk length={} and text may exceed display width",
-                chunk.len()
-            );
-            return Err(e);
-        }
-        offset += chunk.len();
-
-        if offset >= text.len() {
-            return Ok(());
-        }
-    }
-
-    Ok(())
-}
@@ -1 +1,6 @@
+pub mod i2c_bus;
 pub mod nfc_pn532;
+pub mod primary_lcd;
+pub mod secondary_oled;
+pub mod spi_bus;
+pub mod tertiary_lcd;
@@ -0,0 +1,38 @@
+use alloc::boxed::Box;
+use embedded_hal_bus::i2c::AtomicDevice;
+use embedded_hal_bus::util::AtomicCell;
+use esp_hal::gpio::interconnect::PeripheralInput;
+use esp_hal::i2c::master::Config;
+use esp_hal::{gpio::interconnect::PeripheralOutput, i2c::master::I2c};
+
+type InnerI2cBus<'a> = esp_hal::i2c::master::I2c<'a, esp_hal::Blocking>;
+pub type I2cBus<'a> = &'a AtomicCell<InnerI2cBus<'a>>;
+pub type I2cDevice<'a> = AtomicDevice<'a, esp_hal::i2c::master::I2c<'a, esp_hal::Blocking>>;
+
+pub struct I2cBusPinConfiguration<I2C, SCL, SDA> {
+    pub i2c_peripheral: I2C,
+    pub scl: SCL,
+    pub sda: SDA,
+}
+
+impl<'a, I2C, SCL, SDA> I2cBusPinConfiguration<I2C, SCL, SDA>
+where
+    I2C: esp_hal::i2c::master::Instance + 'a,
+    SCL: PeripheralOutput<'a> + PeripheralInput<'a>,
+    SDA: PeripheralOutput<'a> + PeripheralInput<'a>,
+{
+    pub fn build(self) -> I2cBus<'a> {
+        let config = Config::default().with_frequency(esp_hal::time::Rate::from_khz(400));
+        let i2c = match I2c::new(self.i2c_peripheral, config) {
+            Ok(bus) => bus.with_sda(self.sda).with_scl(self.scl),
+            Err(e) => {
+                log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
+                panic!("Shared I2C bus initialization failed");
+            }
+        };
+        let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
+        log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
+
+        shared_i2c
+    }
+}
@@ -1,4 +1,5 @@
 use alloc::vec::Vec;
+use core::error::Error;
 use embedded_hal::i2c::I2c;
 use log::{error, info};
 use pn532::i2c::I2CInterface;
@@ -8,6 +9,7 @@ use pn532::{Pn532, Request};
 pub type Pn532Device<I2C> = Pn532<I2CInterface<I2C>, (), 34>;

 pub const PAGES_PER_READ: usize = 4;
+pub const BYTES_PER_READ: usize = PAGES_PER_READ * 4;

 /// PN532 NFC reader driver.
 pub struct NfcPn532Driver<I2C>
@@ -17,6 +19,144 @@ where
    pn532: Pn532Device<I2C>,
 }

+#[derive(Debug, Clone)]
+struct PageParseError<const N: usize> {
+    iteration: u8,
+    bytes: [u8; N],
+    status_code: Option<CommandResult>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct CommandResult {
+    /// # WrErr
+    /// Set to logic 1, when data is written into the FIFO by the 80C51 during the AutoColl command or MFAuthent command or
+    /// if data is written into the FIFO by the 80C51 during the time between sending the last bit on the RF interface and
+    /// receiving the last bit on the RF interface.
+    write_error: bool,
+    /// # TempErr
+    /// Set to logic 1, if the internal temperature sensor detects overheating. In this case the antenna drivers are switched off automatically.
+    overheating: bool,
+    /// # RFErr
+    /// Set to logic 1, if in active communication mode the counterpart does not switch on the RF field in time as defined in NFCIP-1 standard.
+    /// Note: RFErr is only used in active communication mode. The bit RxFraming or the bit TxFraming has to be set to 01h to enable
+    /// this functionality.
+    rf_timeout: bool,
+    /// # BufferOvfl
+    /// Set to logic 1, if the 80C51 or if the internal state machine (e.g. receiver) tries to write data into the FIFO buffer
+    /// although the FIFO buffer is already full.
+    buffer_overflow: bool,
+    /// # CollErr
+    /// Set to logic 1, if a bit-collision is detected. It is set to logic 0 automatically at receiver start phase.
+    /// This flag is only valid during the bitwise anticollision at 106 kbit/s. During communication schemes at 212 and 424 kbit/s
+    /// this flag is always set to logic 0.
+    bit_collision: bool,
+    /// # CRCErr
+    /// Set to logic 1, if RxCRCEn in CIU_RxMode register is set to logic 1 and the CRC calculation fails. It is set to logic 0 automatically
+    /// at receiver start-up phase.
+    crc_error: bool,
+    /// # ParityErr
+    /// Set to logic 1, if the parity check has failed. It is set to logic 0 automatically at receiver start-up phase.
+    /// Only valid for ISO/IEC 14443A/MIFARE or NFCIP-1 communication at 106 kbit/s.
+    parity_error: bool,
+    /// # ProtocollErr
+    /// Set to logic 1, if one out of the following cases occurs:
+    /// - Set to logic 1 if the SOF is incorrect. It is set to logic 0 automatically at receiver start-up phase.
+    ///   The bit is only valid for 106 kbit in Active and Passive Communication mode.
+    /// - If bit DetectSync in CIU_Mode register is set to logic 1 during FeliCa communication or Active Communication
+    ///   with transfer speeds higher than 106 kbit, ProtocolErr is set to logic 1 in case of a byte length violation.
+    /// - During the AutoColl command, ProtocolErr is set to logic 1, if the Initiator bit in CIU_Control register is set to logic 1.
+    /// - During the MFAuthent Command, ProtocolErr is set to logic 1, if the number of bytes received in one data stream is incorrect.
+    /// - Set to logic 1, if the Miller Decoder detects 2 pauses below the minimum time according to the ISO/IEC 14443A definitions.
+    protocol_error: bool,
+}
+
+impl CommandResult {
+    pub fn is_error(&self) -> bool {
+        self.write_error
+            || self.overheating
+            || self.rf_timeout
+            || self.buffer_overflow
+            || self.bit_collision
+            || self.crc_error
+            || self.parity_error
+            || self.protocol_error
+    }
+}
+
+impl From<u8> for CommandResult {
+    fn from(value: u8) -> Self {
+        let mask = |bit| 1u8 << bit;
+        let take_bit = |bit| (value & mask(bit)) != 0u8;
+
+        Self {
+            write_error: take_bit(7),
+            overheating: take_bit(6),
+            rf_timeout: take_bit(5),
+            buffer_overflow: take_bit(4),
+            bit_collision: take_bit(3),
+            crc_error: take_bit(2),
+            parity_error: take_bit(1),
+            protocol_error: take_bit(0),
+        }
+    }
+}
+
+impl core::fmt::Display for CommandResult {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if !self.is_error() {
+            return write!(f, "ok");
+        }
+
+        write!(f, "error: ")?;
+
+        let errors = [
+            (self.write_error, "write_error(7)"),
+            (self.overheating, "overheating(6)"),
+            (self.rf_timeout, "rf_timeout(5)"),
+            (self.buffer_overflow, "buffer_overflow(4)"),
+            (self.bit_collision, "bit_collision(3)"),
+            (self.crc_error, "crc_error(2)"),
+            (self.parity_error, "parity_error(1)"),
+            (self.protocol_error, "protocol_error(0)"),
+        ]
+        .into_iter()
+        .filter_map(|(active, name)| active.then_some(name));
+
+        let mut first = true;
+        for error in errors {
+            let separator = if !first { ", " } else { "" };
+            write!(f, "{separator}{error}")?;
+            first = false;
+        }
+
+        Ok(())
+    }
+}
+
+impl Error for CommandResult {}
+
+impl<const N: usize> Error for PageParseError<N> {}
+
+impl<const N: usize> core::fmt::Display for PageParseError<N> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let PageParseError {
+            iteration,
+            bytes,
+            status_code,
+        } = self;
+        match status_code {
+            Some(code) => write!(
+                f,
+                "NFC pages parse error in iteration {iteration} with {code}: {bytes:02x?}"
+            ),
+            None => write!(
+                f,
+                "No data available for NFC page in iteration {iteration}: {bytes:02x?}"
+            ),
+        }
+    }
+}
+
 impl<I2C> NfcPn532Driver<I2C>
 where
    I2C: I2c,
@@ -40,7 +180,7 @@ where
        }
    }

-    pub async fn poll_target(&mut self) -> Result<(), ()> {
+    pub async fn poll_target(&mut self) -> Result<(), &'static str> {
        match self
            .pn532
            .process_async(&Request::INLIST_ONE_ISO_A_TARGET, 23)
@@ -51,26 +191,31 @@ where
                Ok(())
            }
            Err(e) => {
-                info!("No NFC card found on shared I2C bus: {e:?}");
-                Err(())
+                info!("Failed to poll NFC target: {e:?}");
+                Err("Failed to poll NFC target")
            }
        }
    }

-    pub fn parse_nfc_page(iteration: u8, bytes: &[u8]) -> Result<[u8; PAGES_PER_READ * 4], ()> {
-        let success = bytes.first().is_some_and(|x| *x == 0);
-        if success {
-            let slice_len = bytes.len().min(PAGES_PER_READ * 4 + 1);
-            let mut arr = [0; PAGES_PER_READ * 4];
-            arr[..slice_len - 1].copy_from_slice(&bytes[1..slice_len]);
-            Ok(arr)
-        } else {
-            info!("err  {iteration}: {:02x?}", bytes);
-            Err(())
+    fn parse_nfc_page(
+        iteration: u8,
+        bytes: &[u8],
+    ) -> Result<[u8; BYTES_PER_READ], PageParseError<BYTES_PER_READ>> {
+        let slice_len = bytes.len().min(BYTES_PER_READ + 1);
+        let mut arr = [0; BYTES_PER_READ];
+        arr[..slice_len - 1].copy_from_slice(&bytes[1..slice_len]);
+
+        match bytes.first() {
+            Some(0x00) => Ok(arr),
+            error => Err(PageParseError {
+                iteration,
+                bytes: arr,
+                status_code: error.copied().map(Into::into),
+            }),
        }
    }

-    pub async fn read_card_data(&mut self) -> Result<Vec<u8>, ()> {
+    pub async fn read_card_data(&mut self) -> Result<Vec<u8>, &'static str> {
        if let Err(e) = self.poll_target().await {
            error!("PN532 I2C target poll failed before reading card data: {e:?}");
            return Err(e);
@@ -79,18 +224,31 @@ where
        let mut data: Vec<u8> = Vec::with_capacity(858);

        for i in (0x0B..=230).step_by(PAGES_PER_READ) {
-            let mut parse_result = Err(());
-            while parse_result.is_err() {
-                let Ok(result) = self
+            let bytes = loop {
+                let read = self
                    .pn532
-                    .process_async(&Request::ntag_read(i), PAGES_PER_READ * 4 + 1)
-                    .await
-                else {
-                    continue;
+                    .process_async(&Request::ntag_read(i), BYTES_PER_READ + 1)
+                    .await;
+
+                let bytes = match read {
+                    Ok(bytes) => bytes,
+                    Err(e) => {
+                        error!("Reading page {i} failed: {e:?}");
+                        continue;
+                    }
                };
-                parse_result = Self::parse_nfc_page(i, result);
-            }
-            let bytes = parse_result.unwrap();
+
+                match Self::parse_nfc_page(i, bytes) {
+                    Ok(data) => break data,
+                    Err(e) => {
+                        error!("Parsing page failed: {e}");
+                        if e.status_code.is_some_and(|e| e.protocol_error) {
+                            // After protocol error, all subsequent reads will fail, so we can stop trying to read more pages.
+                            return Err("Failed to parse NFC page");
+                        }
+                    }
+                }
+            };
            let bytes = if i == 0x0B { &bytes[1..] } else { &bytes };
            data.extend(bytes);
        }
@@ -0,0 +1,42 @@
+use display_interface_spi::SPIInterface;
+use embedded_graphics::draw_target::DrawTarget;
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::RgbColor;
+use embedded_hal_bus::spi::AtomicDevice;
+use embedded_hal_bus::util::AtomicCell;
+use esp_hal::delay::Delay;
+use esp_hal::gpio::Output;
+use ili9341::{DisplaySize240x320, Ili9341, Orientation};
+
+use crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput};
+
+type GenericPrimaryDisplay<'a, BUS, DC, RES> =
+    Ili9341<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RES>;
+pub type PrimaryDisplay<'a> =
+    GenericPrimaryDisplay<'a, DisplaySpiBus, SharedOutput<'a>, Output<'a>>;
+
+pub struct PrimaryDisplayPinConfiguration<'a> {
+    pub spi_bus: &'a AtomicCell<DisplaySpiBus>,
+    pub cs: Output<'a>,
+    pub reset: Output<'a>,
+    pub dc: SharedOutput<'a>,
+}
+
+impl<'a> PrimaryDisplayPinConfiguration<'a> {
+    pub fn build(self) -> PrimaryDisplay<'a> {
+        let spi_dev = AtomicDevice::new(self.spi_bus, self.cs, Delay::new()).unwrap();
+        let iface = SPIInterface::new(spi_dev, self.dc);
+
+        let mut display = Ili9341::new(
+            iface,
+            self.reset,
+            &mut Delay::new(),
+            Orientation::Portrait,
+            DisplaySize240x320,
+        )
+        .unwrap();
+
+        display.clear(Rgb565::BLACK).unwrap();
+        display
+    }
+}
@@ -0,0 +1,194 @@
+use alloc::{format, string::String};
+use display_interface_spi::SPIInterface;
+use embedded_graphics::pixelcolor::BinaryColor;
+use embedded_hal_bus::spi::AtomicDevice;
+use embedded_hal_bus::util::AtomicCell;
+use esp_hal::delay::Delay;
+use esp_hal::gpio::Output;
+
+use crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput, SharedReset};
+
+pub struct SecondaryDisplay<'a>(
+    #[cfg(feature = "wokwi")] ssd1306_aliases::SecondaryDisplay<'a>,
+    #[cfg(not(feature = "wokwi"))] ch1115_aliases::SecondaryDisplay<'a>,
+);
+
+impl<'a> SecondaryDisplay<'a> {
+    pub fn flush(&mut self) -> Result<(), String> {
+        #[cfg(not(feature = "wokwi"))]
+        return self.0.flush().map_err(|e| format!("{e:?}"));
+        #[cfg(feature = "wokwi")]
+        return Ok(());
+    }
+}
+
+impl<'a> embedded_graphics::geometry::Dimensions for SecondaryDisplay<'a> {
+    fn bounding_box(&self) -> embedded_graphics::primitives::Rectangle {
+        self.0.bounding_box()
+    }
+}
+
+impl<'a> embedded_graphics::draw_target::DrawTarget for SecondaryDisplay<'a> {
+    type Color = BinaryColor;
+
+    type Error = String;
+
+    fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
+    where
+        I: IntoIterator<Item = embedded_graphics::prelude::Pixel<Self::Color>>,
+    {
+        self.0.draw_iter(pixels).map_err(|e| format!("{e:?}"))
+    }
+
+    fn fill_contiguous<I>(
+        &mut self,
+        area: &embedded_graphics::primitives::Rectangle,
+        colors: I,
+    ) -> Result<(), Self::Error>
+    where
+        I: IntoIterator<Item = Self::Color>,
+    {
+        self.0
+            .fill_contiguous(area, colors)
+            .map_err(|e| format!("{e:?}"))
+    }
+
+    fn fill_solid(
+        &mut self,
+        area: &embedded_graphics::primitives::Rectangle,
+        color: Self::Color,
+    ) -> Result<(), Self::Error> {
+        self.0.fill_solid(area, color).map_err(|e| format!("{e:?}"))
+    }
+
+    fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error> {
+        #[cfg(feature = "wokwi")]
+        return self.0.clear(color).map_err(|e| format!("{e:?}"));
+
+        #[cfg(not(feature = "wokwi"))]
+        {
+            let _ = color;
+            self.0.clear().map_err(|e| format!("{e:?}"))
+        }
+    }
+}
+
+pub const SECONDARY_DISPLAY_COUNT: usize = 3;
+
+pub struct SecondaryDisplayPinConfiguration<'a> {
+    pub spi_bus: &'a AtomicCell<DisplaySpiBus>,
+    pub cs_pins: [Output<'a>; 3],
+    pub res: SharedReset<'a>,
+    pub dc: SharedOutput<'a>,
+}
+
+impl<'a> SecondaryDisplayPinConfiguration<'a> {
+    pub fn build(self) -> [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
+        #[cfg(feature = "wokwi")]
+        type Displays<'b> = [ssd1306_aliases::SecondaryDisplay<'b>; SECONDARY_DISPLAY_COUNT];
+        #[cfg(not(feature = "wokwi"))]
+        type Displays<'b> = [ch1115_aliases::SecondaryDisplay<'b>; SECONDARY_DISPLAY_COUNT];
+
+        let reset_pin = self.res.clone();
+        let mut displays = Displays::new(self);
+        displays.reset(reset_pin);
+
+        displays.map(SecondaryDisplay)
+    }
+}
+
+trait MultiDisplay<'a> {
+    fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self;
+    fn reset(&mut self, shared_reset: SharedReset<'a>);
+}
+
+mod ch1115_aliases {
+    use super::*;
+    use ch1115::{Ch1115, Size128x64};
+
+    type GenericSecondaryDisplay<'a, BUS, RST, DC> =
+        Ch1115<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RST, Size128x64>;
+    pub type SecondaryDisplay<'a> =
+        GenericSecondaryDisplay<'a, DisplaySpiBus, SharedReset<'a>, SharedOutput<'a>>;
+
+    impl<'a> MultiDisplay<'a> for [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
+        fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self {
+            config.cs_pins.map(|cs| {
+                let spi_dev = AtomicDevice::new(config.spi_bus, cs, Delay::new()).unwrap();
+                let interface = SPIInterface::new(spi_dev, config.dc.clone());
+
+                SecondaryDisplay::new(interface, config.res.clone(), Size128x64)
+            })
+        }
+
+        fn reset(&mut self, shared_reset: SharedReset<'a>) {
+            let mut displays = self.iter_mut().peekable();
+
+            // Reset all secondaries via shared reset
+            let Some(any_display) = displays.peek_mut() else {
+                // no display to initialize
+                return;
+            };
+            any_display.hard_reset(&mut Delay::new()).unwrap();
+
+            shared_reset.disable(true);
+
+            for (i, display) in displays.enumerate() {
+                display
+                    .init(&mut Delay::new())
+                    .map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
+                    .unwrap();
+            }
+        }
+    }
+}
+
+mod ssd1306_aliases {
+    use super::*;
+    use ssd1306::{
+        Ssd1306, mode::BufferedGraphicsMode, rotation::DisplayRotation, size::DisplaySize128x64,
+    };
+
+    type GenericSecondaryDisplay<'a, BUS, DC> = Ssd1306<
+        SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>,
+        DisplaySize128x64,
+        BufferedGraphicsMode<DisplaySize128x64>,
+    >;
+    pub type SecondaryDisplay<'a> = GenericSecondaryDisplay<'a, DisplaySpiBus, SharedOutput<'a>>;
+
+    impl<'a> MultiDisplay<'a> for [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
+        fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self {
+            config.cs_pins.map(|cs| {
+                let spi_dev = AtomicDevice::new(config.spi_bus, cs, Delay::new()).unwrap();
+                let interface = SPIInterface::new(spi_dev, config.dc.clone());
+
+                Ssd1306::new(interface, DisplaySize128x64, DisplayRotation::Rotate0)
+                    .into_buffered_graphics_mode()
+            })
+        }
+
+        fn reset(&mut self, mut shared_reset: SharedReset<'a>) {
+            use ssd1306::mode::DisplayConfig as _;
+
+            let mut displays = self.iter_mut().peekable();
+
+            // Reset all secondaries via shared reset
+            let Some(any_display) = displays.peek_mut() else {
+                // no display to initialize
+                return;
+            };
+            any_display
+                .reset(&mut shared_reset, &mut Delay::new())
+                .unwrap();
+
+            shared_reset.disable(true);
+
+            for (i, display) in displays.enumerate() {
+                display
+                    .init()
+                    .map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
+                    .unwrap();
+            }
+        }
+    }
+}
@@ -3,15 +3,16 @@ use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embedded_hal::digital::ErrorType;
 use embedded_hal::digital::OutputPin as EhOutputPin;
 use embedded_hal_bus::util::AtomicCell;
-use esp_hal::delay::Delay;
 use esp_hal::gpio::interconnect::{PeripheralInput, PeripheralOutput};
 use esp_hal::gpio::{Level, Output, OutputConfig, OutputPin};
 use esp_hal::spi::Mode;
 use esp_hal::spi::master::{Config as SpiConfig, Spi};
 use esp_hal::time::Rate;

-use crate::display::primary_lcd::{PrimaryLcdDisplay, init_primary_lcd_on_bus};
-use crate::display::secondary_oled::{SecondaryOledDisplay, init_secondary_oled_on_bus};
+use crate::drivers::primary_lcd::PrimaryDisplay;
+use crate::drivers::primary_lcd::PrimaryDisplayPinConfiguration;
+use crate::drivers::secondary_oled::SecondaryDisplay;
+use crate::drivers::secondary_oled::SecondaryDisplayPinConfiguration;

 use core::cell::RefCell;
 use embassy_sync::blocking_mutex::Mutex as BlockingMutex;
@@ -101,13 +102,9 @@ impl<'a, P: EhOutputPin> EhOutputPin for SharedResetPin<'a, P> {
    }
 }

-type SharedOutput<'a> = SharedPin<'a, Output<'a>>;
-type SharedReset<'a> = SharedResetPin<'a, Output<'a>>;
+pub type SharedOutput<'a> = SharedPin<'a, Output<'a>>;
+pub type SharedReset<'a> = SharedResetPin<'a, Output<'a>>;
 pub type DisplaySpiBus = Spi<'static, esp_hal::Blocking>;
-pub type DualPrimaryDisplay<'a> =
-    PrimaryLcdDisplay<'a, DisplaySpiBus, SharedOutput<'a>, Output<'a>>;
-pub type DualSecondaryDisplay<'a> =
-    SecondaryOledDisplay<'a, DisplaySpiBus, SharedReset<'a>, SharedOutput<'a>>;

 pub struct DisplayPinConfiguration<SPI, SCK, MOSI, MISO, CS0, CS1, CS2, CS3, RES1, RES2, DC> {
    pub spi_peripheral: SPI,
@@ -138,7 +135,7 @@ where
    RES2: OutputPin + 'static,
    DC: OutputPin + 'static,
 {
-    pub fn build(self) -> (DualPrimaryDisplay<'static>, DualSecondaryDisplay<'static>) {
+    pub fn build(self) -> (PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]) {
        let spi = Spi::new(
            self.spi_peripheral,
            SpiConfig::default()
@@ -151,7 +148,6 @@ where
        .with_miso(self.miso);

        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,
@@ -161,31 +157,31 @@ where
            Level::High,
            OutputConfig::default(),
        ));
-        let mut delay = Delay::new();

-        let primary = init_primary_lcd_on_bus(
-            bus_static,
-            self.cs_primary,
-            reset_primary,
-            dc.clone(),
-            &mut delay,
-        );
+        let primary = PrimaryDisplayPinConfiguration {
+            spi_bus: bus_static,
+            cs: low_active(self.cs_primary),
+            reset: low_active(self.reset_primary),
+            dc: dc.clone(),
+        }
+        .build();

-        // TODO
-        // Build display
-        // Trigger reset
-        // disable init
-        // rest of init code
-
-
-        let secondary = init_secondary_oled_on_bus(
-            bus_static,
-            self.cs_secondary_1,
-            reset_secondary,
+        let secondaries = SecondaryDisplayPinConfiguration {
+            spi_bus: bus_static,
+            cs_pins: [
+                low_active(self.cs_secondary_1),
+                low_active(self.cs_secondary_2),
+                low_active(self.cs_secondary_3),
+            ],
+            res: reset_secondary,
            dc,
-            &mut delay,
-        );
+        }
+        .build();

-        (primary, secondary)
+        (primary, secondaries)
    }
 }
+
+fn low_active<'a, CS: OutputPin + 'a>(pin: CS) -> Output<'a> {
+    Output::new(pin, Level::High, OutputConfig::default())
+}
@@ -0,0 +1,410 @@
+use embedded_hal_bus::i2c::AtomicDevice;
+use esp_hal::delay::Delay;
+use i2c_character_display::{CharacterDisplayPCF8574T, LcdDisplayType};
+use log::error;
+
+use crate::create_custom_char_set;
+use crate::drivers::i2c_bus::{I2cBus, I2cDevice};
+
+type GenericTertiaryDisplay<I2C> = CharacterDisplayPCF8574T<I2C, Delay>;
+type TertiaryDisplayRaw<'a> = GenericTertiaryDisplay<I2cDevice<'a>>;
+pub type TertiaryDisplayError<'a> = i2c_character_display::CharacterDisplayError<I2cDevice<'a>>;
+
+pub struct TertiaryDisplayPinConfiguration<'a> {
+    pub i2c: I2cBus<'a>,
+}
+
+impl<'a> TertiaryDisplayPinConfiguration<'a> {
+    pub fn build(self) -> TertiaryDisplay<'a> {
+        let device = AtomicDevice::new(self.i2c);
+        let mut lcd = CharacterDisplayPCF8574T::new(device, LcdDisplayType::Lcd16x2, Delay::new());
+        match lcd.init() {
+            Ok(()) => {
+                log::info!("I2C tertiary LCD initialized on PCF8574T at address 0x27");
+                TertiaryDisplay {
+                    display: lcd,
+                    charset: create_custom_char_set!(),
+                }
+            }
+            Err(e) => {
+                panic!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum TertiaryDisplayWriteError<'a> {
+    Display(TertiaryDisplayError<'a>),
+    Format(LinesError),
+}
+
+impl<'a> From<TertiaryDisplayError<'a>> for TertiaryDisplayWriteError<'a> {
+    fn from(value: TertiaryDisplayError<'a>) -> Self {
+        Self::Display(value)
+    }
+}
+
+impl From<LinesError> for TertiaryDisplayWriteError<'_> {
+    fn from(value: LinesError) -> Self {
+        Self::Format(value)
+    }
+}
+
+impl<'a> core::fmt::Display for TertiaryDisplayWriteError<'a> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Display(e) => write!(f, "display error: {e}"),
+            Self::Format(e) => write!(f, "format error: {e}"),
+        }
+    }
+}
+
+pub struct TertiaryDisplay<'a> {
+    display: TertiaryDisplayRaw<'a>,
+    charset: CustomCharset,
+}
+
+impl<'a> TertiaryDisplay<'a> {
+    pub const WIDTH: usize = 16;
+    pub const ROWS: usize = 2;
+
+    pub fn inner_mut(&mut self) -> &mut TertiaryDisplayRaw<'a> {
+        &mut self.display
+    }
+
+    pub fn load_charset(&mut self, charset: CustomCharset) -> Result<(), TertiaryDisplayError<'a>> {
+        self.charset = charset;
+        for (index, charmap) in self
+            .charset
+            .set
+            .into_iter()
+            .enumerate()
+            .take(self.charset.len)
+        {
+            self.display
+                .create_char(index as u8, charmap)
+                .inspect_err(|e| error!("I2C Custom character {index} init failed: {e}"))?;
+        }
+        Ok(())
+    }
+
+    pub fn clear(&mut self) -> Result<(), TertiaryDisplayError<'a>> {
+        if let Err(e) = self.display.clear() {
+            error!("I2C LCD clear failed; bus may be busy or device unresponsive");
+            return Err(e);
+        }
+        Ok(())
+    }
+
+    /// Writes text to the LCD. Normal strings wrap by default but this can be controlled
+    /// via explicit [`Lines::checked`].
+    pub fn write<'b, L: Into<Lines<'b>>>(
+        &mut self,
+        text: L,
+    ) -> Result<(), TertiaryDisplayWriteError<'a>> {
+        let lines = text.into();
+
+        // Use original to get correct position in original string
+        lines
+            .original
+            .iter()
+            .try_for_each(|text| Lines::invalid_chars(text, Some(&self.charset)))?;
+
+        let lines = lines.into_result()?;
+
+        self.display
+            .clear()
+            .inspect_err(|e| error!("I2C LCD clear failed before wrapped write: {e}"))?;
+
+        for (row, line) in lines.into_iter().enumerate() {
+            self.display.set_cursor(0, row as u8).inspect_err(|e| {
+                error!("I2C LCD cursor move failed while writing wrapped row {row}: {e}")
+            })?;
+
+            self.display
+                .print(line)
+                .inspect_err(|e| error!("I2C LCD wrapped write failed on row {row}: {e}"))?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum LinesError {
+    ColumnOverflow { line: u8, columns: usize },
+    LineOverflow,
+    InvalidChar { position: usize, symbol: char },
+}
+
+impl core::fmt::Display for LinesError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::ColumnOverflow { line, columns } => {
+                write!(
+                    f,
+                    "text too long for line {line}: {columns} > {}",
+                    TertiaryDisplay::WIDTH
+                )
+            }
+            Self::LineOverflow => write!(f, "text has too many lines"),
+            Self::InvalidChar { position, symbol } => {
+                write!(f, "Invalid character {symbol} at offset {position}")
+            }
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct Lines<'a> {
+    pub lines: Result<[&'a str; TertiaryDisplay::ROWS], LinesError>,
+    /// Unmodified original string. Only first entry is populated unless constructed with [`by_line`]
+    pub original: [&'a str; TertiaryDisplay::ROWS],
+}
+
+impl<'a> Lines<'a> {
+    pub fn into_result(self) -> Result<[&'a str; TertiaryDisplay::ROWS], LinesError> {
+        self.lines
+    }
+
+    /// Validates that the text contains only non-control ASCII characters,
+    /// newlines, and contiguous custom characters up to `charset.len`.
+    /// If `charset` is `None`, allow any custom char up to and including maximum.
+    pub fn invalid_chars(text: &str, charset: Option<&CustomCharset>) -> Result<(), LinesError> {
+        for (pos, c) in text.char_indices() {
+            let is_standard_valid = c == '\n' || (' '..='~').contains(&c);
+
+            if is_standard_valid {
+                continue;
+            }
+
+            let first_invalid_custom_char =
+                charset.map(|c| c.len).unwrap_or(CUSTOM_CHAR_COUNT.into());
+
+            if (c as usize) >= first_invalid_custom_char {
+                return Err(LinesError::InvalidChar {
+                    position: pos,
+                    symbol: c,
+                });
+            }
+        }
+        Ok(())
+    }
+
+    /// Checks pre-split lines strictly for length and valid characters.
+    pub fn by_line(lines: [&'a str; TertiaryDisplay::ROWS]) -> Self {
+        let this = |res| Self {
+            lines: res,
+            original: lines,
+        };
+
+        for line in lines.iter() {
+            if let Err(e) = Self::invalid_chars(line, None) {
+                return this(Err(e));
+            }
+        }
+
+        for (i, line) in lines.iter().enumerate() {
+            if line.len() > TertiaryDisplay::WIDTH {
+                return this(Err(LinesError::ColumnOverflow {
+                    line: i as u8,
+                    columns: line.len(),
+                }));
+            }
+        }
+
+        this(Ok(lines))
+    }
+
+    /// Strictly checks an input string.
+    /// Fails if there are invalid chars, too many newlines, or if any segment exceeds WIDTH.
+    pub fn checked(input: &'a str) -> Self {
+        let this = |res| Self {
+            lines: res,
+            original: [input, ""],
+        };
+
+        if let Err(e) = Self::invalid_chars(input, None) {
+            return this(Err(e));
+        }
+
+        let mut out = [""; TertiaryDisplay::ROWS];
+        let mut parts = input.split('\n');
+
+        for (i, out) in out.iter_mut().enumerate() {
+            if let Some(part) = parts.next() {
+                if part.len() > TertiaryDisplay::WIDTH {
+                    return this(Err(LinesError::ColumnOverflow {
+                        line: i as u8,
+                        columns: part.len(),
+                    }));
+                }
+                *out = part;
+            }
+        }
+
+        if parts.next().is_some() {
+            return this(Err(LinesError::LineOverflow));
+        }
+
+        this(Ok(out))
+    }
+
+    /// Wraps text automatically at `WIDTH` or at newlines.
+    /// Discards (clamps) any leftover text that exceeds `ROWS`.
+    /// Fails immediately if invalid characters are present.
+    pub fn clamped(input: &'a str) -> Self {
+        let this = |res| Self {
+            lines: res,
+            original: [input, ""],
+        };
+        if let Err(e) = Self::invalid_chars(input, None) {
+            return this(Err(e));
+        }
+
+        let mut out = [""; TertiaryDisplay::ROWS];
+        let mut remaining = input;
+
+        for out in out.iter_mut() {
+            if remaining.is_empty() {
+                break;
+            }
+
+            let (segment, rest) = Self::next_segment(remaining, TertiaryDisplay::WIDTH);
+            *out = segment;
+            remaining = rest;
+        }
+
+        this(Ok(out))
+    }
+
+    /// Helper function to slice an ASCII string up to `max_width`
+    /// or until the next newline, whichever comes first.
+    fn next_segment(s: &str, max_width: usize) -> (&str, &str) {
+        let nl_pos = s.find('\n');
+
+        let split_pos = match nl_pos {
+            Some(pos) if pos <= max_width => pos,
+            _ => core::cmp::min(s.len(), max_width),
+        };
+
+        let segment = &s[..split_pos];
+        let mut rest = &s[split_pos..];
+
+        if let Some(stripped) = rest.strip_prefix('\n') {
+            rest = stripped;
+        }
+
+        (segment, rest)
+    }
+}
+
+impl<'a> From<&'a str> for Lines<'a> {
+    fn from(value: &'a str) -> Self {
+        Self::clamped(value)
+    }
+}
+
+impl<'a> From<&'a alloc::string::String> for Lines<'a> {
+    fn from(value: &'a alloc::string::String) -> Self {
+        Self::clamped(value)
+    }
+}
+
+/// 5x8 pixel charmap. Each set bit is a black pixel.
+pub type CharMap = [u8; 8];
+pub struct CustomCharset {
+    set: [CharMap; CUSTOM_CHAR_COUNT as usize],
+    len: usize,
+}
+
+impl core::ops::Index<CharMap> for CustomCharset {
+    type Output = &'static str;
+
+    fn index(&self, map: CharMap) -> &Self::Output {
+        let encoded = self.set[..self.len]
+            .iter()
+            .position(|&m| m == map)
+            .expect("Unknown char map in this set.");
+
+        match encoded {
+            0 => &"\x00",
+            1 => &"\x01",
+            2 => &"\x02",
+            3 => &"\x03",
+            4 => &"\x04",
+            5 => &"\x05",
+            6 => &"\x06",
+            7 => &"\x07",
+            8 => &"\x08",
+            9 => &"\x09",
+            10 => &"\x0A",
+            11 => &"\x0B",
+            12 => &"\x0C",
+            13 => &"\x0D",
+            14 => &"\x0E",
+            15 => &"\x0F",
+            pos => unreachable!(
+                "More than {CUSTOM_CHAR_COUNT} (=max) elements in array? Found element at {pos}."
+            ),
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! create_custom_char_set {
+    () => {{
+        CustomCharset { set: [EMPTY; CUSTOM_CHAR_COUNT as usize], len: 0 }
+    }};
+    ($($char:expr),+ $(,)?) => {{
+        // Count how many characters were passed using macro repetition length
+        const LEN: usize = [$(stringify!($char)),+].len();
+
+        // Ensure we don't exceed the defined maximum capacity
+        const _: () = assert!(
+            LEN <= CUSTOM_CHAR_COUNT as usize,
+            "Too many characters provided for CUSTOM_CHAR_COUNT"
+        );
+
+        // Build a fixed-size array populated with the provided characters,
+        // and pad the rest with empty CharMaps (zeros) to fit CUSTOM_CHAR_COUNT.
+        const SET: [CharMap; CUSTOM_CHAR_COUNT as usize] = {
+            let mut buffer = [[0u8; 8]; CUSTOM_CHAR_COUNT as usize];
+            let input = [$($char),*];
+            let mut i = 0;
+            while i < input.len() {
+                buffer[i] = input[i];
+                i += 1;
+            }
+            buffer
+        };
+
+        CustomCharset {
+            set: SET,
+            len: LEN,
+        }
+    }};
+}
+
+pub const CUSTOM_CHAR_COUNT: u8 = 16;
+
+pub const HEART: CharMap = [
+    0b00000, // Top row
+    0b01010, //  * *
+    0b11111, // *****
+    0b11111, // *****
+    0b01110, //  ***
+    0b00100, //   *
+    0b00000, // Bottom row
+    0b00000, // Cursor line (usually left blank)
+];
+
+pub const EMPTY: CharMap = [0; 8];
+pub const BOX: CharMap = [
+    0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111,
+    0b00000, // Cursor line (usually left blank)
+];
+
+pub const EXAMPLE: CustomCharset = create_custom_char_set!(HEART, BOX, EMPTY);
+
@@ -2,6 +2,7 @@

 extern crate alloc;

+pub mod background_tasks;
 pub mod card;
 pub mod display;
 pub mod drivers;
@@ -1,4 +1,4 @@
 pub mod inputs;
 pub mod navigation;
-pub mod state;
 pub mod outputs;
+pub mod state;
@@ -1,28 +1,26 @@
 use embedded_graphics::{
-    draw_target::DrawTarget as _,
-    pixelcolor::{Rgb565, RgbColor as _},
+    draw_target::DrawTarget as _, pixelcolor::{BinaryColor, Rgb565, RgbColor as _},
 };

-use crate::display::{
-    shared_bus::{DualPrimaryDisplay, DualSecondaryDisplay},
-    tertiary_lcd::TertiaryI2cLcd,
+use crate::drivers::{
+    primary_lcd::PrimaryDisplay, secondary_oled::SecondaryDisplay, tertiary_lcd::TertiaryDisplay,
 };

 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 primary_display: PrimaryDisplay<'static>,
+    pub secondary_display_1: SecondaryDisplay<'static>,
+    pub secondary_display_2: SecondaryDisplay<'static>,
+    pub secondary_display_3: SecondaryDisplay<'static>,
+    pub tertiary_display: TertiaryDisplay<'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.secondary_display_1.clear(BinaryColor::Off).unwrap();
+        self.secondary_display_2.clear(BinaryColor::Off).unwrap();
+        self.secondary_display_3.clear(BinaryColor::Off).unwrap();
        self.tertiary_display.clear().unwrap();
    }
 }
@@ -7,7 +7,12 @@ use embedded_graphics::prelude::RgbColor;
 use embedded_graphics_core::draw_target::DrawTarget;

 use crate::{
-    card::model::Card, navigation::{navigation::{Action, Navigable, NewState}, outputs::Outputs}, views::view::View,
+    card::model::Card,
+    navigation::{
+        navigation::{Action, Navigable, NewState},
+        outputs::Outputs,
+    },
+    views::view::View,
 };

 #[derive(Debug, Clone)]
@@ -22,8 +22,7 @@ pub struct MainMenu {
 }

 impl Navigable for MainMenu {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send
-    {
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
        let display = &mut outputs.primary_display;
        display.clear(Rgb565::BLACK).unwrap();

@@ -33,8 +33,7 @@ pub struct ScanMenu {
 }

 impl Navigable for ScanMenu {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send
-    {
+    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();
@@ -1,4 +1,3 @@
-
 use crate::navigation::outputs::Outputs;
 use crate::views::card_view::CardView;
 use crate::views::{
@@ -18,8 +17,7 @@ pub enum View {
 }

 impl Navigable for View {
-    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send
-    {
+    fn display(&self, outputs: &mut Outputs) -> impl core::future::Future<Output = ()> + Send {
        async move {
            match self {
                View::Main(main_menu) => main_menu.display(outputs).await,
Author	SHA1	Message	Date
ede1998	bd124bf9c2	prepare alternative display driver support	2026-08-26 21:51:01 +02:00
ede1998	e33262577d	rework tertiary display API again	2026-08-26 19:39:33 +02:00
ede1998	e26b1f571d	improved char display API	2026-08-25 01:05:23 +02:00
ede1998	a051bcd08a	move nfc to background tasks	2026-08-24 21:05:59 +02:00
ede1998	680964b631	make NFC read protocol error recoverable	2026-08-24 20:55:03 +02:00
ede1998	25ddf8ca25	update deps	2026-08-24 20:07:54 +02:00
ede1998	ce661a4bde	refactor nfc reader code a bit	2026-08-23 19:30:10 +02:00
ede1998	beb972e0d1	refactor all hardware init in drivers	2026-08-23 19:30:10 +02:00
ede1998	f59ee96cbc	Rename display type aliases	2026-08-23 19:30:10 +02:00
ede1998	b2a8fdea5e	triple oled initialization	2026-08-23 16:07:45 +02:00