rhetenor/creaturedex
1
0
Fork 0
Code Issues 22 Pull Requests Packages Projects 1 Releases Wiki Activity

prepare alternative display driver support

Browse Source
This commit is contained in:
ede1998
2026-08-26 21:51:01 +02:00
parent e33262577d
commit bd124bf9c2
5 changed files with 254 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bin/main.rs
+1 -1
View File
@@ -141,7 +141,7 @@ async fn main(spawner: Spawner) {
}
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)
src/drivers/secondary_oled.rs
+166 -31
View File
@@ -1,6 +1,6 @@
use alloc::format;
use ch1115::{Ch1115, Size128x64};
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;
@@ -8,10 +8,72 @@ use esp_hal::gpio::Output;
use crate::drivers::spi_bus::{DisplaySpiBus, SharedOutput, SharedReset};
pub 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>>;
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>,
@@ -21,39 +83,112 @@ pub struct SecondaryDisplayPinConfiguration<'a> {
}
impl<'a> SecondaryDisplayPinConfiguration<'a> {
pub fn build(self) -> [SecondaryDisplay<'a>; 3] {
let mut displays = self.cs_pins.map(|cs| {
let spi_dev = AtomicDevice::new(self.spi_bus, cs, Delay::new()).unwrap();
let interface = SPIInterface::new(spi_dev, self.dc.clone());
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];
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
displays.map(SecondaryDisplay)
}
}
fn init_single_reset<'a: 'b, 'b>(
displays: impl IntoIterator<Item = &'b mut SecondaryDisplay<'a>>,
shared_reset: SharedReset<'a>,
) {
let mut displays = displays.into_iter().peekable();
trait MultiDisplay<'a> {
fn new(config: SecondaryDisplayPinConfiguration<'a>) -> Self;
fn reset(&mut self, shared_reset: SharedReset<'a>);
}
// Reset all secondaries via shared reset
let Some(any_display) = displays.peek_mut() else {
// no display to initialize
return;
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,
};
any_display.hard_reset(&mut Delay::new()).unwrap();
shared_reset.disable(true);
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>>;
for (i, display) in displays.enumerate() {
display
.init(&mut Delay::new())
.map_err(|e| format!("Failed to init secondary display {}: {e:?}", i + 1))
.unwrap();
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/navigation/outputs.rs
+4 -5
View File
@@ -1,6 +1,5 @@
use embedded_graphics::{
draw_target::DrawTarget as _,
pixelcolor::{Rgb565, RgbColor as _},
draw_target::DrawTarget as _, pixelcolor::{BinaryColor, 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_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();
}
}