prepare alternative display driver support

Cargo.lock

@@ -321,6 +321,7 @@ dependencies = [
  "base64 0.23.1",
  "ch1115",
  "critical-section",
+ "display-interface",
  "display-interface-spi",
  "embassy-executor",
  "embassy-futures",
@@ -343,6 +344,7 @@ dependencies = [
  "log",
  "num_enum",
  "pn532",
+ "ssd1306",
 ]
 
 [[package]]
@@ -607,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"
@@ -1942,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"
@@ -2690,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"
@@ -2719,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"
@@ -3133,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"
@@ -3400,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"

Cargo.toml

@@ -9,11 +9,7 @@ name = "creaturedex"
 path = "./src/bin/main.rs"
 
 [dependencies]
-esp-hal = { version = "~1.1.0", features = [
+esp-hal = { version = "~1.1.0", features = ["esp32s3", "log-04", "unstable"] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
-  "esp32s3",
-  "log-04",
-  "unstable",
-] } #, "embassy", "embassy-time-timg0", "embassy-executor-thread"] }
 
 esp-rtos = { version = "0.3.0", features = [
   "embassy",
@@ -28,7 +24,8 @@ log = "0.4.27"
 
 critical-section = "1.2.0"
 embedded-io = "0.7.1"
-embassy-executor = { version = "0.10.0", features = [] }
+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"
@@ -38,6 +35,7 @@ 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"
@@ -50,9 +48,7 @@ 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 = [] }
-[build-dependencies]
-log = "0.4.27"
 
 
 [patch.crates-io]

build.rs

@@ -1,5 +1,4 @@
 fn main() {
-    generate_filter_snippet();
     linker_be_nice();
     // make sure linkall.x is the last linker script (otherwise might cause problems with flip-link)
     println!("cargo:rustc-link-arg=-Tlinkall.x");
@@ -69,165 +68,3 @@ fn linker_be_nice() {
         std::env::current_exe().unwrap().display()
     );
 }
-
-// Taken over from esp_println because impossible to just extend their existing env logger.
-// https://github.com/esp-rs/esp-hal/blob/8fa6d7e985e724d6ad998e34307429b0920da370/esp-println/build.rs
-fn generate_filter_snippet() {
-    use log::LevelFilter;
-    use std::{env, path::Path};
-
-    let out_dir = env::var_os("OUT_DIR").unwrap();
-    let dest_path = Path::new(&out_dir).join("log_filter.rs");
-
-    let filter = env::var("ESP_LOG");
-    let snippet = if let Ok(filter) = filter {
-        let res = parse_spec(&filter);
-
-        if !res.errors.is_empty() {
-            panic!("Error parsing `ESP_LOG`: {:?}", res.errors);
-        } else {
-            let max = res
-                .directives
-                .iter()
-                .map(|v| v.level)
-                .max()
-                .unwrap_or(LevelFilter::Off);
-            let max = match max {
-                LevelFilter::Off => "Off",
-                LevelFilter::Error => "Error",
-                LevelFilter::Warn => "Warn",
-                LevelFilter::Info => "Info",
-                LevelFilter::Debug => "Debug",
-                LevelFilter::Trace => "Trace",
-            };
-
-            let mut snippet = String::new();
-
-            snippet.push_str(&format!(
-                "pub(crate) const FILTER_MAX: log::LevelFilter = log::LevelFilter::{max};"
-            ));
-
-            snippet
-                .push_str("pub(crate) fn is_enabled(level: log::Level, _target: &str) -> bool {");
-
-            let mut global_level = None;
-            for directive in res.directives {
-                let level = match directive.level {
-                    LevelFilter::Off => "Off",
-                    LevelFilter::Error => "Error",
-                    LevelFilter::Warn => "Warn",
-                    LevelFilter::Info => "Info",
-                    LevelFilter::Debug => "Debug",
-                    LevelFilter::Trace => "Trace",
-                };
-
-                if let Some(name) = directive.name {
-                    // If a prefix matches, don't continue to the next directive
-                    snippet.push_str(&format!(
-                        "if _target.starts_with(\"{name}\") {{ return level <= log::LevelFilter::{level}; }}"
-                    ));
-                } else {
-                    if global_level.is_some() {
-                        panic!("Multiple global log levels specified in `ESP_LOG`");
-                    }
-                    global_level = Some(level);
-                }
-            }
-
-            // Place the fallback rule at the end
-            if let Some(level) = global_level {
-                snippet.push_str(&format!("level <= log::LevelFilter::{level}"));
-            } else {
-                snippet.push_str(" false");
-            }
-            snippet.push('}');
-            snippet
-        }
-    } else {
-        "pub(crate) const FILTER_MAX: log::LevelFilter = log::LevelFilter::Off; pub(crate) fn is_enabled(_level: log::Level, _target: &str) -> bool { true }".to_string()
-    };
-
-    std::fs::write(&dest_path, &snippet).unwrap();
-}
-
-#[derive(Default, Debug)]
-struct ParseResult {
-    pub(crate) directives: Vec<Directive>,
-    pub(crate) errors: Vec<String>,
-}
-
-impl ParseResult {
-    fn add_directive(&mut self, directive: Directive) {
-        self.directives.push(directive);
-    }
-
-    fn add_error(&mut self, message: String) {
-        self.errors.push(message);
-    }
-}
-
-#[derive(Debug)]
-struct Directive {
-    pub(crate) name: Option<String>,
-    pub(crate) level: log::LevelFilter,
-}
-
-/// Parse a logging specification string (e.g:
-/// `crate1,crate2::mod3,crate3::x=error/foo`) and return a vector with log
-/// directives.
-fn parse_spec(spec: &str) -> ParseResult {
-    use log::LevelFilter;
-
-    let mut result = ParseResult::default();
-
-    let mut parts = spec.split('/');
-    let mods = parts.next();
-
-    if let Some(m) = mods {
-        for s in m.split(',').map(|ss| ss.trim()) {
-            if s.is_empty() {
-                continue;
-            }
-            let mut parts = s.split('=');
-            let (log_level, name) =
-                match (parts.next(), parts.next().map(|s| s.trim()), parts.next()) {
-                    (Some(part0), None, None) => {
-                        // if the single argument is a log-level string or number,
-                        // treat that as a global fallback
-                        match part0.parse() {
-                            Ok(num) => (num, None),
-                            Err(_) => (LevelFilter::max(), Some(part0)),
-                        }
-                    }
-                    (Some(part0), Some(""), None) => (LevelFilter::max(), Some(part0)),
-                    (Some(part0), Some(part1), None) => {
-                        if let Ok(num) = part1.parse() {
-                            (num, Some(part0))
-                        } else {
-                            result.add_error(format!("invalid logging spec '{part1}'"));
-                            continue;
-                        }
-                    }
-                    _ => {
-                        result.add_error(format!("invalid logging spec '{s}'"));
-                        continue;
-                    }
-                };
-
-            result.add_directive(Directive {
-                name: name.map(|s| s.to_owned()),
-                level: log_level,
-            });
-        }
-    }
-
-    // Sort by length so that the most specific prefixes come first
-    result
-        .directives
-        .sort_by(|a, b| match (a.name.as_ref(), b.name.as_ref()) {
-            (Some(a), Some(b)) => b.len().cmp(&a.len()),
-            _ => std::cmp::Ordering::Equal,
-        });
-
-    result
-}

src/bin/main.rs

@@ -52,7 +52,7 @@ esp_bootloader_esp_idf::esp_app_desc!();
 )]
 #[esp_rtos::main]
 async fn main(spawner: Spawner) {
-    creaturedex::logging::init();
+    esp_println::logger::init_logger_from_env();
 
     let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
     let peripherals = esp_hal::init(config);
@@ -64,9 +64,7 @@ async fn main(spawner: Spawner) {
     let timg0 = TimerGroup::new(peripherals.TIMG0);
     esp_rtos::start(timg0.timer0, sw_interrupt.software_interrupt0);
 
-    let (primary, mut secondaries) = retry(
+    let (primary, mut secondaries) = spi_bus::DisplayPinConfiguration {
-        5,
-        spi_bus::DisplayPinConfiguration {
         spi_peripheral: peripherals.SPI2,
         sck: peripherals.GPIO36,
         mosi: peripherals.GPIO35,
@@ -78,33 +76,25 @@ async fn main(spawner: Spawner) {
         reset_primary: peripherals.GPIO10,
         reset_secondary: peripherals.GPIO47,
         dc_pin: peripherals.GPIO12,
-        },
+    }
-        spi_bus::DisplayPinConfiguration::build,
+    .build();
-    );
 
     // Initialize the shared I2C bus using the refactored i2c_bus module.
     let shared_i2c = {
-        use alloc::boxed::Box;
+        let config = I2cBusPinConfiguration {
-        let bus = retry(5, I2cBusPinConfiguration {
             i2c_peripheral: peripherals.I2C0,
             scl: peripherals.GPIO18,
             sda: peripherals.GPIO17,
-        }, I2cBusPinConfiguration::build);
+        };
-        Box::leak(Box::new(bus))
+        config.build()
     };
 
-    let mut lcd: TertiaryDisplay = retry(
+    let mut lcd: TertiaryDisplay = TertiaryDisplayPinConfiguration { i2c: shared_i2c }.build();
-        5,
-        TertiaryDisplayPinConfiguration { i2c: shared_i2c },
-        TertiaryDisplayPinConfiguration::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!(
+    if let Err(e) = lcd.write(&alloc::format!("Custom symbols: {h}{e}{b} And more stuff to wrap and cut off please.")) {
-        "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}"
         );
@@ -148,11 +138,10 @@ async fn main(spawner: Spawner) {
     log::info!("Setup complete, entering main loop");
     spawner.spawn(navigation::run(inputs, outputs).expect("run task failed"));
     spawner.spawn(background_tasks::nfc_scanner(nfc_driver).expect("nfc scanner task failed"));
-    core::future::pending::<()>().await
 }
 
 fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
-    oled.clear().unwrap();
+    oled.clear(BinaryColor::Off).unwrap();
 
     let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
     Text::new(text, Point::new(10, 20), text_style)
@@ -160,17 +149,3 @@ fn display_shit(oled: &mut SecondaryDisplay<'static>, text: &str) {
         .unwrap();
     oled.flush().unwrap();
 }
-
-fn retry<T, U, F: FnMut(T) -> Result<U, T>>(repetitions: u32, input: T, mut action: F) -> U {
-    let mut initial_state = input;
-    for iteration in 0..repetitions {
-        log::debug!("Trying to initialize. Retries: {iteration}");
-
-        match action(initial_state) {
-            Ok(success) => return success,
-            Err(recovered_input) => initial_state = recovered_input,
-        }
-    }
-
-    panic!("Init failed after {repetitions} retries.")
-}

src/drivers/i2c_bus.rs

@@ -1,3 +1,4 @@
+use alloc::boxed::Box;
 use embedded_hal_bus::i2c::AtomicDevice;
 use embedded_hal_bus::util::AtomicCell;
 use esp_hal::gpio::interconnect::PeripheralInput;
@@ -20,19 +21,18 @@ where
     SCL: PeripheralOutput<'a> + PeripheralInput<'a>,
     SDA: PeripheralOutput<'a> + PeripheralInput<'a>,
 {
-    pub fn build(self) -> Result<AtomicCell<InnerI2cBus<'a>>, Self> {
+    pub fn build(self) -> I2cBus<'a> {
         let config = Config::default().with_frequency(esp_hal::time::Rate::from_khz(400));
-        match I2c::new(self.i2c_peripheral, config) {
+        let i2c = match I2c::new(self.i2c_peripheral, config) {
-            Ok(bus) => {
+            Ok(bus) => bus.with_sda(self.sda).with_scl(self.scl),
-                let i2c = bus.with_sda(self.sda).with_scl(self.scl);
-                log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
-                Ok(AtomicCell::new(i2c))
-            }
             Err(e) => {
                 log::error!("Shared I2C bus initialization failed for GPIO17/GPIO18: {e:?}");
-                unimplemented!("Partial move makes it impossible to retry.");
+                panic!("Shared I2C bus initialization failed");
-                // Err(self)
-            }
             }
+        };
+        let shared_i2c = Box::leak(Box::new(AtomicCell::new(i2c)));
+        log::info!("Shared I2C bus ready on GPIO17 (SDA) and GPIO18 (SCL)");
+
+        shared_i2c
     }
 }

src/drivers/secondary_oled.rs

@@ -1,6 +1,6 @@
-use alloc::format;
+use alloc::{format, string::String};
-use ch1115::{Ch1115, Size128x64};
 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;
@@ -8,10 +8,72 @@ use esp_hal::gpio::Output;
 
 use crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput, SharedReset};
 
-pub type GenericSecondaryDisplay<'a, BUS, RST, DC> =
+pub struct SecondaryDisplay<'a>(
-    Ch1115<SPIInterface<AtomicDevice<'a, BUS, Output<'a>, Delay>, DC>, RST, Size128x64>;
+    #[cfg(feature = "wokwi")] ssd1306_aliases::SecondaryDisplay<'a>,
-pub type SecondaryDisplay<'a> =
+    #[cfg(not(feature = "wokwi"))] ch1115_aliases::SecondaryDisplay<'a>,
-    GenericSecondaryDisplay<'a, DisplaySpiBus, SharedReset<'a>, SharedOutput<'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>,
@@ -21,25 +83,46 @@ pub struct SecondaryDisplayPinConfiguration<'a> {
 }
 
 impl<'a> SecondaryDisplayPinConfiguration<'a> {
-    pub fn build(self) -> [SecondaryDisplay<'a>; 3] {
+    pub fn build(self) -> [SecondaryDisplay<'a>; SECONDARY_DISPLAY_COUNT] {
-        let mut displays = self.cs_pins.map(|cs| {
+        #[cfg(feature = "wokwi")]
-            let spi_dev = AtomicDevice::new(self.spi_bus, cs, Delay::new()).unwrap();
+        type Displays<'b> = [ssd1306_aliases::SecondaryDisplay<'b>; SECONDARY_DISPLAY_COUNT];
-            let interface = SPIInterface::new(spi_dev, self.dc.clone());
+        #[cfg(not(feature = "wokwi"))]
+        type Displays<'b> = [ch1115_aliases::SecondaryDisplay<'b>; SECONDARY_DISPLAY_COUNT];
 
-            Ch1115::new(interface, self.res.clone(), Size128x64)
+        let reset_pin = self.res.clone();
-        });
+        let mut displays = Displays::new(self);
+        displays.reset(reset_pin);
 
-        init_single_reset(&mut displays, self.res);
+        displays.map(SecondaryDisplay)
-
-        displays
     }
 }
 
-fn init_single_reset<'a: 'b, 'b>(
+trait MultiDisplay<'a> {
-    displays: impl IntoIterator<Item = &'b mut SecondaryDisplay<'a>>,
+    fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self;
-    shared_reset: SharedReset<'a>,
+    fn reset(&mut self, shared_reset: SharedReset<'a>);
-) {
+}
-    let mut displays = displays.into_iter().peekable();
+
+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 {
@@ -56,4 +139,56 @@ fn init_single_reset<'a: 'b, 'b>(
                     .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();
+            }
+        }
+    }
 }

