Anshorei
/
epd-waveshare
mirror of https://github.com/Anshorei/epd-waveshare
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Stablised traits and interfaces, converted epd4in2 to it, and started real work on epd2in9

embedded-hal-1.0
Christoph Groß 8 years ago
parent
80e5c0ffb1
commit
5e03c3c39a
9 changed files with 323 additions and 374 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      examples/embedded_linux/src/main.rs
  2. 35
      src/epd2in9/command.rs
  3. 38
      src/epd2in9/mod.rs
  4. 13
      src/epd4in2/command.rs
  5. 9
      src/epd4in2/constants.rs
  6. 525
      src/epd4in2/mod.rs
  7. 25
      src/interface/connection_interface.rs
  8. 33
      src/interface/mod.rs
  9. 3
      src/lib.rs

16
examples/embedded_linux/src/main.rs
Unescape View File

@ -5,7 +5,7 @@ extern crate linux_embedded_hal as lin_hal;
extern crate eink_waveshare_rs; extern crate eink_waveshare_rs;
use eink_waveshare_rs::{epd4in2::EPD4in2, drawing::{Graphics, color::Color}}; use eink_waveshare_rs::{epd4in2::EPD4in2, drawing::{Graphics, color::Color}, interface::WaveshareInterface};
use lin_hal::spidev::{self, SpidevOptions}; use lin_hal::spidev::{self, SpidevOptions};
use lin_hal::{Pin, Spidev}; use lin_hal::{Pin, Spidev};
@ -120,27 +120,27 @@ fn main() {
graphics.draw_vertical_line(200, 50, 200, &Color::Black); graphics.draw_vertical_line(200, 50, 200, &Color::Black);
epd4in2.display_and_transfer_frame(graphics.get_buffer(), None).expect("display and transfer error"); epd4in2.update_and_display_frame(graphics.get_buffer()).expect("display and transfer error");
epd4in2.delay_ms(3000); epd4in2.delay_ms(3000);
epd4in2.clear_frame(None).expect("clear frame error"); epd4in2.clear_frame().expect("clear frame error");
//Test fast updating a bit more //Test fast updating a bit more
let mut small_buffer = [0x00; 128]; let mut small_buffer = [0x00; 128];
let mut circle_graphics = Graphics::new(32,32, &mut small_buffer); let mut circle_graphics = Graphics::new(32,32, &mut small_buffer);
circle_graphics.draw_circle(16,16, 10, &Color::Black); circle_graphics.draw_circle(16,16, 10, &Color::Black);
epd4in2.set_partial_window(circle_graphics.get_buffer(), 16,16, 32, 32, false).expect("Partial Window Error"); epd4in2.update_partial_frame(circle_graphics.get_buffer(), 16,16, 32, 32).expect("Partial Window Error");
epd4in2.display_frame().expect("Display Frame Error"); epd4in2.display_frame().expect("Display Frame Error");
epd4in2.set_partial_window(circle_graphics.get_buffer(), 128,64, 32, 32, false).expect("Partial Window Error"); epd4in2.update_partial_frame(circle_graphics.get_buffer(), 128,64, 32, 32).expect("Partial Window Error");
epd4in2.display_frame().expect("Display Frame Error"); epd4in2.display_frame().expect("Display Frame Error");
epd4in2.set_partial_window(circle_graphics.get_buffer(), 320,24, 32, 32, false).expect("Partial Window Error"); epd4in2.update_partial_frame(circle_graphics.get_buffer(), 320,24, 32, 32).expect("Partial Window Error");
epd4in2.display_frame().expect("Display Frame Error"); epd4in2.display_frame().expect("Display Frame Error");
epd4in2.set_partial_window(circle_graphics.get_buffer(), 160,240, 32, 32, false).expect("Partial Window Error"); epd4in2.update_partial_frame(circle_graphics.get_buffer(), 160,240, 32, 32).expect("Partial Window Error");
epd4in2.display_frame().expect("Display Frame Error"); epd4in2.display_frame().expect("Display Frame Error");
epd4in2.delay_ms(3000); epd4in2.delay_ms(3000);
@ -152,7 +152,7 @@ fn main() {
graphics.draw_string_8x8(16, 16, "hello", &Color::Black); graphics.draw_string_8x8(16, 16, "hello", &Color::Black);
graphics.draw_char_8x8(250, 250, '#', &Color::Black); graphics.draw_char_8x8(250, 250, '#', &Color::Black);
graphics.draw_char_8x8(300, 16, '7', &Color::Black); graphics.draw_char_8x8(300, 16, '7', &Color::Black);
epd4in2.display_and_transfer_frame(graphics.get_buffer(), None).expect("display and transfer error"); epd4in2.update_and_display_frame(graphics.get_buffer()).expect("display and transfer error");
epd4in2.delay_ms(3000); epd4in2.delay_ms(3000);

35
src/epd2in9/command.rs
Unescape View File

@ -10,7 +10,7 @@ use interface;
/// For more infos about the addresses and what they are doing look into the pdfs /// For more infos about the addresses and what they are doing look into the pdfs
/// ///
/// The description of the single commands is mostly taken from IL0398.pdf /// The description of the single commands is mostly taken from IL0398.pdf
#[allow(dead_code)] //#[allow(dead_code)]
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
pub enum Command { pub enum Command {
@ -38,6 +38,39 @@ pub enum Command {
/// A[0] = 1: Enter Deep Sleep Mode /// A[0] = 1: Enter Deep Sleep Mode
DEEP_SLEEP_MODE = 0x10, DEEP_SLEEP_MODE = 0x10,
// /// Data Entry mode setting // /// Data Entry mode setting
DATA_ENTRY_MODE_SETTING = 0x11,
SW_RESET = 0x12,
TEMPERATURE_SENSOR_CONTROL = 0x1A,
MASTER_ACTIVATION = 0x20,
DISPLAY_UPDATE_CONTROL_1 = 0x21,
DISPLAY_UPDATE_CONTROL_2 = 0x22,
WRITE_RAM = 0x24,
WRITE_VCOM_REGISTER = 0x2C,
WRITE_LUT_REGISTER = 0x32,
SET_DUMMY_LINE_PERIOD = 0x3A,
SET_GATE_TIME = 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,
TERMINATE_COMMANDS_AND_FRAME_WRITE = 0xFF
} }

38
src/epd2in9/mod.rs
Unescape View File

@ -62,21 +62,23 @@ use self::constants::*;
use drawing::color::Color; use drawing::color::Color;
pub mod command; pub mod command;
pub use command::Command as Command; pub use self::command::Command;
use interface::*; use interface::*;
use interface::data_interface::DataInterface; use interface::connection_interface::ConnectionInterface;
/// EPD2in9 driver /// EPD2in9 driver
/// ///
pub struct EPD2in9<SPI, CS, BUSY, DC, RST, D> { pub struct EPD2in9<SPI, CS, BUSY, DC, RST, D> {
/// SPI /// SPI
interface: DataInterface<SPI, CS, BUSY, DC, RST, D>, interface: ConnectionInterface<SPI, CS, BUSY, DC, RST, D>,
/// Width /// Width
width: u32, width: u32,
/// Height /// Height
height: u32, height: u32,
/// Color
color: Color,
} }
impl<SPI, CS, BUSY, DC, RST, D, E> EPD2in9<SPI, CS, BUSY, DC, RST, D> impl<SPI, CS, BUSY, DC, RST, D, E> EPD2in9<SPI, CS, BUSY, DC, RST, D>
@ -122,9 +124,11 @@ where
let width = WIDTH as u32; let width = WIDTH as u32;
let height = HEIGHT as u32; let height = HEIGHT as u32;
let mut interface = DataInterface::new(spi, cs, busy, dc, rst, delay); let interface = ConnectionInterface::new(spi, cs, busy, dc, rst, delay);
let mut epd = EPD2in9 {interface, width, height}; let color = Color::White;
let mut epd = EPD2in9 {interface, width, height, color};
epd.init()?; epd.init()?;
@ -135,11 +139,26 @@ where
fn init(&mut self) -> Result<(), E> { fn init(&mut self) -> Result<(), E> {
self.reset();
unimplemented!() unimplemented!()
} }
fn sleep(&mut self) -> Result<(), E> { fn sleep(&mut self) -> Result<(), E> {
unimplemented!()
self.interface.send_command(Command::DEEP_SLEEP_MODE)?;
// 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
//TODO: is 0x00 needed here?
self.interface.send_data(0x00)?;
self.interface.wait_until_idle(false);
Ok(())
} }
fn reset(&mut self) { fn reset(&mut self) {
self.interface.reset() self.interface.reset()
} }
@ -165,6 +184,9 @@ where
// TODO: add this abstraction function // TODO: add this abstraction function
// fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>; // fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>;
fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>{
unimplemented!()
}
fn clear_frame(&mut self) -> Result<(), E>{ fn clear_frame(&mut self) -> Result<(), E>{
@ -173,7 +195,7 @@ where
/// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame()) /// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame())
fn set_background_color(&mut self, color: Color){ fn set_background_color(&mut self, color: Color){
unimplemented!() self.color = color;
} }
} }

13
src/epd4in2/command.rs
Unescape View File

@ -1,5 +1,5 @@
//! SPI Commands for the Waveshare 4.2" E-Ink Display //! SPI Commands for the Waveshare 4.2" E-Ink Display
use interface;
/// EPD4IN2 commands /// EPD4IN2 commands
/// ///
/// Should rarely (never?) be needed directly. /// Should rarely (never?) be needed directly.
@ -146,9 +146,9 @@ pub enum Command {
impl Command { impl interface::Command for Command {
/// Returns the address of the command /// Returns the address of the command
pub fn addr(self) -> u8 { fn address(self) -> u8 {
self as u8 self as u8
} }
} }
@ -157,13 +157,14 @@ impl Command {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use interface::Command as CommandTrait;
#[test] #[test]
fn command_addr() { fn command_addr() {
assert_eq!(Command::POWER_SAVING.addr(), 0xE3); assert_eq!(Command::POWER_SAVING.address(), 0xE3);
assert_eq!(Command::PANEL_SETTING.addr(), 0x00); assert_eq!(Command::PANEL_SETTING.address(), 0x00);
assert_eq!(Command::DISPLAY_REFRESH.addr(), 0x12); assert_eq!(Command::DISPLAY_REFRESH.address(), 0x12);
} }
} }

9
src/epd4in2/lut.rs → src/epd4in2/constants.rs
Unescape View File

@ -1,3 +1,6 @@
pub(crate) const WIDTH: usize = 400;
pub(crate) const HEIGHT: usize = 300;
pub(crate) const LUT_VCOM0: [u8; 44] = [ pub(crate) const LUT_VCOM0: [u8; 44] = [
0x00, 0x17, 0x00, 0x00, 0x00, 0x02, 0x00, 0x17, 0x00, 0x00, 0x00, 0x02,
0x00, 0x17, 0x17, 0x00, 0x00, 0x02, 0x00, 0x17, 0x17, 0x00, 0x00, 0x02,
@ -8,6 +11,7 @@ pub(crate) const LUT_VCOM0: [u8; 44] = [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]; ];
pub(crate) const LUT_VCOM0_QUICK: [u8; 44] = [ pub(crate) const LUT_VCOM0_QUICK: [u8; 44] = [
0x00, 0x0E, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -18,6 +22,7 @@ pub(crate) const LUT_VCOM0_QUICK: [u8; 44] = [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]; ];
pub(crate) const LUT_WW: [u8; 42] =[ pub(crate) const LUT_WW: [u8; 42] =[
0x40, 0x17, 0x00, 0x00, 0x00, 0x02, 0x40, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02, 0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
@ -28,6 +33,7 @@ pub(crate) const LUT_WW: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]; ];
pub(crate) const LUT_WW_QUICK: [u8; 42] =[ pub(crate) const LUT_WW_QUICK: [u8; 42] =[
0xA0, 0x0E, 0x00, 0x00, 0x00, 0x01, 0xA0, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -49,6 +55,7 @@ pub(crate) const LUT_BW: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]; ];
pub(crate) const LUT_BW_QUICK: [u8; 42] =[ pub(crate) const LUT_BW_QUICK: [u8; 42] =[
0xA0, 0x0E, 0x00, 0x00, 0x00, 0x01, 0xA0, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -70,6 +77,7 @@ pub(crate) const LUT_BB: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]; ];
pub(crate) const LUT_BB_QUICK: [u8; 42] =[ pub(crate) const LUT_BB_QUICK: [u8; 42] =[
0x50, 0x0E, 0x00, 0x00, 0x00, 0x01, 0x50, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -91,6 +99,7 @@ pub(crate) const LUT_WB: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]; ];
pub(crate) const LUT_WB_QUICK: [u8; 42] =[ pub(crate) const LUT_WB_QUICK: [u8; 42] =[
0x50, 0x0E, 0x00, 0x00, 0x00, 0x01, 0x50, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

525
src/epd4in2/mod.rs
Unescape View File

@ -1,27 +1,27 @@
//! A simple Driver for the Waveshare 4.2" E-Ink Display via SPI //! A simple Driver for the Waveshare 4.2" E-Ink Display via SPI
//! //!
//! The other Waveshare E-Ink Displays should be added later on //! The other Waveshare E-Ink Displays should be added later on
//! //!
//! Build with the help of documentation/code from [Waveshare](https://www.waveshare.com/wiki/4.2inch_e-Paper_Module), //! Build with the help of documentation/code from [Waveshare](https://www.waveshare.com/wiki/4.2inch_e-Paper_Module),
//! [Ben Krasnows partial Refresh tips](https://benkrasnow.blogspot.de/2017/10/fast-partial-refresh-on-42-e-paper.html) and //! [Ben Krasnows partial Refresh tips](https://benkrasnow.blogspot.de/2017/10/fast-partial-refresh-on-42-e-paper.html) and
//! the driver documents in the `pdfs`-folder as orientation. //! the driver documents in the `pdfs`-folder as orientation.
//! //!
//! This driver was built using [`embedded-hal`] traits. //! This driver was built using [`embedded-hal`] traits.
//! //!
//! [`embedded-hal`]: https://docs.rs/embedded-hal/~0.1 //! [`embedded-hal`]: https://docs.rs/embedded-hal/~0.1
//! //!
//! # Requirements //! # Requirements
//! //!
//! ### SPI //! ### SPI
//! //!
//! - MISO is not connected/available //! - MISO is not connected/available
//! - SPI_MODE_0 is used (CPHL = 0, CPOL = 0) //! - SPI_MODE_0 is used (CPHL = 0, CPOL = 0)
//! - 8 bits per word, MSB first //! - 8 bits per word, MSB first
//! - Max. Speed tested was 8Mhz but more should be possible //! - Max. Speed tested was 8Mhz but more should be possible
//! //!
//! ### Other.... //! ### Other....
//! //!
//! - Buffersize: Wherever a buffer is used it always needs to be of the size: `width / 8 * length`, //! - Buffersize: Wherever a buffer is used it always needs to be of the size: `width / 8 * length`,
//! where width and length being either the full e-ink size or the partial update window size //! where width and length being either the full e-ink size or the partial update window size
//! //!
//! # Examples //! # Examples
@ -30,82 +30,64 @@
//! let mut epd4in2 = EPD4in2::new(spi, cs, busy, dc, rst, delay).unwrap(); //! let mut epd4in2 = EPD4in2::new(spi, cs, busy, dc, rst, delay).unwrap();
//! //!
//! let mut buffer = [0u8, epd4in2.get_width() / 8 * epd4in2.get_height()]; //! let mut buffer = [0u8, epd4in2.get_width() / 8 * epd4in2.get_height()];
//! //!
//! // draw something into the buffer //! // draw something into the buffer
//! //!
//! epd4in2.display_and_transfer_buffer(buffer, None); //! epd4in2.display_and_transfer_buffer(buffer, None);
//! //!
//! // wait and look at the image //! // wait and look at the image
//! //!
//! epd4in2.clear_frame(None); //! epd4in2.clear_frame(None);
//! //!
//! epd4in2.sleep(); //! epd4in2.sleep();
//! ``` //! ```
//! //!
//! //!
//! //!
//! BE CAREFUL! The Partial Drawing can "destroy" your display. //! BE CAREFUL! The Partial Drawing can "destroy" your display.
//! It needs more testing first. //! It needs more testing first.
use hal::{ use hal::{
blocking::{ blocking::{delay::*, spi::Write},
spi::Write, digital::*,
delay::*
},
spi::{Mode, Phase, Polarity}, spi::{Mode, Phase, Polarity},
digital::*
}; };
use interface::{connection_interface::ConnectionInterface, WaveshareInterface};
//The Lookup Tables for the Display //The Lookup Tables for the Display
mod lut; mod constants;
use self::lut::*; use self::constants::*;
use drawing::color::Color; use drawing::color::Color;
pub mod command; pub mod command;
pub use command::Command as Command; pub use self::command::Command;
//TODO: test spi mode //TODO: test spi mode
/// SPI mode - /// SPI mode -
/// For more infos see [Requirements: SPI](index.html#spi) /// For more infos see [Requirements: SPI](index.html#spi)
pub const SPI_MODE: Mode = Mode { pub const SPI_MODE: Mode = Mode {
phase: Phase::CaptureOnFirstTransition, phase: Phase::CaptureOnFirstTransition,
polarity: Polarity::IdleLow, polarity: Polarity::IdleLow,
}; };
/// EPD4in2 driver /// EPD4in2 driver
/// ///
pub struct EPD4in2<SPI, CS, BUSY, DC, RST, D> { pub struct EPD4in2<SPI, CS, BUSY, DC, RST, D> {
/// SPI /// Connection Interface
spi: SPI, interface: ConnectionInterface<SPI, CS, BUSY, DC, RST, D>,
/// CS for SPI
cs: CS,
/// Low for busy, Wait until display is ready!
busy: BUSY,
/// Data/Command Control Pin (High for data, Low for command)
dc: DC,
/// Pin for Reseting
rst: RST,
/// The concrete Delay implementation
delay: D,
/// Width /// Width
width: u16, width: u32,
/// Height /// Height
height: u16, height: u32,
/// Background Color
color: Color,
} }
impl<SPI, CS, BUSY, DC, RST, D, E> WaveshareInterface<SPI, CS, BUSY, DC, RST, D, E>
impl<SPI, CS, BUSY, DC, RST, D, E> EPD4in2<SPI, CS, BUSY, DC, RST, D> for EPD4in2<SPI, CS, BUSY, DC, RST, D>
where where
SPI: Write<u8, Error = E>, SPI: Write<u8, Error = E>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
@ -113,54 +95,48 @@ where
RST: OutputPin, RST: OutputPin,
D: DelayUs<u16> + DelayMs<u16>, D: DelayUs<u16> + DelayMs<u16>,
{ {
/// Get the width of the display fn get_width(&self) -> u32 {
pub fn get_width(&self) -> u16 {
self.width self.width
} }
/// Get the height of the display fn get_height(&self) -> u32 {
pub fn get_height(&self) -> u16 {
self.height self.height
} }
/// Creates a new driver from a SPI peripheral, CS Pin, Busy InputPin, DC /// Creates a new driver from a SPI peripheral, CS Pin, Busy InputPin, DC
/// ///
/// This already initialises the device. That means [EPD4in2::init()](EPD4in2::init()) isn't needed directly afterwards /// This already initialises the device. That means [EPD4in2::init()](EPD4in2::init()) isn't needed directly afterwards
/// ///
/// # Example /// # Example
/// ///
/// ```ignore /// ```ignore
/// //buffer = some image data; /// //buffer = some image data;
/// ///
/// let mut epd4in2 = EPD4in2::new(spi, cs, busy, dc, rst, delay); /// let mut epd4in2 = EPD4in2::new(spi, cs, busy, dc, rst, delay);
/// ///
/// epd4in2.display_and_transfer_frame(buffer, None); /// epd4in2.display_and_transfer_frame(buffer, None);
/// ///
/// epd4in2.sleep(); /// epd4in2.sleep();
/// ``` /// ```
pub fn new(spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: D) -> Result<Self, E> { fn new(spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: D) -> Result<Self, E> {
//TODO: width und height anpassbar machen? let width = WIDTH as u32;
let width = 400; let height = HEIGHT as u32;
let height = 300;
let interface = ConnectionInterface::new(spi, cs, busy, dc, rst, delay);
let mut epd4in2 = EPD4in2 {spi, cs, busy, dc, rst, delay, width, height }; let color = Color::White;
let mut epd = EPD4in2 {
epd4in2.init()?; interface,
width,
Ok(epd4in2) height,
color,
};
epd.init()?;
Ok(epd)
} }
fn init(&mut self) -> Result<(), E> {
/// This initialises the EPD and powers it up
///
/// This function is already called from [EPD4in2::new()](EPD4in2::new())
///
/// This function calls [EPD4in2::reset()](EPD4in2::reset()),
/// so you don't need to call reset your self when trying to wake your device up
/// after setting it to sleep.
pub fn init(&mut self) -> Result<(), E> {
// reset the device // reset the device
self.reset(); self.reset();
@ -175,7 +151,7 @@ where
// start the booster // start the booster
self.send_command(Command::BOOSTER_SOFT_START)?; self.send_command(Command::BOOSTER_SOFT_START)?;
for _ in 0..3 { for _ in 0..3 {
self.send_data(0x17)?; //07 0f 17 1f 27 2F 37 2f self.send_data(0x17)?; //07 0f 17 1f 27 2F 37 2f
} }
// power on // power on
@ -198,68 +174,46 @@ where
// Set Frequency, 200 Hz didn't work on my board // Set Frequency, 200 Hz didn't work on my board
// 150Hz and 171Hz wasn't tested yet // 150Hz and 171Hz wasn't tested yet
// TODO: Test these other frequencies // TODO: Test these other frequencies
// 3A 100HZ 29 150Hz 39 200HZ 31 171HZ DEFAULT: 3c 50Hz // 3A 100HZ 29 150Hz 39 200HZ 31 171HZ DEFAULT: 3c 50Hz
self.send_command(Command::PLL_CONTROL)?; self.send_command(Command::PLL_CONTROL)?;
self.send_data(0x3A)?; self.send_data(0x3A)?;
self.set_lut()?;
Ok(()) Ok(())
} }
fn sleep(&mut self) -> Result<(), E> {
self.send_command(Command::VCOM_AND_DATA_INTERVAL_SETTING)?;
self.send_data(0x17)?; //border floating
self.send_command(Command::VCM_DC_SETTING)?; // VCOM to 0V
self.send_command(Command::PANEL_SETTING)?;
self.delay_ms(100);
self.send_command(Command::POWER_SETTING)?; //VG&VS to 0V fast
for _ in 0..4 {
self.send_data(0x00)?;
/// Transmit partial data to the SRAM of the EPD,
/// the final parameter dtm chooses between the 2
/// internal buffers
///
/// Normally it should be dtm2, so use false
///
/// BUFFER needs to be of size: w / 8 * l !
pub fn set_partial_window(&mut self, buffer: &[u8], x: u16, y: u16, w: u16, l: u16, is_dtm1: bool) -> Result<(), E> {
if buffer.len() as u16 != w / 8 * l {
//TODO: panic!! or sth like that
//return Err("Wrong buffersize");
} }
self.delay_ms(100);
self.send_command(Command::PARTIAL_IN)?; self.send_command(Command::POWER_OFF)?;
self.send_command(Command::PARTIAL_WINDOW)?; self.wait_until_idle();
self.send_data((x >> 8) as u8)?; self.send_command(Command::DEEP_SLEEP)?;
let tmp = x & 0xf8; self.send_data(0xA5)?;
self.send_data(tmp as u8)?; // x should be the multiple of 8, the last 3 bit will always be ignored
let tmp = tmp + w - 1;
self.send_data((tmp >> 8) as u8)?;
self.send_data((tmp | 0x07) as u8)?;
self.send_data((y >> 8) as u8)?;
self.send_data(y as u8)?;
self.send_data(((y + l - 1) >> 8) as u8)?;
self.send_data((y + l - 1) as u8)?;
self.send_data(0x01)?; // Gates scan both inside and outside of the partial window. (default)
if is_dtm1 {
self.send_command(Command::DATA_START_TRANSMISSION_1)?
} else {
self.send_command(Command::DATA_START_TRANSMISSION_2)?
}
self.send_multiple_data(buffer)?; Ok(())
}
self.send_command(Command::PARTIAL_OUT) fn reset(&mut self) {
self.interface.reset()
} }
fn delay_ms(&mut self, delay: u16) {
self.interface.delay_ms(delay)
}
// void DisplayFrame(const unsigned char* frame_buffer); fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E> {
/// Display the frame data from SRAM let color_value = self.color.get_byte_value();
/// Uses the SLOW!! full update/refresh
/// Default color: 0xff
///
pub fn display_and_transfer_frame(&mut self, buffer: &[u8], color: Option<u8>) -> Result<(), E>{
let color = color.unwrap_or(0xff);
self.send_resolution()?; self.send_resolution()?;
@ -272,10 +226,9 @@ where
//self.send_command_u8(0x97)?; //VBDF 17|D7 VBDW 97 VBDB 57 VBDF F7 VBDW 77 VBDB 37 VBDR B7 //self.send_command_u8(0x97)?; //VBDF 17|D7 VBDW 97 VBDB 57 VBDF F7 VBDW 77 VBDB 37 VBDR B7
self.send_data(0x97)?; self.send_data(0x97)?;
self.send_command(Command::DATA_START_TRANSMISSION_1)?; self.send_command(Command::DATA_START_TRANSMISSION_1)?;
for _ in 0..(buffer.len()) { for _ in 0..(buffer.len()) {
self.send_data(color)?; self.send_data(color_value)?;
} }
self.delay_ms(2); self.delay_ms(2);
@ -284,73 +237,79 @@ where
for &elem in buffer.iter() { for &elem in buffer.iter() {
self.send_data(elem)?; self.send_data(elem)?;
} }
self.delay_ms(2);
self.set_lut()?;
self.send_command(Command::DISPLAY_REFRESH)?;
//TODO: adapt time, is this long delay really needed?
self.delay_ms(10);
self.wait_until_idle();
Ok(()) Ok(())
} }
fn send_resolution(&mut self) -> Result<(), E> { fn update_partial_frame(
let w = self.get_width(); &mut self,
let h = self.get_height(); buffer: &[u8],
x: u16,
y: u16,
width: u16,
height: u16,
) -> Result<(), E> {
if buffer.len() as u16 != width / 8 * height {
//TODO: panic!! or sth like that
//return Err("Wrong buffersize");
}
self.send_command(Command::RESOLUTION_SETTING)?; self.send_command(Command::PARTIAL_IN)?;
self.send_data((w >> 8) as u8)?; self.send_command(Command::PARTIAL_WINDOW)?;
self.send_data(w as u8)?; self.send_data((x >> 8) as u8)?;
self.send_data((h >> 8) as u8)?; let tmp = x & 0xf8;
self.send_data(h as u8) self.send_data(tmp as u8)?; // x should be the multiple of 8, the last 3 bit will always be ignored
} let tmp = tmp + width - 1;
self.send_data((tmp >> 8) as u8)?;
self.send_data((tmp | 0x07) as u8)?;
/// Displays the frame data from SRAM self.send_data((y >> 8) as u8)?;
pub fn display_frame(&mut self) -> Result<(), E> { self.send_data(y as u8)?;
self.set_lut()?;
self.send_command(Command::DISPLAY_REFRESH)?;
self.delay_ms(100); self.send_data(((y + height - 1) >> 8) as u8)?;
self.wait_until_idle(); self.send_data((y + height - 1) as u8)?;
Ok(())
self.send_data(0x01)?; // Gates scan both inside and outside of the partial window. (default)
//TODO: handle dtm somehow
let is_dtm1 = false;
if is_dtm1 {
self.send_command(Command::DATA_START_TRANSMISSION_1)?
} else {
self.send_command(Command::DATA_START_TRANSMISSION_2)?
}
self.send_multiple_data(buffer)?;
self.send_command(Command::PARTIAL_OUT)
} }
/// Same as display_frame(), but with nearly no delay fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>{
/// and uses the fast/partial refresh LUT self.update_frame(buffer)?;
/// needs more testing!!! self.display_frame()
/// maybe delay can be fully removed as wait_until_idle should do }
/// the necessary stuff
/// TODO: check delay!!!
/// Displays the frame data from SRAM fn display_frame(&mut self) -> Result<(), E> {
pub fn display_frame_quick(&mut self) -> Result<(), E> {
self.set_lut_quick()?;
self.send_command(Command::DISPLAY_REFRESH)?; self.send_command(Command::DISPLAY_REFRESH)?;
self.delay_ms(1);
self.wait_until_idle(); self.wait_until_idle();
Ok(()) Ok(())
} }
// TODO: add this abstraction function
/// Clears the frame from the buffer // fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>;
///
/// Set a reset_color if you want a different from the default 0xff
///
/// TODO: should that option be removed? E.g. the struct contains an additional default background value
/// which is settable?
pub fn clear_frame(&mut self, reset_color: Option<Color>) -> Result<(), E> {
let reset_color: Color = reset_color.unwrap_or(Color::White);
fn clear_frame(&mut self) -> Result<(), E> {
self.send_resolution()?; self.send_resolution()?;
let size = self.width / 8 * self.height; let size = self.width / 8 * self.height;
let color_value = self.color.get_byte_value();
self.send_command(Command::DATA_START_TRANSMISSION_1)?; self.send_command(Command::DATA_START_TRANSMISSION_1)?;
self.delay_ms(2); self.delay_ms(2);
for _ in 0..size { for _ in 0..size {
self.send_data(reset_color.get_byte_value())?; self.send_data(color_value)?;
} }
self.delay_ms(2); self.delay_ms(2);
@ -358,203 +317,101 @@ where
self.send_command(Command::DATA_START_TRANSMISSION_2)?; self.send_command(Command::DATA_START_TRANSMISSION_2)?;
self.delay_ms(2); self.delay_ms(2);
for _ in 0..size { for _ in 0..size {
self.send_data(reset_color.get_byte_value())?; self.send_data(color_value)?;
} }
Ok(()) Ok(())
} }
/// Let the device enter deep-sleep mode to save power. /// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame())
/// fn set_background_color(&mut self, color: Color) {
/// The deep sleep mode returns to standby with a hardware reset. self.color = color;
/// But you can also use [EPD4in2::reset()](EPD4in2::reset()) to awaken.
/// But as you need to power it up once more anyway you can also just directly use [EPD4in2::init()](EPD4in2::init()) for resetting
/// and initialising which already contains the reset
pub fn sleep(&mut self) -> Result<(), E> {
self.send_command(Command::VCOM_AND_DATA_INTERVAL_SETTING)?;
self.send_data(0x17)?; //border floating
self.send_command(Command::VCM_DC_SETTING)?; // VCOM to 0V
self.send_command(Command::PANEL_SETTING)?;
self.delay_ms(100);
self.send_command(Command::POWER_SETTING)?; //VG&VS to 0V fast
for _ in 0..4 {
self.send_data(0x00)?;
}
self.delay_ms(100);
self.send_command(Command::POWER_OFF)?;
self.wait_until_idle();
self.send_command(Command::DEEP_SLEEP)?;
self.send_data(0xA5)?;
Ok(())
} }
}
/// Resets the device. impl<SPI, CS, BUSY, DC, RST, D, E> EPD4in2<SPI, CS, BUSY, DC, RST, D>
/// where
/// Often used to awake the module from deep sleep. See [EPD4in2::sleep()](EPD4in2::sleep()) SPI: Write<u8, Error = E>,
/// CS: OutputPin,
/// TODO: Takes at least 400ms of delay alone, can it be shortened? BUSY: InputPin,
pub fn reset(&mut self) { DC: OutputPin,
self.rst.set_low(); RST: OutputPin,
D: DelayUs<u16> + DelayMs<u16>,
{
fn send_command(&mut self, command: Command) -> Result<(), E> {
self.interface.send_command(command)
}
//TODO: why 200ms? (besides being in the waveshare code) fn send_data(&mut self, val: u8) -> Result<(), E> {
self.delay_ms(200); self.interface.send_data(val)
}
self.rst.set_high(); fn send_multiple_data(&mut self, data: &[u8]) -> Result<(), E> {
self.interface.send_multiple_data(data)
}
//TODO: same as 3 lines above fn wait_until_idle(&mut self) {
self.delay_ms(200); self.interface.wait_until_idle(true)
} }
fn send_resolution(&mut self) -> Result<(), E> {
let w = self.get_width();
let h = self.get_height();
self.send_command(Command::RESOLUTION_SETTING)?;
self.send_data((w >> 8) as u8)?;
self.send_data(w as u8)?;
self.send_data((h >> 8) as u8)?;
self.send_data(h as u8)
}
/// Fill the look-up table for the EPD /// Fill the look-up table for the EPD
//TODO: make public? //TODO: make public?
fn set_lut(&mut self) -> Result<(), E> { fn set_lut(&mut self) -> Result<(), E> {
self.set_lut_helper( self.set_lut_helper(&LUT_VCOM0, &LUT_WW, &LUT_BW, &LUT_WB, &LUT_BB)
&LUT_VCOM0,
&LUT_WW,
&LUT_BW,
&LUT_WB,
&LUT_BB)
} }
/// Fill the look-up table for a quick display (partial refresh) /// Fill the look-up table for a quick display (partial refresh)
/// ///
/// Is automatically done by [EPD4in2::display_frame_quick()](EPD4in2::display_frame_quick()) /// Is automatically done by [EPD4in2::display_frame_quick()](EPD4in2::display_frame_quick())
/// //TODO: make public? /// //TODO: make public?
fn set_lut_quick(&mut self) -> Result<(), E> { fn set_lut_quick(&mut self) -> Result<(), E> {
self.set_lut_helper( self.set_lut_helper(
&LUT_VCOM0_QUICK, &LUT_VCOM0_QUICK,
&LUT_WW_QUICK, &LUT_WW_QUICK,
&LUT_BW_QUICK, &LUT_BW_QUICK,
&LUT_WB_QUICK, &LUT_WB_QUICK,
&LUT_BB_QUICK) &LUT_BB_QUICK,
)
} }
fn set_lut_helper(&mut self, fn set_lut_helper(
lut_vcom: &[u8], &mut self,
lut_ww: &[u8], lut_vcom: &[u8],
lut_bw: &[u8], lut_ww: &[u8],
lut_wb: &[u8], lut_bw: &[u8],
lut_bb: &[u8]) -> Result<(), E> lut_wb: &[u8],
{ lut_bb: &[u8],
//vcom ) -> Result<(), E> {
// LUT VCOM
self.send_command(Command::LUT_FOR_VCOM)?; self.send_command(Command::LUT_FOR_VCOM)?;
self.send_multiple_data(lut_vcom)?; self.send_multiple_data(lut_vcom)?;
//ww -- // LUT WHITE to WHITE
self.send_command(Command::LUT_WHITE_TO_WHITE)?; self.send_command(Command::LUT_WHITE_TO_WHITE)?;
self.send_multiple_data(lut_ww)?; self.send_multiple_data(lut_ww)?;
//bw r // LUT BLACK to WHITE
self.send_command(Command::LUT_BLACK_TO_WHITE)?; self.send_command(Command::LUT_BLACK_TO_WHITE)?;
self.send_multiple_data(lut_bw)?; self.send_multiple_data(lut_bw)?;
//wb w // LUT WHITE to BLACK
self.send_command(Command::LUT_WHITE_TO_BLACK)?; self.send_command(Command::LUT_WHITE_TO_BLACK)?;
self.send_multiple_data(lut_wb)?; self.send_multiple_data(lut_wb)?;
//bb b // LUT BLACK to BLACK
self.send_command(Command::LUT_BLACK_TO_BLACK)?; self.send_command(Command::LUT_BLACK_TO_BLACK)?;
self.send_multiple_data(lut_bb)?; self.send_multiple_data(lut_bb)?;
Ok(()) Ok(())
} }
/// Basic function for sending [Commands](Command).
///
/// Enables direct interaction with the device with the help of [EPD4in2::send_data()](EPD4in2::send_data())
/// Should rarely be needed!
/// //TODO: make public?
fn send_command(&mut self, command: Command) -> Result<(), E> {
// low for commands
self.dc.set_low();
// Transfer the command over spi
self.with_cs(|epd| {
epd.spi.write(&[command.addr()])
})
}
/// Basic function for sending a single u8 of data over spi
///
/// Enables direct interaction with the device with the help of [EPD4in2::send_command()](EPD4in2::send_command())
///
/// Should rarely be needed!
/// //TODO: make public?
fn send_data(&mut self, val: u8) -> Result<(), E> {
// high for data
self.dc.set_high();
// Transfer data (u8) over spi
self.with_cs(|epd| {
epd.spi.write(&[val])
})
}
/// Basic function for sending an array of u8-values of data over spi
///
/// Enables direct interaction with the device with the help of [EPD4in2::send_command()](EPD4in2::send_command())
///
/// Should rarely be needed!
/// //TODO: make public?
fn send_multiple_data(&mut self, data: &[u8]) -> Result<(), E> {
// high for data
self.dc.set_high();
// Transfer data (u8-array) over spi
self.with_cs(|epd| {
epd.spi.write(data)
})
}
// spi write helper/abstraction function
fn with_cs<F>(&mut self, f: F) -> Result<(), E>
where
F: FnOnce(&mut Self) -> Result<(), E>,
{
// activate spi with cs low
self.cs.set_low();
// transfer spi data
let result = f(self);
// deativate spi with cs high
self.cs.set_high();
// return result
result
}
/// Waits until device isn't busy anymore (busy == HIGH)
///
/// This is normally handled by the more complicated commands themselves,
/// but in the case you send data and commands directly you might need to check
/// if the device is still busy
pub fn wait_until_idle(&mut self) {
//low: busy, high: idle
while self.busy.is_low() {
//TODO: shorten the time? it was 100 in the beginning
self.delay_ms(10);
}
}
/// Abstraction of setting the delay for simpler calls
pub fn delay_ms(&mut self, delay: u16) {
self.delay.delay_ms(delay);
}
} }

