From d0b7f162fe7417d0b9cd592e30f2207b2c3c9057 Mon Sep 17 00:00:00 2001 From: Johan Kristell Date: Fri, 25 Oct 2019 08:16:10 +0200 Subject: [PATCH] Add support for the epd1in54b display --- Cargo.toml | 3 +- src/epd1in54b/command.rs | 41 +++++ src/epd1in54b/constants.rs | 31 ++++ src/epd1in54b/graphics.rs | 46 +++++ src/epd1in54b/mod.rs | 349 +++++++++++++++++++++++++++++++++++++ src/lib.rs | 5 +- src/traits.rs | 17 ++ 7 files changed, 490 insertions(+), 2 deletions(-) create mode 100644 src/epd1in54b/command.rs create mode 100644 src/epd1in54b/constants.rs create mode 100644 src/epd1in54b/graphics.rs create mode 100644 src/epd1in54b/mod.rs diff --git a/Cargo.toml b/Cargo.toml index ac5655d..7341be2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -19,10 +19,11 @@ travis-ci = { repository = "caemor/epd-waveshare" } [features] -default = ["epd1in54", "epd2in9", "epd4in2", "epd7in5", "graphics"] +default = ["epd1in54", "epd1in54b", "epd2in9", "epd4in2", "epd7in5", "graphics"] graphics = ["embedded-graphics"] epd1in54 = [] +epd1in54b = [] epd2in9 = [] epd4in2 = [] epd7in5 = [] diff --git a/src/epd1in54b/command.rs b/src/epd1in54b/command.rs new file mode 100644 index 0000000..6c150e0 --- /dev/null +++ b/src/epd1in54b/command.rs @@ -0,0 +1,41 @@ +//! SPI Commands for the Waveshare 1.54" red E-Ink Display +use crate::traits; + +#[allow(dead_code)] +#[allow(non_camel_case_types)] +#[derive(Copy, Clone)] +pub(crate) enum Command { + PANEL_SETTING = 0x00, + + POWER_SETTING = 0x01, + POWER_OFF = 0x02, + POWER_ON = 0x04, + BOOSTER_SOFT_START = 0x06, + DATA_START_TRANSMISSION_1 = 0x10, + DISPLAY_REFRESH = 0x12, + DATA_START_TRANSMISSION_2 = 0x13, + + LUT_FOR_VCOM = 0x20, + LUT_WHITE_TO_WHITE = 0x21, + LUT_BLACK_TO_WHITE = 0x22, + LUT_G0 = 0x23, + LUT_G1 = 0x24, + LUT_RED_VCOM = 0x25, + LUT_RED0 = 0x26, + LUT_RED1 = 0x27, + + PLL_CONTROL = 0x30, + TEMPERATURE_SENSOR_COMMAND = 0x40, + TEMPERATURE_SENSOR_SELECTION = 0x41, + VCOM_AND_DATA_INTERVAL_SETTING = 0x50, + RESOLUTION_SETTING = 0x61, + VCM_DC_SETTING = 0x82, + POWER_SAVING = 0xE3, +} + +impl traits::Command for Command { + /// Returns the address of the command + fn address(self) -> u8 { + self as u8 + } +} diff --git a/src/epd1in54b/constants.rs b/src/epd1in54b/constants.rs new file mode 100644 index 0000000..a08c0fc --- /dev/null +++ b/src/epd1in54b/constants.rs @@ -0,0 +1,31 @@ +pub(crate) const LUT_VCOM0: &[u8] = &[ + 0x0E, 0x14, 0x01, 0x0A, 0x06, 0x04, 0x0A, 0x0A, 0x0F, 0x03, 0x03, 0x0C, 0x06, 0x0A, 0x00, +]; + +pub(crate) const LUT_WHITE_TO_WHITE: &[u8] = &[ + 0x0E, 0x14, 0x01, 0x0A, 0x46, 0x04, 0x8A, 0x4A, 0x0F, 0x83, 0x43, 0x0C, 0x86, 0x0A, 0x04, +]; + +pub(crate) const LUT_BLACK_TO_WHITE: &[u8] = &[ + 0x0E, 0x14, 0x01, 0x8A, 0x06, 0x04, 0x8A, 0x4A, 0x0F, 0x83, 0x43, 0x0C, 0x06, 0x4A, 0x04, +]; + +pub(crate) const LUT_G1: &[u8] = &[ + 0x8E, 0x94, 0x01, 0x8A, 0x06, 0x04, 0x8A, 0x4A, 0x0F, 0x83, 0x43, 0x0C, 0x06, 0x0A, 0x04, +]; + +pub(crate) const LUT_G2: &[u8] = &[ + 0x8E, 0x94, 0x01, 0x8A, 0x06, 0x04, 0x8A, 0x4A, 0x0F, 0x83, 0x43, 0x0C, 0x06, 0x0A, 0x04, +]; + +pub(crate) const LUT_RED_VCOM: &[u8] = &[ + 0x03, 0x1D, 0x01, 0x01, 0x08, 0x23, 0x37, 0x37, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +]; + +pub(crate) const LUT_RED0: &[u8] = &[ + 0x83, 0x5D, 0x01, 0x81, 0x48, 0x23, 0x77, 0x77, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +]; + +pub(crate) const LUT_RED1: &[u8] = &[ + 0x03, 0x1D, 0x01, 0x01, 0x08, 0x23, 0x37, 0x37, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +]; diff --git a/src/epd1in54b/graphics.rs b/src/epd1in54b/graphics.rs new file mode 100644 index 0000000..536ba6a --- /dev/null +++ b/src/epd1in54b/graphics.rs @@ -0,0 +1,46 @@ +use crate::epd1in54b::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH}; +use crate::graphics::{Display, DisplayRotation}; +use crate::prelude::*; +use embedded_graphics::prelude::*; + +pub struct Display1in54b { + buffer: [u8; WIDTH as usize * HEIGHT as usize / 8], + rotation: DisplayRotation, +} + +impl Default for Display1in54b { + fn default() -> Self { + Display1in54b { + buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); + WIDTH as usize * HEIGHT as usize / 8], + rotation: DisplayRotation::default(), + } + } +} + +impl Drawing for Display1in54b { + fn draw(&mut self, item_pixels: T) + where + T: IntoIterator>, + { + self.draw_helper(WIDTH, HEIGHT, item_pixels); + } +} + +impl Display for Display1in54b { + 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 + } +} diff --git a/src/epd1in54b/mod.rs b/src/epd1in54b/mod.rs new file mode 100644 index 0000000..0e82ccb --- /dev/null +++ b/src/epd1in54b/mod.rs @@ -0,0 +1,349 @@ +use embedded_hal::{ + blocking::{delay::*, spi::Write}, + digital::*, +}; + +use crate::interface::DisplayInterface; +use crate::traits::{InternalWiAdditions, RefreshLUT, WaveshareDisplay, WaveshareTwoColorDisplay}; + +//The Lookup Tables for the Display +mod constants; +use crate::epd1in54b::constants::*; + +pub const WIDTH: u32 = 200; +pub const HEIGHT: u32 = 200; +pub const DEFAULT_BACKGROUND_COLOR: Color = Color::White; +const IS_BUSY_LOW: bool = true; + +use crate::color::Color; + +pub(crate) mod command; +use self::command::Command; + +#[cfg(feature = "graphics")] +mod graphics; +#[cfg(feature = "graphics")] +pub use self::graphics::Display1in54b; + +/// EPD1in54b driver +pub struct EPD1in54b { + interface: DisplayInterface, + color: Color, +} + +impl InternalWiAdditions + for EPD1in54b +where + SPI: Write, + CS: OutputPin, + BUSY: InputPin, + DC: OutputPin, + RST: OutputPin, +{ + fn init>( + &mut self, + spi: &mut SPI, + delay: &mut DELAY, + ) -> Result<(), SPI::Error> { + self.interface.reset(delay); + + // set the power settings + self.interface + .cmd_with_data(spi, Command::POWER_SETTING, &[0x07, 0x00, 0x08, 0x00])?; + + // start the booster + self.interface + .cmd_with_data(spi, Command::BOOSTER_SOFT_START, &[0x07, 0x07, 0x07])?; + + // power on + self.command(spi, Command::POWER_ON)?; + delay.delay_ms(5); + self.wait_until_idle(); + + // set the panel settings + self.cmd_with_data(spi, Command::PANEL_SETTING, &[0xCF])?; + + self.cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x37])?; + + // PLL + self.cmd_with_data(spi, Command::PLL_CONTROL, &[0x39])?; + + // set resolution + self.send_resolution(spi)?; + + self.cmd_with_data(spi, Command::VCM_DC_SETTING, &[0x0E])?; + + self.set_lut(spi, None)?; + + self.wait_until_idle(); + + Ok(()) + } +} + +impl WaveshareTwoColorDisplay + for EPD1in54b +where + SPI: Write, + CS: OutputPin, + BUSY: InputPin, + DC: OutputPin, + RST: OutputPin, +{ + fn update_both_planes( + &mut self, + spi: &mut SPI, + black: &[u8], + red: &[u8], + ) -> Result<(), SPI::Error> { + self.send_resolution(spi)?; + + self.interface + .cmd(spi, Command::DATA_START_TRANSMISSION_1)?; + + for b in black { + let expanded = expand_bits(*b); + self.interface.data(spi, &expanded)?; + } + + self.interface + .cmd(spi, Command::DATA_START_TRANSMISSION_2)?; + self.interface.data(spi, red)?; + + self.wait_until_idle(); + Ok(()) + } +} + +impl WaveshareDisplay + for EPD1in54b +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 = EPD1in54b { interface, color }; + + epd.init(spi, delay)?; + + Ok(epd) + } + + fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> { + self.interface + .cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x17])?; //border floating + + self.interface + .cmd_with_data(spi, Command::VCM_DC_SETTING, &[0x00])?; // VCOM to 0V + + self.interface + .cmd_with_data(spi, Command::POWER_SETTING, &[0x02, 0x00, 0x00, 0x00])?; //VG&VS to 0V fast + + self.wait_until_idle(); + + //NOTE: The example code has a 1s delay here + + self.command(spi, Command::POWER_OFF)?; + + Ok(()) + } + + fn wake_up>( + &mut self, + spi: &mut SPI, + delay: &mut DELAY, + ) -> Result<(), SPI::Error> { + self.init(spi, delay) + } + + fn set_background_color(&mut self, color: Color) { + self.color = color; + } + + fn background_color(&self) -> &Color { + &self.color + } + + fn width(&self) -> u32 { + WIDTH + } + + fn height(&self) -> u32 { + HEIGHT + } + + fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> { + self.send_resolution(spi)?; + + self.interface + .cmd(spi, Command::DATA_START_TRANSMISSION_1)?; + + for b in buffer { + // Two bits per pixel + let expanded = expand_bits(*b); + self.interface.data(spi, &expanded)?; + } + + //NOTE: Example code has a delay here + + // Clear the read layer + let color = self.color.get_byte_value(); + let nbits = WIDTH * (HEIGHT / 8); + + self.interface + .cmd(spi, Command::DATA_START_TRANSMISSION_2)?; + self.interface.data_x_times(spi, color, nbits)?; + + //NOTE: Example code has a delay here + + self.wait_until_idle(); + Ok(()) + } + + #[allow(unused)] + fn update_partial_frame( + &mut self, + spi: &mut SPI, + buffer: &[u8], + x: u32, + y: u32, + width: u32, + height: u32, + ) -> Result<(), SPI::Error> { + Ok(()) + } + + fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> { + self.command(spi, Command::DISPLAY_REFRESH)?; + + self.wait_until_idle(); + Ok(()) + } + + fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> { + self.send_resolution(spi)?; + + let color = DEFAULT_BACKGROUND_COLOR.get_byte_value(); + + // Clear the black + self.interface + .cmd(spi, Command::DATA_START_TRANSMISSION_1)?; + + // Uses 2 bits per pixel + self.interface + .data_x_times(spi, color, 2 * (WIDTH * HEIGHT / 8))?; + + // Clear the red + self.interface + .cmd(spi, Command::DATA_START_TRANSMISSION_2)?; + self.interface + .data_x_times(spi, color, WIDTH * HEIGHT / 8)?; + + self.wait_until_idle(); + Ok(()) + } + + fn set_lut( + &mut self, + spi: &mut SPI, + _refresh_rate: Option, + ) -> Result<(), SPI::Error> { + self.interface + .cmd_with_data(spi, Command::LUT_FOR_VCOM, LUT_VCOM0)?; + self.interface + .cmd_with_data(spi, Command::LUT_WHITE_TO_WHITE, LUT_WHITE_TO_WHITE)?; + self.interface + .cmd_with_data(spi, Command::LUT_BLACK_TO_WHITE, LUT_BLACK_TO_WHITE)?; + self.interface.cmd_with_data(spi, Command::LUT_G0, LUT_G1)?; + self.interface.cmd_with_data(spi, Command::LUT_G1, LUT_G2)?; + self.interface + .cmd_with_data(spi, Command::LUT_RED_VCOM, LUT_RED_VCOM)?; + self.interface + .cmd_with_data(spi, Command::LUT_RED0, LUT_RED0)?; + self.interface + .cmd_with_data(spi, Command::LUT_RED1, LUT_RED1)?; + + Ok(()) + } + + fn is_busy(&self) -> bool { + self.interface.is_busy(IS_BUSY_LOW) + } +} + +impl EPD1in54b +where + SPI: Write, + CS: OutputPin, + BUSY: InputPin, + DC: OutputPin, + RST: OutputPin, +{ + 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) + } + + fn send_resolution(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> { + let w = self.width(); + let h = self.height(); + + self.command(spi, Command::RESOLUTION_SETTING)?; + + self.send_data(spi, &[w as u8])?; + self.send_data(spi, &[(h >> 8) as u8])?; + self.send_data(spi, &[h as u8]) + } +} + +fn expand_bits(bits: u8) -> [u8; 2] { + let mut x = bits as u16; + + x = (x | (x << 4)) & 0x0F0F; + x = (x | (x << 2)) & 0x3333; + x = (x | (x << 1)) & 0x5555; + x = x | (x << 1); + + [(x >> 8) as u8, (x & 0xFF) as u8] +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn epd_size() { + assert_eq!(WIDTH, 200); + assert_eq!(HEIGHT, 200); + assert_eq!(DEFAULT_BACKGROUND_COLOR, Color::White); + } +} diff --git a/src/lib.rs b/src/lib.rs index 86b0e7f..b52d6c2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -73,6 +73,9 @@ pub mod epd4in2; #[cfg(feature = "epd1in54")] pub mod epd1in54; +#[cfg(feature = "epd1in54b")] +pub mod epd1in54b; + #[cfg(feature = "epd2in9")] pub mod epd2in9; @@ -81,7 +84,7 @@ pub(crate) mod type_a; pub mod prelude { pub use crate::color::Color; - pub use crate::traits::{RefreshLUT, WaveshareDisplay}; + pub use crate::traits::{RefreshLUT, WaveshareDisplay, WaveshareTwoColorDisplay}; pub use crate::SPI_MODE; #[cfg(feature = "graphics")] diff --git a/src/traits.rs b/src/traits.rs index b9ce249..737b05f 100644 --- a/src/traits.rs +++ b/src/traits.rs @@ -52,6 +52,23 @@ where ) -> Result<(), SPI::Error>; } +pub trait WaveshareTwoColorDisplay: + WaveshareDisplay +where + SPI: Write, + CS: OutputPin, + BUSY: InputPin, + DC: OutputPin, + RST: OutputPin, +{ + fn update_both_planes( + &mut self, + spi: &mut SPI, + black: &[u8], + color1: &[u8], + ) -> Result<(), SPI::Error>; +} + /// All the functions to interact with the EPDs /// /// This trait includes all public functions to use the EPDS