src/drivers/spi_bus.rs

@@ -135,7 +135,7 @@ where
     RES2: OutputPin + 'static,
     DC: OutputPin + 'static,
 {
-    pub fn build(self) -> Result<(PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]), Self> {
+    pub fn build(self) -> (PrimaryDisplay<'static>, [SecondaryDisplay<'static>; 3]) {
         let spi = Spi::new(
             self.spi_peripheral,
             SpiConfig::default()
@@ -178,7 +178,7 @@ where
         }
         .build();
 
-        Ok((primary, secondaries))
+        (primary, secondaries)
     }
 }
 

src/drivers/tertiary_lcd.rs

@@ -15,20 +15,19 @@ pub struct TertiaryDisplayPinConfiguration<'a> {
 }
 
 impl<'a> TertiaryDisplayPinConfiguration<'a> {
-    pub fn build(self) -> Result<TertiaryDisplay<'a>, Self> {
+    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");
-                Ok(TertiaryDisplay {
+                TertiaryDisplay {
                     display: lcd,
                     charset: create_custom_char_set!(),
-                })
+                }
             }
             Err(e) => {
-                log::error!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
+                panic!("I2C tertiary LCD init failed on PCF8574T at address 0x27: {e}");
-                Err(self)
             }
         }
     }
@@ -408,3 +407,4 @@ pub const BOX: CharMap = [
 ];
 
 pub const EXAMPLE: CustomCharset = create_custom_char_set!(HEART, BOX, EMPTY);
