124 lines
3.8 KiB
Rust
124 lines
3.8 KiB
Rust
// Manages display hardware
|
|
use crate::dither::DitheredImage;
|
|
use anyhow::Result;
|
|
use epd_waveshare::{epd7in3f::Epd7in3f, prelude::WaveshareDisplay};
|
|
use linux_embedded_hal::gpio_cdev::{Chip, LineRequestFlags};
|
|
use linux_embedded_hal::spidev::SpiModeFlags;
|
|
use linux_embedded_hal::spidev::SpidevOptions;
|
|
use linux_embedded_hal::{CdevPin, Delay, SpidevDevice};
|
|
use std::sync::mpsc;
|
|
use std::thread;
|
|
use tracing::instrument;
|
|
use tracing::span;
|
|
use tracing::{debug, error, info, warn, Level};
|
|
|
|
pub trait EInkPanel {
|
|
fn display(&mut self, buf: &DitheredImage) -> Result<()>;
|
|
}
|
|
|
|
pub struct Wrapper {
|
|
spi: SpidevDevice,
|
|
gpiochip: Chip,
|
|
delay: Delay,
|
|
panel: Epd7in3f<SpidevDevice, CdevPin, CdevPin, CdevPin, Delay>,
|
|
}
|
|
|
|
impl Wrapper {
|
|
pub fn new() -> Result<Self> {
|
|
let mut spi = SpidevDevice::open("/dev/spidev0.0")?;
|
|
let spi_options = SpidevOptions::new()
|
|
.bits_per_word(8)
|
|
.max_speed_hz(10_000_000)
|
|
.mode(SpiModeFlags::SPI_MODE_0)
|
|
.build();
|
|
spi.configure(&spi_options)?;
|
|
|
|
let mut gpiochip = Chip::new("/dev/gpiochip0")?;
|
|
let busy_pin = CdevPin::new(gpiochip.get_line(24)?.request(
|
|
LineRequestFlags::INPUT,
|
|
0,
|
|
"frametool",
|
|
)?)?;
|
|
let dc_pin = CdevPin::new(gpiochip.get_line(25)?.request(
|
|
LineRequestFlags::OUTPUT,
|
|
0,
|
|
"frametool",
|
|
)?)?;
|
|
let rst_pin = CdevPin::new(gpiochip.get_line(17)?.request(
|
|
LineRequestFlags::OUTPUT,
|
|
0,
|
|
"frametool",
|
|
)?)?;
|
|
let mut delay = Delay {};
|
|
let panel = Epd7in3f::new(&mut spi, busy_pin, dc_pin, rst_pin, &mut delay, None)?;
|
|
|
|
Ok(Self {
|
|
spi,
|
|
gpiochip,
|
|
delay,
|
|
panel,
|
|
})
|
|
}
|
|
pub fn test(&mut self) -> Result<()> {
|
|
self.panel.show_7block(&mut self.spi, &mut self.delay)?;
|
|
self.panel.sleep(&mut self.spi, &mut self.delay)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl EInkPanel for Wrapper {
|
|
#[instrument(skip_all)]
|
|
fn display(&mut self, img: &DitheredImage) -> Result<()> {
|
|
let buf = img.into_display_buffer();
|
|
self.panel
|
|
.update_and_display_frame(&mut self.spi, &buf, &mut self.delay)?;
|
|
debug!("Finished updating frame");
|
|
self.panel.sleep(&mut self.spi, &mut self.delay)?;
|
|
debug!("Display entered sleep mode");
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// A Fake EInk display for testing purposes.
|
|
/// Saves the output as `display.bmp`
|
|
pub struct FakeEInk();
|
|
impl EInkPanel for FakeEInk {
|
|
fn display(&mut self, img: &DitheredImage) -> Result<()> {
|
|
warn!("Fake display was called: saving to display.bmp");
|
|
img.into_rgbimage().save("display.bmp")?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Create a thread that can take dithered images and display them. This allows the display to be
|
|
/// used in an async context since updating the display can take ~30 seconds.
|
|
#[must_use]
|
|
pub fn create_display_thread(
|
|
mut display: Box<dyn EInkPanel + Send>,
|
|
) -> (thread::JoinHandle<()>, mpsc::Sender<Box<DitheredImage>>) {
|
|
let (tx, rx) = mpsc::channel::<Box<DitheredImage>>();
|
|
let handle = thread::spawn(move || {
|
|
let span = span!(Level::INFO, "display_thread");
|
|
let _enter = span.enter();
|
|
loop {
|
|
let res = rx.recv();
|
|
match res {
|
|
Ok(img) => {
|
|
info!("Received an image to display");
|
|
if let Err(e) = display.display(&img) {
|
|
error!("Error displaying image: {e}");
|
|
return;
|
|
}
|
|
info!("Successfully set display image");
|
|
}
|
|
Err(e) => {
|
|
error!("Error reading image from channel: {e}");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
(handle, tx)
|
|
}
|