From 5c21f8b6e2c346ab27a533bb062e8e83ce2e44bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Wed, 19 Aug 2020 16:07:08 +0200 Subject: [PATCH] WIP: early support for 2in13 e-ink --- src/epd2in13_v2/command.rs | 121 ++++++++++++ src/epd2in13_v2/constants.rs | 39 ++++ src/epd2in13_v2/graphics.rs | 149 ++++++++++++++ src/epd2in13_v2/mod.rs | 369 +++++++++++++++++++++++++++++++++++ src/lib.rs | 1 + 5 files changed, 679 insertions(+) create mode 100644 src/epd2in13_v2/command.rs create mode 100644 src/epd2in13_v2/constants.rs create mode 100644 src/epd2in13_v2/graphics.rs create mode 100644 src/epd2in13_v2/mod.rs diff --git a/src/epd2in13_v2/command.rs b/src/epd2in13_v2/command.rs new file mode 100644 index 00000000..7fa1b37a --- /dev/null +++ b/src/epd2in13_v2/command.rs @@ -0,0 +1,121 @@ +//! SPI Commands for the Waveshare 2.13" v2 + +use crate::traits; + +/// EPD2in13 v2 +/// +/// Should rarely (never?) be needed directly. +/// +/// For more infos about the addresses and what they are doing look into the pdfs +#[allow(dead_code)] +#[allow(non_camel_case_types)] +#[derive(Copy, Clone)] +pub(crate) enum Command { + /// Driver Output control + /// 3 Databytes: + /// A[7:0] + /// 0.. A[8] + /// 0.. B[2:0] + /// Default: Set A[8:0] = 0x127 and B[2:0] = 0x0 + DRIVER_OUTPUT_CONTROL = 0x01, + + GATE_DRIVING_VOLTAGE_CTRL = 0x03, + SOURCE_DRIVING_VOLTAGE_CTRL = 0x04, + + /// Booster Soft start control + /// 3 Databytes: + /// 1.. A[6:0] + /// 1.. B[6:0] + /// 1.. C[6:0] + /// Default: A[7:0] = 0xCF, B[7:0] = 0xCE, C[7:0] = 0x8D + BOOSTER_SOFT_START_CONTROL = 0x0C, + GATE_SCAN_START_POSITION = 0x0F, + //TODO: useful? + // GATE_SCAN_START_POSITION = 0x0F, + /// Deep Sleep Mode Control + /// 1 Databyte: + /// 0.. A[0] + /// Values: + /// A[0] = 0: Normal Mode (POR) + /// A[0] = 1: Enter Deep Sleep Mode + DEEP_SLEEP_MODE = 0x10, + // /// Data Entry mode setting + DATA_ENTRY_MODE_SETTING = 0x11, + + SW_RESET = 0x12, + + TEMPERATURE_SENSOR_CONTROL_WRITE = 0x1A, + TEMPERATURE_SENSOR_CONTROL_READ = 0x1B, + + MASTER_ACTIVATION = 0x20, + + DISPLAY_UPDATE_CONTROL_1 = 0x21, + + DISPLAY_UPDATE_CONTROL_2 = 0x22, + + WRITE_RAM = 0x24, + READ_RAM = 0x27, + + VCOM_SENSE = 0x28, + + WRITE_VCOM_REGISTER = 0x2C, + + WRITE_LUT_REGISTER = 0x32, + + WRITE_REGISTER_TO_DISPLAY_OPT = 0x37, + WRITE_REGISTER_FOR_USER_ID = 0x38, + + SET_DUMMY_LINE_PERIOD = 0x3A, + + SET_GATE_LINE_WIDTH = 0x3B, + + BORDER_WAVEFORM_CONTROL = 0x3C, + + SET_RAM_X_ADDRESS_START_END_POSITION = 0x44, + + SET_RAM_Y_ADDRESS_START_END_POSITION = 0x45, + + SET_RAM_X_ADDRESS_COUNTER = 0x4E, + + SET_RAM_Y_ADDRESS_COUNTER = 0x4F, + + SET_ANALOG_BLOCK_CONTROL = 0x74, + + SET_DIGITAL_BLOCK_CONTROL = 0x7E, + + NOP = 0x7F, +} + +pub(crate) enum DataEntryModeIncr { + X_DECR_Y_DECR = 0x0, + X_INCR_Y_DECR = 0x1, + X_DECR_Y_INCR = 0x2, + X_INCR_Y_INCR = 0x3 +} + +pub (crate) enum DataEntryModeDir { + X_DIR = 0x0, + Y_DIR = 0x4, +} + +impl traits::Command for Command { + /// Returns the address of the command + fn address(self) -> u8 { + self as u8 + } +} + +#[cfg(test)] +mod tests { + use super::Command; + use crate::traits::Command as CommandTrait; + + #[test] + fn command_addr() { + assert_eq!(Command::DRIVER_OUTPUT_CONTROL.address(), 0x01); + + assert_eq!(Command::SET_RAM_X_ADDRESS_COUNTER.address(), 0x4E); + + assert_eq!(Command::NOP.address(), 0xFF); + } +} diff --git a/src/epd2in13_v2/constants.rs b/src/epd2in13_v2/constants.rs new file mode 100644 index 00000000..5f45a1c8 --- /dev/null +++ b/src/epd2in13_v2/constants.rs @@ -0,0 +1,39 @@ +#[rustfmt::skip] +// Original Waveforms from Waveshare +pub(crate) const LUT_FULL_UPDATE: [u8; 70] =[ + 0x80,0x60,0x40,0x00,0x00,0x00,0x00, // LUT0: BB: VS 0 ~7 + 0x10,0x60,0x20,0x00,0x00,0x00,0x00, // LUT1: BW: VS 0 ~7 + 0x80,0x60,0x40,0x00,0x00,0x00,0x00, // LUT2: WB: VS 0 ~7 + 0x10,0x60,0x20,0x00,0x00,0x00,0x00, // LUT3: WW: VS 0 ~7 + 0x00,0x00,0x00,0x00,0x00,0x00,0x00, // LUT4: VCOM: VS 0 ~7 + + 0x03,0x03,0x00,0x00,0x02, // TP0 A~D RP0 + 0x09,0x09,0x00,0x00,0x02, // TP1 A~D RP1 + 0x03,0x03,0x00,0x00,0x02, // TP2 A~D RP2 + 0x00,0x00,0x00,0x00,0x00, // TP3 A~D RP3 + 0x00,0x00,0x00,0x00,0x00, // TP4 A~D RP4 + 0x00,0x00,0x00,0x00,0x00, // TP5 A~D RP5 + 0x00,0x00,0x00,0x00,0x00, // TP6 A~D RP6 + +// 0x15,0x41,0xA8,0x32,0x30,0x0A, +]; + +#[rustfmt::skip] +pub(crate) const LUT_PARTIAL_UPDATE: [u8; 70] =[ + 0x00,0x00,0x00,0x00,0x00,0x00,0x00, // LUT0: BB: VS 0 ~7 + 0x80,0x00,0x00,0x00,0x00,0x00,0x00, // LUT1: BW: VS 0 ~7 + 0x40,0x00,0x00,0x00,0x00,0x00,0x00, // LUT2: WB: VS 0 ~7 + 0x00,0x00,0x00,0x00,0x00,0x00,0x00, // LUT3: WW: VS 0 ~7 + 0x00,0x00,0x00,0x00,0x00,0x00,0x00, // LUT4: VCOM: VS 0 ~7 + + 0x0A,0x00,0x00,0x00,0x00, // TP0 A~D RP0 + 0x00,0x00,0x00,0x00,0x00, // TP1 A~D RP1 + 0x00,0x00,0x00,0x00,0x00, // TP2 A~D RP2 + 0x00,0x00,0x00,0x00,0x00, // TP3 A~D RP3 + 0x00,0x00,0x00,0x00,0x00, // TP4 A~D RP4 + 0x00,0x00,0x00,0x00,0x00, // TP5 A~D RP5 + 0x00,0x00,0x00,0x00,0x00, // TP6 A~D RP6 + +// 0x15,0x41,0xA8,0x32,0x30,0x0A, +]; + diff --git a/src/epd2in13_v2/graphics.rs b/src/epd2in13_v2/graphics.rs new file mode 100644 index 00000000..4dbb668a --- /dev/null +++ b/src/epd2in13_v2/graphics.rs @@ -0,0 +1,149 @@ +use crate::epd2in13_v2::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH}; +use crate::graphics::{Display, DisplayRotation}; +use embedded_graphics::pixelcolor::BinaryColor; +use embedded_graphics::prelude::*; + +/// Full size buffer for use with the 2in13 v2 EPD +/// +/// Can also be manually constructed: +/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]` +pub struct Display2in13 { + buffer: [u8; WIDTH as usize * HEIGHT as usize / 8], + rotation: DisplayRotation, +} + +impl Default for Display2in13 { + fn default() -> Self { + Display2in13 { + buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); + WIDTH as usize * HEIGHT as usize / 8], + rotation: DisplayRotation::default(), + } + } +} + +impl DrawTarget for Display2in13 { + type Error = core::convert::Infallible; + + fn draw_pixel(&mut self, pixel: Pixel) -> Result<(), Self::Error> { + self.draw_helper(WIDTH, HEIGHT, pixel) + } + + fn size(&self) -> Size { + Size::new(WIDTH, HEIGHT) + } +} + +impl Display for Display2in13 { + fn buffer(&self) -> &[u8] { + &self.buffer + } + + fn get_mut_buffer(&mut self) -> &mut [u8] { + &mut self.buffer + } + + fn set_rotation(&mut self, rotation: DisplayRotation) { + self.rotation = rotation; + } + + fn rotation(&self) -> DisplayRotation { + self.rotation + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::color::{Black, Color}; + use crate::epd2in13_v2; + use crate::graphics::{Display, DisplayRotation}; + use embedded_graphics::{primitives::Line, style::PrimitiveStyle}; + + // test buffer length + #[test] + fn graphics_size() { + let display = Display2in13::default(); + assert_eq!(display.buffer().len(), 48000); + } + + // test default background color on all bytes + #[test] + fn graphics_default() { + let display = Display2in13::default(); + for &byte in display.buffer() { + assert_eq!(byte, epd2in13_v2::DEFAULT_BACKGROUND_COLOR.get_byte_value()); + } + } + + #[test] + fn graphics_rotation_0() { + let mut display = Display2in13::default(); + + let _ = Line::new(Point::new(0, 0), Point::new(7, 0)) + .into_styled(PrimitiveStyle::with_stroke(Black, 1)) + .draw(&mut display); + + let buffer = display.buffer(); + + assert_eq!(buffer[0], Color::Black.get_byte_value()); + + for &byte in buffer.iter().skip(1) { + assert_eq!(byte, epd2in13_v2::DEFAULT_BACKGROUND_COLOR.get_byte_value()); + } + } + + #[test] + fn graphics_rotation_90() { + let mut display = Display2in13::default(); + display.set_rotation(DisplayRotation::Rotate90); + + let _ = Line::new(Point::new(0, 792), Point::new(0, 799)) + .into_styled(PrimitiveStyle::with_stroke(Black, 1)) + .draw(&mut display); + + let buffer = display.buffer(); + + assert_eq!(buffer[0], Color::Black.get_byte_value()); + + for &byte in buffer.iter().skip(1) { + assert_eq!(byte, epd2in13_v2::DEFAULT_BACKGROUND_COLOR.get_byte_value()); + } + } + + #[test] + fn graphics_rotation_180() { + let mut display = Display2in13::default(); + display.set_rotation(DisplayRotation::Rotate180); + + let _ = Line::new(Point::new(792, 479), Point::new(799, 479)) + .into_styled(PrimitiveStyle::with_stroke(Black, 1)) + .draw(&mut display); + + let buffer = display.buffer(); + + assert_eq!(buffer[0], Color::Black.get_byte_value()); + + for &byte in buffer.iter().skip(1) { + assert_eq!(byte, epd2in13_v2::DEFAULT_BACKGROUND_COLOR.get_byte_value()); + } + } + + #[test] + fn graphics_rotation_270() { + let mut display = Display2in13::default(); + display.set_rotation(DisplayRotation::Rotate270); + + let _ = Line::new(Point::new(479, 0), Point::new(479, 7)) + .into_styled(PrimitiveStyle::with_stroke(Black, 1)) + .draw(&mut display); + + let buffer = display.buffer(); + + assert_eq!(buffer[0], Color::Black.get_byte_value()); + + for &byte in buffer.iter().skip(1) { + assert_eq!(byte, epd2in13_v2::DEFAULT_BACKGROUND_COLOR.get_byte_value()); + } + } +} diff --git a/src/epd2in13_v2/mod.rs b/src/epd2in13_v2/mod.rs new file mode 100644 index 00000000..cf0bd43c --- /dev/null +++ b/src/epd2in13_v2/mod.rs @@ -0,0 +1,369 @@ +//! A simple Driver for the Waveshare 2.13" E-Ink Display (V2) via SPI +//! +//! # References +//! +//! - [Datasheet](https://www.waveshare.com/wiki/7.5inch_e-Paper_HAT) +//! - [Waveshare C driver](https://github.com/waveshare/e-Paper/blob/master/RaspberryPi%26JetsonNano/c/lib/e-Paper/EPD_2in13_V2.c) +//! - [Waveshare Python driver](https://github.com/waveshare/e-Paper/blob/master/RaspberryPi%26JetsonNano/python/lib/waveshare_epd/epd2in13_V2.py) +//! - [Controller Datasheet SS1780](http://www.e-paper-display.com/download_detail/downloadsId=682.html) +//! + +use embedded_hal::{ + blocking::{delay::*, spi::Write}, + digital::v2::{InputPin, OutputPin}, +}; + +use crate::color::Color; +use crate::interface::DisplayInterface; +use crate::traits::{InternalWiAdditions, RefreshLUT, WaveshareDisplay}; + +pub(crate) mod command; +use self::command::{Command, DataEntryModeDir, DataEntryModeIncr}; + +pub(crate) mod constants; +use self::constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}; + +#[cfg(feature = "graphics")] +mod graphics; +#[cfg(feature = "graphics")] +pub use self::graphics::Display2in13; + +/// Width of the display. Beware the visible part is smaller (122) +pub const WIDTH: u32 = 128; + +/// Height of the display +pub const HEIGHT: u32 = 250; + +/// Default Background Color +pub const DEFAULT_BACKGROUND_COLOR: Color = Color::White; +const IS_BUSY_LOW: bool = false; + +/// EPD2in13 (V2) driver +/// +pub struct EPD2in13 { + /// Connection Interface + interface: DisplayInterface, + /// Background Color + background_color: Color, + refresh: RefreshLUT, +} + +impl InternalWiAdditions + for EPD2in13 +where + SPI: Write, + CS: OutputPin, + BUSY: InputPin, + DC: OutputPin, + RST: OutputPin, +{ + fn init>( + &mut self, + spi: &mut SPI, + delay: &mut DELAY, + ) -> Result<(), SPI::Error> { + // Reset the device + self.interface.reset(delay); + + self.command(spi, Command::SW_RESET)?; + + self.cmd_with_data(spi, Command::SET_ANALOG_BLOCK_CONTROL, &[0x54])?; + self.cmd_with_data(spi, Command::SET_DIGITAL_BLOCK_CONTROL, &[0x3B])?; + + self.cmd_with_data(spi, Command::DRIVER_OUTPUT_CONTROL, &[(HEIGHT-1) as u8, 0x00, 0x00])?; + + self.set_data_entry_mode(spi, DataEntryModeIncr::X_INCR_Y_INCR, DataEntryModeDir::X_DIR)?; + + // start from Gate 0 + self.cmd_with_data(spi, Command::GATE_SCAN_START_POSITION, &[0x00])?; + +// self.use_full_frame(spi)?; + + self.cmd_with_data(spi, Command::BORDER_WAVEFORM_CONTROL, &[0x03])?; + + // GxEPD: + self.cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0x70])?; + + self.cmd_with_data(spi, Command::GATE_DRIVING_VOLTAGE_CTRL, &[0x15])?; + self.cmd_with_data(spi, Command::SOURCE_DRIVING_VOLTAGE_CTRL, &[0x41, 0xA8, 0x32])?; + + // default values [POR] + self.cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x30])?; + self.cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x0A])?; + + self.set_lut(spi, None)?; + + self.wait_until_idle(); + Ok(()) + } +} + +impl WaveshareDisplay + for EPD2in13 +where + SPI: Write, + CS: OutputPin, + BUSY: InputPin, + DC: OutputPin, + RST: OutputPin, +{ + fn new>( + spi: &mut SPI, + cs: CS, + busy: BUSY, + dc: DC, + rst: RST, + delay: &mut DELAY, + ) -> Result { + let interface = DisplayInterface::new(cs, busy, dc, rst); + let color = DEFAULT_BACKGROUND_COLOR; + + let mut epd = EPD2in13 { + interface, + background_color: DEFAULT_BACKGROUND_COLOR, + refresh: RefreshLUT::FULL, + }; + + epd.init(spi, delay)?; + + Ok(epd) + } + + fn wake_up>( + &mut self, + spi: &mut SPI, + delay: &mut DELAY, + ) -> Result<(), SPI::Error> { + self.init(spi, delay) + } + + fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> { + self.wait_until_idle(); + + // was 0xC3 but nothing in doc. + self.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0x03])?; + self.command(spi, Command::MASTER_ACTIVATION)?; + + // 00 : normal + // 01 : deep sleep mode 1 + // 11 : deep sleep mode 2 + self.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x01])?; + Ok(()) + } + + fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> { + self.wait_until_idle(); + self.use_full_frame(spi)?; + self.interface + .cmd_with_data(spi, Command::WRITE_RAM, buffer)?; + Ok(()) + } + + fn update_partial_frame( + &mut self, + _spi: &mut SPI, + _buffer: &[u8], + _x: u32, + _y: u32, + _width: u32, + _height: u32, + ) -> Result<(), SPI::Error> { + unimplemented!(); + } + + fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> { + self.wait_until_idle(); + // orig: 0xC7 + self.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?; + self.command(spi, Command::MASTER_ACTIVATION)?; + self.wait_until_idle(); + Ok(()) + } + + fn update_and_display_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> { + self.update_frame(spi, buffer)?; + self.display_frame(spi)?; + Ok(()) + } + + fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> { + self.wait_until_idle(); + self.use_full_frame(spi)?; + + // clear the ram with the background color + let color = self.background_color.get_byte_value(); + + self.command(spi, Command::WRITE_RAM)?; + self.interface + .data_x_times(spi, color, WIDTH * HEIGHT / 8)?; + + self.use_full_frame(spi)?; + self.command(spi, Command::WRITE_RAM)?; + + for _ in 0..HEIGHT/10 { + self.interface.data_x_times(spi, 0x00, 16)?; + self.interface.data_x_times(spi, 0xFF, 16*9)?; + } + // let mut skip = 10; + + // for y in 0..(HEIGHT - 1) { + // for x in 0..(WIDTH-1)/8 { + // if !skip{ + // self.interface.data_x_times(spi, 0x00, 1)?; + // } + // skip = false; + // } + // } + + Ok(()) + } + + fn set_background_color(&mut self, background_color: Color) { + self.background_color = background_color; + } + + fn background_color(&self) -> &Color { + &self.background_color + } + + fn width(&self) -> u32 { + WIDTH + } + + fn height(&self) -> u32 { + HEIGHT + } + + fn set_lut( + &mut self, + spi: &mut SPI, + refresh_rate: Option, + ) -> Result<(), SPI::Error> { + if let Some(refresh_lut) = refresh_rate { + self.refresh = refresh_lut; + } + match self.refresh { + RefreshLUT::FULL => self.set_lut_helper(spi, &LUT_FULL_UPDATE), + RefreshLUT::QUICK => self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE), + } + } + + fn is_busy(&self) -> bool { + self.interface.is_busy(IS_BUSY_LOW) + } +} + +impl EPD2in13 +where + SPI: Write, + CS: OutputPin, + BUSY: InputPin, + DC: OutputPin, + RST: OutputPin, +{ + + fn set_data_entry_mode(&mut self, spi: &mut SPI, + counter_incr_mode: DataEntryModeIncr, + counter_direction: DataEntryModeDir + + ) -> Result<(), SPI::Error> { + let mode = counter_incr_mode as u8 | counter_direction as u8; + self.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[mode]) + } + + fn use_full_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> { + // choose full frame/ram + self.set_ram_area(spi, 0, 0, WIDTH - 1, HEIGHT - 1)?; + + // start from the beginning + self.set_ram_counter(spi, 0, 0) + } + + fn set_ram_area( + &mut self, + spi: &mut SPI, + start_x: u32, + start_y: u32, + end_x: u32, + end_y: u32, + ) -> Result<(), SPI::Error> { + // assert!(start_x < end_x); + // assert!(start_y < end_y); + + // x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram + // aren't relevant + self.cmd_with_data( + spi, + Command::SET_RAM_X_ADDRESS_START_END_POSITION, + &[(start_x >> 3) as u8, (end_x >> 3) as u8], + )?; + + // 2 Databytes: A[7:0] & 0..A[8] for each - start and end + self.cmd_with_data( + spi, + Command::SET_RAM_Y_ADDRESS_START_END_POSITION, + &[ + start_y as u8, + (start_y >> 8) as u8, + end_y as u8, + (end_y >> 8) as u8, + ], + ) + } + + fn set_ram_counter(&mut self, spi: &mut SPI, x: u32, y: u32) -> Result<(), SPI::Error> { + self.wait_until_idle(); + // x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram + // aren't relevant + self.cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?; + + // 2 Databytes: A[7:0] & 0..A[8] + self.cmd_with_data( + spi, + Command::SET_RAM_Y_ADDRESS_COUNTER, + &[y as u8, (y >> 8) as u8], + )?; + Ok(()) + } + + /// Set your own LUT, this function is also used internally for set_lut + fn set_lut_helper(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> { + self.wait_until_idle(); + assert!(buffer.len() == 70); + self.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)?; + Ok(()) + } + + fn command(&mut self, spi: &mut SPI, command: Command) -> Result<(), SPI::Error> { + self.interface.cmd(spi, command) + } + + fn send_data(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> { + self.interface.data(spi, data) + } + + fn cmd_with_data( + &mut self, + spi: &mut SPI, + command: Command, + data: &[u8], + ) -> Result<(), SPI::Error> { + self.interface.cmd_with_data(spi, command, data) + } + + fn wait_until_idle(&mut self) { + self.interface.wait_until_idle(IS_BUSY_LOW) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn epd_size() { + assert_eq!(WIDTH, 128); + assert_eq!(HEIGHT, 250); + assert_eq!(DEFAULT_BACKGROUND_COLOR, Color::White); + } +} diff --git a/src/lib.rs b/src/lib.rs index 0d653640..724c56bb 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -75,6 +75,7 @@ mod interface; pub mod epd1in54; pub mod epd1in54b; pub mod epd2in9; +pub mod epd2in13_v2; pub mod epd2in9bc; pub mod epd4in2; pub mod epd7in5;