+

src/lib.rs

@@ -6,7 +6,6 @@ pub mod background_tasks;
 pub mod card;
 pub mod display;
 pub mod drivers;
-pub mod logging;
 pub mod navigation;
 pub mod network;
 pub mod storage;

src/logging.rs

@@ -1,83 +0,0 @@
-mod logging_config {
-    include!(concat!(env!("OUT_DIR"), "/log_filter.rs"));
-}
-
-struct EnvLogger;
-
-impl log::Log for EnvLogger {
-    fn enabled(&self, metadata: &log::Metadata) -> bool {
-        let level = metadata.level();
-        let target = metadata.target();
-        logging_config::is_enabled(level, target)
-    }
-
-    fn log(&self, record: &log::Record) {
-        if !self.enabled(record.metadata()) {
-            return;
-        }
-
-        // print with color? default to true if env var unset or set but empty.
-        let with_color = 1
-            == option_env!("ESP_LOG_COLOR")
-                .unwrap_or("1")
-                .parse()
-                .unwrap_or(1);
-        let (color, reset) = if with_color {
-            const RESET: &str = "\u{001B}[0m";
-            const RED: &str = "\u{001B}[31m";
-            const GREEN: &str = "\u{001B}[32m";
-            const YELLOW: &str = "\u{001B}[33m";
-            const BLUE: &str = "\u{001B}[34m";
-            const CYAN: &str = "\u{001B}[35m";
-
-            let color = match record.level() {
-                log::Level::Error => RED,
-                log::Level::Warn => YELLOW,
-                log::Level::Info => GREEN,
-                log::Level::Debug => BLUE,
-                log::Level::Trace => CYAN,
-            };
-            let reset = RESET;
-            (color, reset)
-        } else {
-            ("", "")
-        };
-
-        let [now_s, now_ms] = {
-            let now = esp_hal::time::Instant::now()
-                .duration_since_epoch()
-                .as_millis();
-
-            [now / 1000, now % 1000]
-        };
-
-        let level = match record.level() {
-            log::Level::Error => "E",
-            log::Level::Warn => "W",
-            log::Level::Info => "I",
-            log::Level::Debug => "D",
-            log::Level::Trace => "T",
-        };
-        let args = record.args();
-        let line = record.line().unwrap_or(0);
-        let target = record.target();
-        let module = record.module_path().unwrap_or("???");
-
-        let (module, divider) = if module == target {
-            ("", "")
-        } else {
-            (module, " ")
-        };
-
-        esp_println::println!(
-            "{color}{now_s:>4}.{now_ms:03}s {level} {target}{divider}{module}:{line} - {args}{reset}"
-        );
-    }
-
-    fn flush(&self) {}
-}
-
-pub fn init() {
-    log::set_logger(&EnvLogger).expect("Failed to init logger.");
-    log::set_max_level(logging_config::FILTER_MAX);
-}

src/navigation/outputs.rs

@@ -1,6 +1,5 @@
 use embedded_graphics::{
-    draw_target::DrawTarget as _,
+    draw_target::DrawTarget as _, pixelcolor::{BinaryColor, Rgb565, RgbColor as _},
-    pixelcolor::{Rgb565, RgbColor as _},
 };
 
 use crate::drivers::{
@@ -19,9 +18,9 @@ pub struct Outputs {
 impl Outputs {
     pub fn clear_screens(&mut self) {
         self.primary_display.clear(Rgb565::BLACK).unwrap();
-        self.secondary_display_1.clear().unwrap();
+        self.secondary_display_1.clear(BinaryColor::Off).unwrap();
-        // self.secondary_display_2.clear().unwrap();
+        self.secondary_display_2.clear(BinaryColor::Off).unwrap();
-        // self.secondary_display_3.clear().unwrap();
+        self.secondary_display_3.clear(BinaryColor::Off).unwrap();
         self.tertiary_display.clear().unwrap();
     }
 }