25
src/interface/data_interface.rs → src/interface/connection_interface.rs
Unescape View File

@ -10,7 +10,7 @@ use interface::Command;
/// EPD4in2 driver /// EPD4in2 driver
/// ///
pub(crate) struct DataInterface<SPI, CS, BUSY, DC, RST, D> { pub(crate) struct ConnectionInterface<SPI, CS, BUSY, DC, RST, D> {
/// SPI /// SPI
spi: SPI, spi: SPI,
/// CS for SPI /// CS for SPI
@ -26,7 +26,7 @@ pub(crate) struct DataInterface<SPI, CS, BUSY, DC, RST, D> {
} }
impl<SPI, CS, BUSY, DC, RST, D, E> DataInterface<SPI, CS, BUSY, DC, RST, D> impl<SPI, CS, BUSY, DC, RST, D, E> ConnectionInterface<SPI, CS, BUSY, DC, RST, D>
where where
SPI: Write<u8, Error = E>, SPI: Write<u8, Error = E>,
CS: OutputPin, CS: OutputPin,
@ -36,12 +36,12 @@ where
D: DelayUs<u16> + DelayMs<u16>, D: DelayUs<u16> + DelayMs<u16>,
{ {
pub(crate) fn new(spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: D) -> Self { pub(crate) fn new(spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: D) -> Self {
DataInterface {spi, cs, busy, dc, rst, delay } ConnectionInterface {spi, cs, busy, dc, rst, delay }
} }
/// Basic function for sending [Commands](Command). /// Basic function for sending [Commands](Command).
/// ///
/// Enables direct interaction with the device with the help of [EPD4in2::send_data()](EPD4in2::send_data()) /// Enables direct interaction with the device with the help of [send_data()](ConnectionInterface::send_data())
/// Should rarely be needed! /// Should rarely be needed!
/// //TODO: make public? /// //TODO: make public?
pub(crate) fn send_command<T: Command>(&mut self, command: T) -> Result<(), E> { pub(crate) fn send_command<T: Command>(&mut self, command: T) -> Result<(), E> {
@ -56,7 +56,7 @@ where
/// Basic function for sending a single u8 of data over spi /// Basic function for sending a single u8 of data over spi
/// ///
/// Enables direct interaction with the device with the help of [EPD4in2::send_command()](EPD4in2::send_command()) /// Enables direct interaction with the device with the help of [Esend_command()](ConnectionInterface::send_command())
/// ///
/// Should rarely be needed! /// Should rarely be needed!
/// //TODO: make public? /// //TODO: make public?
@ -72,7 +72,7 @@ where
/// Basic function for sending an array of u8-values of data over spi /// Basic function for sending an array of u8-values of data over spi
/// ///
/// Enables direct interaction with the device with the help of [EPD4in2::send_command()](EPD4in2::send_command()) /// Enables direct interaction with the device with the help of [send_command()](EPD4in2::send_command())
/// ///
/// Should rarely be needed! /// Should rarely be needed!
/// //TODO: make public? /// //TODO: make public?
@ -107,11 +107,18 @@ where
/// This is normally handled by the more complicated commands themselves, /// This is normally handled by the more complicated commands themselves,
/// but in the case you send data and commands directly you might need to check /// but in the case you send data and commands directly you might need to check
/// if the device is still busy /// if the device is still busy
pub(crate) fn wait_until_idle(&mut self) { ///
/// is_busy_low
/// - TRUE for epd4in2, epd1in54, epd2in13, epd2in7, epd5in83, epd7in5
///
/// - FALSE for epd2in9
/// Most likely there was a mistake with the 2in9 busy connection
pub(crate) fn wait_until_idle(&mut self, is_busy_low: bool) {
self.delay_ms(1);
//low: busy, high: idle //low: busy, high: idle
while self.busy.is_low() { while (is_busy_low && self.busy.is_low()) || (!is_busy_low && self.busy.is_high()) {
//TODO: shorten the time? it was 100 in the beginning //TODO: shorten the time? it was 100 in the beginning
self.delay_ms(10); self.delay_ms(5);
} }
} }

33
src/interface/mod.rs
Unescape View File

@ -9,7 +9,7 @@ use hal::{
use drawing::color::Color; use drawing::color::Color;
pub mod data_interface; pub mod connection_interface;
//TODO: test spi mode //TODO: test spi mode
/// SPI mode - /// SPI mode -
@ -25,6 +25,18 @@ pub(crate) trait Command {
fn address(self) -> u8; fn address(self) -> u8;
} }
//TODO add LUT trait with set_fast_lut
// and set_manual_lut and set_normal_lut or sth like that
// for partial updates
pub trait LUTSupport<Error> {
fn set_lut(&mut self) -> Result<(), Error>;
fn set_lut_quick(&mut self) -> Result<(), Error>;
fn set_lut_manual(&mut self, data: &[u8]) -> Result<(), Error>;
}
pub trait WaveshareInterface<SPI, CS, BUSY, DC, RST, D, E> pub trait WaveshareInterface<SPI, CS, BUSY, DC, RST, D, E>
where where
SPI: Write<u8, Error = E>, SPI: Write<u8, Error = E>,
@ -63,16 +75,26 @@ pub trait WaveshareInterface<SPI, CS, BUSY, DC, RST, D, E>
fn init(&mut self) -> Result<(), E>; fn init(&mut self) -> Result<(), E>;
// void DisplayFrame(const unsigned char* frame_buffer);
/// Transmit a full frame to the SRAM of the DPD
///
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E>; fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E>;
//TODO: is dtm always used?
/// Transmit partial data to the SRAM of the EPD,
/// the final parameter dtm chooses between the 2
/// internal buffers
///
/// Normally it should be dtm2, so use false
///
/// BUFFER needs to be of size: w / 8 * l !
fn update_partial_frame(&mut self, buffer: &[u8], x: u16, y: u16, width: u16, height: u16) -> Result<(), E>; fn update_partial_frame(&mut self, buffer: &[u8], x: u16, y: u16, width: u16, height: u16) -> Result<(), E>;
/// Displays the frame data from SRAM /// Displays the frame data from SRAM
fn display_frame(&mut self) -> Result<(), E>; fn display_frame(&mut self) -> Result<(), E>;
// TODO: add this abstraction function // TODO: add this abstraction function
// fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>; fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>;
/// Clears the frame from the buffer /// Clears the frame from the buffer
/// ///
@ -102,10 +124,7 @@ pub trait WaveshareInterface<SPI, CS, BUSY, DC, RST, D, E>
fn delay_ms(&mut self, delay: u16); fn delay_ms(&mut self, delay: u16);
/* /*
-display_frame
-clear_frame
-set_full_frame
-set_partial_frame
// //
-set_quick_lut? -set_quick_lut?

3
src/lib.rs
Unescape View File

@ -58,7 +58,8 @@ use hal::{
pub mod drawing; pub mod drawing;
pub mod epd4in2; pub mod epd4in2;
use epd4in2::*;
pub mod epd2in9; pub mod epd2in9;

Write Preview
Loading…
Cancel
Save