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

Run cargo fmt (reverted for constants and some graphic calculations)

embedded-hal-1.0
Chris 2018-11-05 15:31:52 +01:00
parent 375adf4bff
commit e518265273
14 changed files with 365 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/color.rs
View File

@ -1,6 +1,5 @@
//! B/W Color for EPDs
/// Only for the Black/White-Displays
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Color {
@ -34,12 +33,15 @@ impl Color {
match val {
0 => Color::Black,
1 => Color::White,
e => panic!("DisplayColor only parses 0 and 1 (Black and White) and not `{}`", e),
e => panic!(
"DisplayColor only parses 0 and 1 (Black and White) and not `{}`",
e
),
}
}
/// Returns the inverse of the given color.
///
/// Returns the inverse of the given color.
///
/// Black returns White and White returns Black
pub fn inverse(self) -> Color {
match self {
@ -60,8 +62,6 @@ impl From<u8> for Color {
}
}
#[cfg(test)]
mod tests {
use super::*;
@ -79,7 +79,7 @@ mod tests {
extern crate std;
let result = std::panic::catch_unwind(|| Color::from(val));
assert!(result.is_err());
}
}
}
#[test]

35
src/epd1in54/graphics.rs
View File

@ -1,9 +1,9 @@
use epd1in54::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
use epd1in54::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
/// Full size buffer for use with the 1in54 EPD
///
///
/// Can also be manuall constructed:
/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
pub struct Buffer1in54BlackWhite {
pub buffer: [u8; WIDTH as usize * HEIGHT as usize / 8],
}
@ -11,23 +11,20 @@ pub struct Buffer1in54BlackWhite {
impl Default for Buffer1in54BlackWhite {
fn default() -> Self {
Buffer1in54BlackWhite {
buffer: [
DEFAULT_BACKGROUND_COLOR.get_byte_value();
WIDTH as usize * HEIGHT as usize / 8
]
buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value();
WIDTH as usize * HEIGHT as usize / 8],
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use graphics::{DisplayRotation, Display};
use embedded_graphics::coord::Coord;
use embedded_graphics::primitives::Line;
use color::Color;
use embedded_graphics::coord::Coord;
use embedded_graphics::prelude::*;
use embedded_graphics::primitives::Line;
use graphics::{Display, DisplayRotation};
// test buffer length
#[test]
@ -36,7 +33,7 @@ mod tests {
let display = Display::new(WIDTH, HEIGHT, &mut display1in54.buffer);
assert_eq!(display.buffer().len(), 5000);
}
// test default background color on all bytes
#[test]
fn graphics_default() {
@ -56,7 +53,7 @@ mod tests {
.with_stroke(Some(Color::Black))
.into_iter(),
);
let buffer = display.buffer();
assert_eq!(buffer[0], Color::Black.get_byte_value());
@ -76,7 +73,7 @@ mod tests {
.with_stroke(Some(Color::Black))
.into_iter(),
);
let buffer = display.buffer();
assert_eq!(buffer[0], Color::Black.get_byte_value());
@ -96,7 +93,7 @@ mod tests {
.with_stroke(Some(Color::Black))
.into_iter(),
);
let buffer = display.buffer();
extern crate std;
@ -107,7 +104,6 @@ mod tests {
for &byte in buffer.iter().skip(1) {
assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
}
}
#[test]
@ -120,7 +116,7 @@ mod tests {
.with_stroke(Some(Color::Black))
.into_iter(),
);
let buffer = display.buffer();
extern crate std;
@ -131,6 +127,5 @@ mod tests {
for &byte in buffer.iter().skip(1) {
assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
}
}
}
}

141
src/epd1in54/mod.rs
View File

@ -1,21 +1,21 @@
//! A simple Driver for the Waveshare 1.54" E-Ink Display via SPI
//!
//!
//! # Example for the 1.54 in E-Ink Display
//!
//!
//! ```ignore
//! use eink_waveshare_rs::{
//! epd1in54::{EPD1in54, Buffer1in54},
//! graphics::{Display, DisplayRotation},
//! prelude::*,
//! };
//!
//! };
//!
//! // Setup EPD
//! let mut epd = EPD1in54::new(&mut spi, cs_pin, busy_in, dc, rst, &mut delay)?;
//!
//! // Use display graphics
//! let mut buffer = Buffer1in54::default();
//! let mut display = Display::new(epd.width(), epd.height(), &mut buffer.buffer);
//!
//!
//! // Write some hello world in the screenbuffer
//! display.draw(
//! Font6x8::render_str("Hello World!")
@ -28,7 +28,7 @@
//! // Display updated frame
//! epd.update_frame(&mut spi, &display.buffer()).unwrap();
//! epd.display_frame(&mut spi).expect("display frame new graphics");
//!
//!
//! // Set the EPD to sleep
//! epd.sleep(&mut spi).expect("sleep");
//! ```
@ -44,13 +44,13 @@ use hal::{
};
use type_a::{
command::Command,
constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}
command::Command,
constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE},
};
use color::Color;
use traits::{WaveshareDisplay, RefreshLUT};
use traits::{RefreshLUT, WaveshareDisplay};
use interface::DisplayInterface;
@ -76,7 +76,11 @@ where
DC: OutputPin,
RST: OutputPin,
{
fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
fn init<DELAY: DelayMs<u8>>(
&mut self,
spi: &mut SPI,
delay: &mut DELAY,
) -> Result<(), SPI::Error> {
self.interface.reset(delay);
// 3 Databytes:
@ -85,9 +89,9 @@ where
// 0.. B[2:0]
// Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?)
self.interface.cmd_with_data(
spi,
Command::DRIVER_OUTPUT_CONTROL,
&[HEIGHT as u8, (HEIGHT >> 8) as u8, 0x00]
spi,
Command::DRIVER_OUTPUT_CONTROL,
&[HEIGHT as u8, (HEIGHT >> 8) as u8, 0x00],
)?;
// 3 Databytes: (and default values from datasheet and arduino)
@ -95,24 +99,31 @@ where
// 1 .. B[6:0] = 0xCE | 0xD6
// 1 .. C[6:0] = 0x8D | 0x9D
//TODO: test
self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START_CONTROL, &[0xD7, 0xD6, 0x9D])?;
self.interface.cmd_with_data(
spi,
Command::BOOSTER_SOFT_START_CONTROL,
&[0xD7, 0xD6, 0x9D],
)?;
// One Databyte with value 0xA8 for 7V VCOM
self.interface.cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
self.interface
.cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
// One Databyte with default value 0x1A for 4 dummy lines per gate
self.interface.cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
self.interface
.cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
// One Databyte with default value 0x08 for 2us per line
self.interface.cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
self.interface
.cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
// One Databyte with default value 0x03
// -> address: x increment, y increment, address counter is updated in x direction
self.interface.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
self.interface
.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
self.set_lut(spi, None)
}
}
impl<SPI, CS, BUSY, DC, RST, E> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
@ -133,14 +144,19 @@ where
}
fn new<DELAY: DelayMs<u8>>(
spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY,
spi: &mut SPI,
cs: CS,
busy: BUSY,
dc: DC,
rst: RST,
delay: &mut DELAY,
) -> Result<Self, SPI::Error> {
let interface = DisplayInterface::new(cs, busy, dc, rst);
let mut epd = EPD1in54 {
interface,
background_color: DEFAULT_BACKGROUND_COLOR,
refresh: RefreshLUT::FULL
refresh: RefreshLUT::FULL,
};
epd.init(spi, delay)?;
@ -148,16 +164,19 @@ where
Ok(epd)
}
fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
fn wake_up<DELAY: DelayMs<u8>>(
&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> {
// 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
//TODO: is 0x00 needed here or would 0x01 be even more efficient?
self.interface.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
self.interface
.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
self.wait_until_idle();
Ok(())
@ -165,7 +184,8 @@ where
fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
self.use_full_frame(spi)?;
self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
self.interface
.cmd_with_data(spi, Command::WRITE_RAM, buffer)
}
//TODO: update description: last 3 bits will be ignored for width and x_pos
@ -181,13 +201,15 @@ where
self.set_ram_area(spi, x, y, x + width, y + height)?;
self.set_ram_counter(spi, x, y)?;
self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
self.interface
.cmd_with_data(spi, Command::WRITE_RAM, buffer)
}
fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
// enable clock signal, enable cp, display pattern -> 0xC4 (tested with the arduino version)
//TODO: test control_1 or control_2 with default value 0xFF (from the datasheet)
self.interface.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface
.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface.cmd(spi, Command::MASTER_ACTIVATION)?;
// MASTER Activation should not be interupted to avoid currption of panel images
@ -202,34 +224,29 @@ where
let color = self.background_color.get_byte_value();
//TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
self.interface.cmd(
spi,
Command::WRITE_RAM
)?;
self.interface.cmd(spi, Command::WRITE_RAM)?;
self.interface.data_x_times(spi, color, WIDTH / 8 * HEIGHT)
}
fn set_background_color(&mut self, background_color: Color) {
self.background_color = background_color;
}
fn background_color(&self) -> &Color {
&self.background_color
}
fn set_lut(&mut self, spi: &mut SPI, refresh_rate: Option<RefreshLUT>) -> Result<(), SPI::Error> {
fn set_lut(
&mut self,
spi: &mut SPI,
refresh_rate: Option<RefreshLUT>,
) -> 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)
}
RefreshLUT::FULL => self.set_lut_helper(spi, &LUT_FULL_UPDATE),
RefreshLUT::QUICK => self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE),
}
}
}
@ -240,7 +257,7 @@ where
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin
RST: OutputPin,
{
fn wait_until_idle(&mut self) {
self.interface.wait_until_idle(false);
@ -255,7 +272,7 @@ where
}
pub(crate) fn set_ram_area(
&mut self,
&mut self,
spi: &mut SPI,
start_x: u32,
start_y: u32,
@ -270,30 +287,39 @@ where
self.interface.cmd_with_data(
spi,
Command::SET_RAM_X_ADDRESS_START_END_POSITION,
&[(start_x >> 3) as u8, (end_x >> 3) as u8]
&[(start_x >> 3) as u8, (end_x >> 3) as u8],
)?;
// 2 Databytes: A[7:0] & 0..A[8] for each - start and end
self.interface.cmd_with_data(
spi,
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]
&[
start_y as u8,
(start_y >> 8) as u8,
end_y as u8,
(end_y >> 8) as u8,
],
)
}
pub(crate) fn set_ram_counter(&mut self, spi: &mut SPI, x: u32, y: u32) -> Result<(), SPI::Error> {
pub(crate) fn set_ram_counter(
&mut self,
spi: &mut SPI,
x: u32,
y: u32,
) -> Result<(), SPI::Error> {
// x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant
self.interface.cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?;
self.interface
.cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?;
// 2 Databytes: A[7:0] & 0..A[8]
self.interface.cmd_with_data(
spi,
Command::SET_RAM_Y_ADDRESS_COUNTER,
&[
y as u8,
(y >> 8) as u8
])?;
spi,
Command::SET_RAM_Y_ADDRESS_COUNTER,
&[y as u8, (y >> 8) as u8],
)?;
self.wait_until_idle();
Ok(())
@ -301,7 +327,8 @@ where
fn set_lut_helper(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
assert!(buffer.len() == 30);
self.interface.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
self.interface
.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
}
}
@ -315,4 +342,4 @@ mod tests {
assert_eq!(HEIGHT, 200);
assert_eq!(DEFAULT_BACKGROUND_COLOR, Color::White);
}
}
}

17
src/epd2in9/graphics.rs
View File

@ -1,9 +1,9 @@
use epd2in9::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
use epd2in9::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
/// Full size buffer for use with the 2in9 EPD
///
///
/// Can also be manuall constructed:
/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
pub struct Buffer2in9 {
pub buffer: [u8; WIDTH as usize * HEIGHT as usize / 8],
}
@ -11,15 +11,12 @@ pub struct Buffer2in9 {
impl Default for Buffer2in9 {
fn default() -> Self {
Buffer2in9 {
buffer: [
DEFAULT_BACKGROUND_COLOR.get_byte_value();
WIDTH as usize * HEIGHT as usize / 8
]
buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value();
WIDTH as usize * HEIGHT as usize / 8],
}
}
}
#[cfg(test)]
mod tests {
use super::*;
@ -32,7 +29,7 @@ mod tests {
let display = Display::new(WIDTH, HEIGHT, &mut buffer.buffer);
assert_eq!(display.buffer().len(), 4736);
}
// test default background color on all bytes
#[test]
fn graphics_default() {
@ -42,4 +39,4 @@ mod tests {
assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
}
}
}
}

119
src/epd2in9/mod.rs
View File

@ -3,21 +3,21 @@
//! Untested!
//!
//! # Example for the 2.9 in E-Ink Display
//!
//!
//! ```ignore
//! use eink_waveshare_rs::{
//! epd2in9::{EPD2in9, Buffer2in9},
//! graphics::{Display, DisplayRotation},
//! prelude::*,
//! };
//!
//! };
//!
//! // Setup EPD
//! let mut epd = EPD2in9::new(&mut spi, cs_pin, busy_in, dc, rst, &mut delay)?;
//!
//! // Use display graphics
//! let mut buffer = Buffer2in9::default();
//! let mut display = Display::new(epd.width(), epd.height(), &mut buffer.buffer);
//!
//!
//! // Write some hello world in the screenbuffer
//! display.draw(
//! Font6x8::render_str("Hello World!")
@ -30,7 +30,7 @@
//! // Display updated frame
//! epd.update_frame(&mut spi, &display.buffer()).unwrap();
//! epd.display_frame(&mut spi).expect("display frame new graphics");
//!
//!
//! // Set the EPD to sleep
//! epd.sleep(&mut spi).expect("sleep");
//! ```
@ -45,8 +45,8 @@ use hal::{
};
use type_a::{
command::Command,
constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}
command::Command,
constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE},
};
use color::Color;
@ -77,7 +77,11 @@ where
DC: OutputPin,
RST: OutputPin,
{
fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
fn init<DELAY: DelayMs<u8>>(
&mut self,
spi: &mut SPI,
delay: &mut DELAY,
) -> Result<(), SPI::Error> {
self.interface.reset(delay);
// 3 Databytes:
@ -85,34 +89,42 @@ where
// 0.. A[8]
// 0.. B[2:0]
// Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?)
self.interface.cmd_with_data(spi, Command::DRIVER_OUTPUT_CONTROL, &[0x27, 0x01, 0x00])?;
self.interface
.cmd_with_data(spi, Command::DRIVER_OUTPUT_CONTROL, &[0x27, 0x01, 0x00])?;
// 3 Databytes: (and default values from datasheet and arduino)
// 1 .. A[6:0] = 0xCF | 0xD7
// 1 .. B[6:0] = 0xCE | 0xD6
// 1 .. C[6:0] = 0x8D | 0x9D
//TODO: test
self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START_CONTROL, &[0xD7, 0xD6, 0x9D])?;
self.interface.cmd_with_data(
spi,
Command::BOOSTER_SOFT_START_CONTROL,
&[0xD7, 0xD6, 0x9D],
)?;
// One Databyte with value 0xA8 for 7V VCOM
self.interface.cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
self.interface
.cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
// One Databyte with default value 0x1A for 4 dummy lines per gate
self.interface.cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
self.interface
.cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
// One Databyte with default value 0x08 for 2us per line
self.interface.cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
self.interface
.cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
// One Databyte with default value 0x03
// -> address: x increment, y increment, address counter is updated in x direction
self.interface.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
self.interface
.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
self.set_lut(spi, None)
}
}
impl<SPI, CS, BUSY, DC, RST>
WaveshareDisplay<SPI, CS, BUSY, DC, RST>
impl<SPI, CS, BUSY, DC, RST> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
for EPD2in9<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8>,
@ -130,7 +142,12 @@ where
}
fn new<DELAY: DelayMs<u8>>(
spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY,
spi: &mut SPI,
cs: CS,
busy: BUSY,
dc: DC,
rst: RST,
delay: &mut DELAY,
) -> Result<Self, SPI::Error> {
let interface = DisplayInterface::new(cs, busy, dc, rst);
@ -145,30 +162,34 @@ where
Ok(epd)
}
fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
// 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
//TODO: is 0x00 needed here? (see also epd1in54)
self.interface.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
self.interface
.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
self.wait_until_idle();
Ok(())
}
fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
fn wake_up<DELAY: DelayMs<u8>>(
&mut self,
spi: &mut SPI,
delay: &mut DELAY,
) -> Result<(), SPI::Error> {
self.init(spi, delay)
}
fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
self.use_full_frame(spi)?;
self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
self.interface
.cmd_with_data(spi, Command::WRITE_RAM, buffer)
}
//TODO: update description: last 3 bits will be ignored for width and x_pos
fn update_partial_frame(
&mut self,
&mut self,
spi: &mut SPI,
buffer: &[u8],
x: u32,
@ -179,13 +200,15 @@ where
self.set_ram_area(spi, x, y, x + width, y + height)?;
self.set_ram_counter(spi, x, y)?;
self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
self.interface
.cmd_with_data(spi, Command::WRITE_RAM, buffer)
}
fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
// enable clock signal, enable cp, display pattern -> 0xC4 (tested with the arduino version)
//TODO: test control_1 or control_2 with default value 0xFF (from the datasheet)
self.interface.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface
.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface.cmd(spi, Command::MASTER_ACTIVATION)?;
// MASTER Activation should not be interupted to avoid currption of panel images
@ -212,17 +235,17 @@ where
&self.background_color
}
fn set_lut(&mut self, spi: &mut SPI, refresh_rate: Option<RefreshLUT>) -> Result<(), SPI::Error> {
fn set_lut(
&mut self,
spi: &mut SPI,
refresh_rate: Option<RefreshLUT>,
) -> 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)
}
RefreshLUT::FULL => self.set_lut_helper(spi, &LUT_FULL_UPDATE),
RefreshLUT::QUICK => self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE),
}
}
}
@ -248,7 +271,7 @@ where
}
fn set_ram_area(
&mut self,
&mut self,
spi: &mut SPI,
start_x: u32,
start_y: u32,
@ -262,23 +285,35 @@ where
// aren't relevant
self.interface.cmd_with_data(
spi,
Command::SET_RAM_X_ADDRESS_START_END_POSITION,
&[(start_x >> 3) as u8, (end_x >> 3) as u8]
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.interface.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]
self.interface.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> {
// x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant
self.interface.cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?;
self.interface
.cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?;
// 2 Databytes: A[7:0] & 0..A[8]
self.interface.cmd_with_data(spi, Command::SET_RAM_Y_ADDRESS_COUNTER, &[y as u8, (y >> 8) as u8])?;
self.interface.cmd_with_data(
spi,
Command::SET_RAM_Y_ADDRESS_COUNTER,
&[y as u8, (y >> 8) as u8],
)?;
self.wait_until_idle();
Ok(())
@ -286,11 +321,11 @@ where
fn set_lut_helper(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
assert!(buffer.len() == 30);
self.interface.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
self.interface
.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
}
}
#[cfg(test)]
mod tests {
use super::*;
@ -301,4 +336,4 @@ mod tests {
assert_eq!(HEIGHT, 296);
assert_eq!(DEFAULT_BACKGROUND_COLOR, Color::White);
}
}
}

2
src/epd4in2/constants.rs
View File

@ -4,7 +4,6 @@ pub const WIDTH: u32 = 400;
pub const HEIGHT: u32 = 300;
pub const DEFAULT_BACKGROUND_COLOR: Color = Color::White;
pub(crate) const LUT_VCOM0: [u8; 44] = [
0x00, 0x17, 0x00, 0x00, 0x00, 0x02,
0x00, 0x17, 0x17, 0x00, 0x00, 0x02,
@ -15,7 +14,6 @@ pub(crate) const LUT_VCOM0: [u8; 44] = [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
pub(crate) const LUT_VCOM0_QUICK: [u8; 44] = [
0x00, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

59
src/epd4in2/graphics.rs
View File

@ -1,9 +1,9 @@
use epd4in2::constants::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
use epd4in2::constants::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
/// Full size buffer for use with the 4in2 EPD
///
///
/// Can also be manuall constructed:
/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
pub struct Buffer4in2 {
pub buffer: [u8; WIDTH as usize * HEIGHT as usize / 8],
}
@ -11,24 +11,21 @@ pub struct Buffer4in2 {
impl Default for Buffer4in2 {
fn default() -> Self {
Buffer4in2 {
buffer: [
DEFAULT_BACKGROUND_COLOR.get_byte_value();
WIDTH as usize * HEIGHT as usize / 8
]
buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value();
WIDTH as usize * HEIGHT as usize / 8],
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use epd4in2;
use graphics::{DisplayRotation, Display};
use embedded_graphics::coord::Coord;
use embedded_graphics::primitives::Line;
use color::Color;
use embedded_graphics::coord::Coord;
use embedded_graphics::prelude::*;
use embedded_graphics::primitives::Line;
use epd4in2;
use graphics::{Display, DisplayRotation};
// test buffer length
#[test]
@ -37,7 +34,7 @@ mod tests {
let display = Display::new(WIDTH, HEIGHT, &mut display4in2.buffer);
assert_eq!(display.buffer().len(), 15000);
}
// test default background color on all bytes
#[test]
fn graphics_default() {
@ -45,7 +42,10 @@ mod tests {
let display = Display::new(WIDTH, HEIGHT, &mut display4in2.buffer);
use epd4in2;
for &byte in display.buffer() {
assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
assert_eq!(
byte,
epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
);
}
}
@ -58,13 +58,16 @@ mod tests {
.with_stroke(Some(Color::Black))
.into_iter(),
);
let buffer = display.buffer();
assert_eq!(buffer[0], Color::Black.get_byte_value());
for &byte in buffer.iter().skip(1) {
assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
assert_eq!(
byte,
epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
);
}
}
@ -78,13 +81,16 @@ mod tests {
.with_stroke(Some(Color::Black))
.into_iter(),
);
let buffer = display.buffer();
assert_eq!(buffer[0], Color::Black.get_byte_value());
for &byte in buffer.iter().skip(1) {
assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
assert_eq!(
byte,
epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
);
}
}
@ -98,7 +104,7 @@ mod tests {
.with_stroke(Some(Color::Black))
.into_iter(),
);
let buffer = display.buffer();
extern crate std;
@ -107,9 +113,11 @@ mod tests {
assert_eq!(buffer[0], Color::Black.get_byte_value());
for &byte in buffer.iter().skip(1) {
assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
assert_eq!(
byte,
epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
);
}
}
#[test]
@ -122,7 +130,7 @@ mod tests {
.with_stroke(Some(Color::Black))
.into_iter(),
);
let buffer = display.buffer();
extern crate std;
@ -131,9 +139,10 @@ mod tests {
assert_eq!(buffer[0], Color::Black.get_byte_value());
for &byte in buffer.iter().skip(1) {
assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
assert_eq!(
byte,
epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
);
}
}
}

149
src/epd4in2/mod.rs
View File

@ -51,8 +51,8 @@ use hal::{
digital::*,
};
use traits::{WaveshareDisplay, InternalWiAdditions, RefreshLUT};
use interface::DisplayInterface;
use traits::{InternalWiAdditions, RefreshLUT, WaveshareDisplay};
//The Lookup Tables for the Display
mod constants; //TODO: Limit to crate::drawing
@ -66,7 +66,6 @@ use self::command::Command;
mod graphics;
pub use self::graphics::Buffer4in2;
/// EPD4in2 driver
///
pub struct EPD4in2<SPI, CS, BUSY, DC, RST> {
@ -78,11 +77,7 @@ pub struct EPD4in2<SPI, CS, BUSY, DC, RST> {
refresh: RefreshLUT,
}
impl<SPI, CS, BUSY, DC, RST>
InternalWiAdditions<SPI, CS, BUSY, DC, RST>
impl<SPI, CS, BUSY, DC, RST> InternalWiAdditions<SPI, CS, BUSY, DC, RST>
for EPD4in2<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8>,
@ -91,15 +86,24 @@ where
DC: OutputPin,
RST: OutputPin,
{
fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
fn init<DELAY: DelayMs<u8>>(
&mut self,
spi: &mut SPI,
delay: &mut DELAY,
) -> Result<(), SPI::Error> {
// reset the device
self.interface.reset(delay);
// set the power settings
self.interface.cmd_with_data(spi, Command::POWER_SETTING, &[0x03, 0x00, 0x2b, 0x2b, 0xff])?;
self.interface.cmd_with_data(
spi,
Command::POWER_SETTING,
&[0x03, 0x00, 0x2b, 0x2b, 0xff],
)?;
// start the booster
self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START, &[0x17, 0x17, 0x17])?;
self.interface
.cmd_with_data(spi, Command::BOOSTER_SOFT_START, &[0x17, 0x17, 0x17])?;
// power on
self.command(spi, Command::POWER_ON)?;
@ -114,15 +118,14 @@ where
// TODO: Test these other frequencies
// 3A 100HZ 29 150Hz 39 200HZ 31 171HZ DEFAULT: 3c 50Hz
self.cmd_with_data(spi, Command::PLL_CONTROL, &[0x3A])?;
self.set_lut(spi, None)?;
Ok(())
}
}
impl<SPI, CS, BUSY, DC, RST>
WaveshareDisplay<SPI, CS, BUSY, DC, RST>
impl<SPI, CS, BUSY, DC, RST> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
for EPD4in2<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8>,
@ -146,14 +149,21 @@ where
///
/// epd4in2.sleep();
/// ```
fn new<DELAY: DelayMs<u8>>(spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY) -> Result<Self, SPI::Error> {
fn new<DELAY: DelayMs<u8>>(
spi: &mut SPI,
cs: CS,
busy: BUSY,
dc: DC,
rst: RST,
delay: &mut DELAY,
) -> Result<Self, SPI::Error> {
let interface = DisplayInterface::new(cs, busy, dc, rst);
let color = DEFAULT_BACKGROUND_COLOR;
let mut epd = EPD4in2 {
interface,
color,
refresh: RefreshLUT::FULL
refresh: RefreshLUT::FULL,
};
epd.init(spi, delay)?;
@ -161,12 +171,17 @@ where
Ok(epd)
}
fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
fn wake_up<DELAY: DelayMs<u8>>(
&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.interface.cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x17])?; //border floating
self.interface
.cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x17])?; //border floating
self.command(spi, Command::VCM_DC_SETTING)?; // VCOM to 0V
self.command(spi, Command::PANEL_SETTING)?;
@ -177,7 +192,8 @@ where
self.command(spi, Command::POWER_OFF)?;
self.wait_until_idle();
self.interface.cmd_with_data(spi, Command::DEEP_SLEEP, &[0xA5])
self.interface
.cmd_with_data(spi, Command::DEEP_SLEEP, &[0xA5])
}
fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
@ -185,20 +201,25 @@ where
self.send_resolution(spi)?;
self.interface.cmd_with_data(spi, Command::VCM_DC_SETTING, &[0x12])?;
self.interface
.cmd_with_data(spi, Command::VCM_DC_SETTING, &[0x12])?;
//VBDF 17|D7 VBDW 97 VBDB 57 VBDF F7 VBDW 77 VBDB 37 VBDR B7
self.interface.cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x97])?;
self.interface
.cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x97])?;
self.interface.cmd(spi, Command::DATA_START_TRANSMISSION_1)?;
self.interface.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)?;
self.interface
.cmd(spi, Command::DATA_START_TRANSMISSION_1)?;
self.interface
.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)?;
self.interface.cmd_with_data(spi, Command::DATA_START_TRANSMISSION_2, buffer)
self.interface
.cmd_with_data(spi, Command::DATA_START_TRANSMISSION_2, buffer)
}
fn update_partial_frame(
&mut self,
spi: &mut SPI,
&mut self,
spi: &mut SPI,
buffer: &[u8],
x: u32,
y: u32,
@ -240,8 +261,6 @@ where
self.command(spi, Command::PARTIAL_OUT)
}
fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.command(spi, Command::DISPLAY_REFRESH)?;
@ -254,14 +273,18 @@ where
let color_value = self.color.get_byte_value();
self.interface.cmd(spi, Command::DATA_START_TRANSMISSION_1)?;
self.interface.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)?;
self.interface
.cmd(spi, Command::DATA_START_TRANSMISSION_1)?;
self.interface
.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)?;
//TODO: Removal of delay. TEST!
//self.delay_ms(2);
self.interface.cmd(spi, Command::DATA_START_TRANSMISSION_2)?;
self.interface.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)
self.interface
.cmd(spi, Command::DATA_START_TRANSMISSION_2)?;
self.interface
.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)
}
fn set_background_color(&mut self, color: Color) {
@ -280,24 +303,26 @@ where
HEIGHT
}
fn set_lut(&mut self, spi: &mut SPI, refresh_rate: Option<RefreshLUT>) -> Result<(), SPI::Error> {
fn set_lut(
&mut self,
spi: &mut SPI,
refresh_rate: Option<RefreshLUT>,
) -> 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_VCOM0, &LUT_WW, &LUT_BW, &LUT_WB, &LUT_BB)
},
RefreshLUT::QUICK => {
self.set_lut_helper(
spi,
&LUT_VCOM0_QUICK,
&LUT_WW_QUICK,
&LUT_BW_QUICK,
&LUT_WB_QUICK,
&LUT_BB_QUICK,
)
}
RefreshLUT::QUICK => self.set_lut_helper(
spi,
&LUT_VCOM0_QUICK,
&LUT_WW_QUICK,
&LUT_BW_QUICK,
&LUT_WB_QUICK,
&LUT_BB_QUICK,
),
}
}
}
@ -318,7 +343,12 @@ where
self.interface.data(spi, data)
}
fn cmd_with_data(&mut self, spi: &mut SPI, command: Command, data: &[u8]) -> Result<(), SPI::Error> {
fn cmd_with_data(
&mut self,
spi: &mut SPI,
command: Command,
data: &[u8],
) -> Result<(), SPI::Error> {
self.interface.cmd_with_data(spi, command, data)
}
@ -347,43 +377,22 @@ where
lut_bb: &[u8],
) -> Result<(), SPI::Error> {
// LUT VCOM
self.cmd_with_data(
spi,
Command::LUT_FOR_VCOM,
lut_vcom
)?;
self.cmd_with_data(spi, Command::LUT_FOR_VCOM, lut_vcom)?;
// LUT WHITE to WHITE
self.cmd_with_data(
spi,
Command::LUT_WHITE_TO_WHITE,
lut_ww
)?;
self.cmd_with_data(spi, Command::LUT_WHITE_TO_WHITE, lut_ww)?;
// LUT BLACK to WHITE
self.cmd_with_data(
spi,
Command::LUT_BLACK_TO_WHITE,
lut_bw
)?;
self.cmd_with_data(spi, Command::LUT_BLACK_TO_WHITE, lut_bw)?;
// LUT WHITE to BLACK
self.cmd_with_data(
spi,
Command::LUT_WHITE_TO_BLACK,
lut_wb,
)?;
self.cmd_with_data(spi, Command::LUT_WHITE_TO_BLACK, lut_wb)?;
// LUT BLACK to BLACK
self.cmd_with_data(
spi,
Command::LUT_BLACK_TO_BLACK,
lut_bb,
)
self.cmd_with_data(spi, Command::LUT_BLACK_TO_BLACK, lut_bb)
}
}
#[cfg(test)]
mod tests {
use super::*;
@ -394,4 +403,4 @@ mod tests {
assert_eq!(HEIGHT, 300);
assert_eq!(DEFAULT_BACKGROUND_COLOR, Color::White);
}
}
}

32
src/graphics.rs
View File

@ -60,14 +60,12 @@ impl<'a> Display<'a> {
}
}
impl<'a> Drawing<Color> for Display<'a> {
fn draw<T>(&mut self, item_pixels: T)
where
T: Iterator<Item = Pixel<Color>>
T: Iterator<Item = Pixel<Color>>,
{
for Pixel(UnsignedCoord(x,y), color) in item_pixels {
for Pixel(UnsignedCoord(x, y), color) in item_pixels {
if outside_display(x, y, self.width, self.height, self.rotation) {
continue;
}
@ -89,14 +87,13 @@ impl<'a> Drawing<Color> for Display<'a> {
}
}
fn outside_display(x: u32, y: u32, width: u32, height: u32, rotation: DisplayRotation) -> bool {
match rotation {
DisplayRotation::Rotate0 | DisplayRotation::Rotate180 => {
if x >= width || y >= height {
return true;
}
},
}
DisplayRotation::Rotate90 | DisplayRotation::Rotate270 => {
if y >= width || x >= height {
return true;
@ -127,19 +124,17 @@ fn rotation(x: u32, y: u32, width: u32, height: u32, rotation: DisplayRotation)
}
}
#[cfg(test)]
mod tests {
use super::{DisplayRotation, outside_display, rotation, Display};
use super::{outside_display, rotation, Display, DisplayRotation};
use color::Color;
use embedded_graphics::coord::Coord;
use embedded_graphics::primitives::Line;
use embedded_graphics::prelude::*;
use embedded_graphics::primitives::Line;
#[test]
fn buffer_clear() {
use epd4in2::{WIDTH, HEIGHT};
use epd4in2::{HEIGHT, WIDTH};
let mut buffer = [Color::Black.get_byte_value(); WIDTH as usize / 8 * HEIGHT as usize];
let mut display = Display::new(WIDTH, HEIGHT, &mut buffer);
@ -155,22 +150,21 @@ mod tests {
}
}
#[test]
fn rotation_overflow() {
use epd4in2::{WIDTH, HEIGHT};
use epd4in2::{HEIGHT, WIDTH};
let width = WIDTH as u32;
let height = HEIGHT as u32;
test_rotation_overflow(width, height, DisplayRotation::Rotate0);
test_rotation_overflow(width, height, DisplayRotation::Rotate90);
test_rotation_overflow(width, height, DisplayRotation::Rotate180);
test_rotation_overflow(width, height, DisplayRotation::Rotate270);
}
fn test_rotation_overflow(width: u32, height: u32, rotation2: DisplayRotation) {
let max_value = width / 8 * height;
for x in 0..(width + height) { //limit x because it runs too long
for x in 0..(width + height) {
//limit x because it runs too long
for y in 0..(u32::max_value()) {
if outside_display(x, y, width, height, rotation2) {
break;
@ -182,11 +176,9 @@ mod tests {
}
}
#[test]
fn graphics_rotation_0() {
use epd2in9::{DEFAULT_BACKGROUND_COLOR};
use epd2in9::DEFAULT_BACKGROUND_COLOR;
let width = 128;
let height = 296;
@ -210,7 +202,7 @@ mod tests {
#[test]
fn graphics_rotation_90() {
use epd2in9::{DEFAULT_BACKGROUND_COLOR};
use epd2in9::DEFAULT_BACKGROUND_COLOR;
let width = 128;
let height = 296;
@ -236,4 +228,4 @@ mod tests {
assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
}
}
}
}

26
src/interface.rs
View File

@ -1,8 +1,8 @@
use core::marker::PhantomData;
use hal::{
blocking::{delay::*, spi::Write},
digital::*,
};
use core::marker::PhantomData;
use traits::Command;
/// The Connection Interface of all (?) Waveshare EPD-Devices
@ -20,8 +20,7 @@ pub(crate) struct DisplayInterface<SPI, CS, BUSY, DC, RST> {
rst: RST,
}
impl<SPI, CS, BUSY, DC, RST>
DisplayInterface<SPI, CS, BUSY, DC, RST>
impl<SPI, CS, BUSY, DC, RST> DisplayInterface<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8>,
CS: OutputPin,
@ -62,14 +61,18 @@ where
}
/// Basic function for sending [Commands](Command) and the data belonging to it.
///
///
/// TODO: directly use ::write? cs wouldn't needed to be changed twice than
pub(crate) fn cmd_with_data<T: Command>(&mut self, spi: &mut SPI, command: T, data: &[u8]) -> Result<(), SPI::Error> {
self.cmd(spi, command)?;
self.data(spi, data)
pub(crate) fn cmd_with_data<T: Command>(
&mut self,
spi: &mut SPI,
command: T,
data: &[u8],
) -> Result<(), SPI::Error> {
self.cmd(spi, command)?;
self.data(spi, data)
}
/// Basic function for sending the same byte of data (one u8) multiple times over spi
///
/// Enables direct interaction with the device with the help of [command()](ConnectionInterface::command())
@ -89,8 +92,7 @@ where
}
// spi write helper/abstraction function
fn write(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error>
{
fn write(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> {
// activate spi with cs low
self.cs.set_low();
@ -104,7 +106,7 @@ where
} else {
spi.write(data)?;
}
// deativate spi with cs high
self.cs.set_high();
@ -125,7 +127,7 @@ where
/// Most likely there was a mistake with the 2in9 busy connection
/// //TODO: use the #cfg feature to make this compile the right way for the certain types
pub(crate) fn wait_until_idle(&mut self, is_busy_low: bool) {
// TODO: removal of delay. TEST!
// TODO: removal of delay. TEST!
//self.delay_ms(1);
//low: busy, high: idle
while (is_busy_low && self.busy.is_low()) || (!is_busy_low && self.busy.is_high()) {

3
src/lib.rs
View File

@ -67,12 +67,11 @@ pub mod epd2in9;
pub(crate) mod type_a;
pub mod prelude {
pub use traits::{WaveshareDisplay, RefreshLUT};
pub use color::Color;
pub use traits::{RefreshLUT, WaveshareDisplay};
pub use SPI_MODE;
}
extern crate embedded_hal as hal;
use hal::spi::{Mode, Phase, Polarity};

51
src/traits.rs
View File

@ -1,10 +1,9 @@
use color::Color;
use core::marker::Sized;
use hal::{
blocking::{delay::*, spi::Write},
digital::*,
};
use color::Color;
/// All commands need to have this trait which gives the address of the command
/// which needs to be send via SPI with activated CommandsPin (Data/Command Pin in CommandMode)
@ -17,8 +16,8 @@ pub enum RefreshLUT {
/// The "normal" full Lookuptable for the Refresh-Sequence
FULL,
/// The quick LUT where not the full refresh sequence is followed.
/// This might lead to some
QUICK
/// This might lead to some
QUICK,
}
impl Default for RefreshLUT {
@ -37,20 +36,23 @@ where
{
/// This initialises the EPD and powers it up
///
/// This function is already called from
/// This function is already called from
/// - [new()](WaveshareInterface::new())
/// - [`wake_up`]
///
///
///
/// This function calls [reset()](WaveshareInterface::reset()),
/// so you don't need to call reset your self when trying to wake your device up
/// after setting it to sleep.
fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error>;
fn init<DELAY: DelayMs<u8>>(
&mut self,
spi: &mut SPI,
delay: &mut DELAY,
) -> Result<(), SPI::Error>;
}
/// All the functions to interact with the EPDs
///
///
/// This trait includes all public functions to use the EPDS
pub trait WaveshareDisplay<SPI, CS, BUSY, DC, RST>
where
@ -64,10 +66,15 @@ where
///
/// This already initialises the device. That means [init()](WaveshareInterface::init()) isn't needed directly afterwards
fn new<DELAY: DelayMs<u8>>(
spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY,
spi: &mut SPI,
cs: CS,
busy: BUSY,
dc: DC,
rst: RST,
delay: &mut DELAY,
) -> Result<Self, SPI::Error>
where
Self: Sized;
Self: Sized;
/// Let the device enter deep-sleep mode to save power.
///
@ -78,7 +85,11 @@ where
fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error>;
/// Wakes the device up from sleep
fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error>;
fn wake_up<DELAY: DelayMs<u8>>(
&mut self,
spi: &mut SPI,
delay: &mut DELAY,
) -> Result<(), SPI::Error>;
/// Sets the backgroundcolor for various commands like [clear_frame()](WaveshareInterface::clear_frame())
fn set_background_color(&mut self, color: Color);
@ -98,7 +109,7 @@ where
/// Transmits partial data to the SRAM of the EPD
///
/// (x,y) is the top left corner
///
///
/// BUFFER needs to be of size: width / 8 * height !
fn update_partial_frame(
&mut self,
@ -119,11 +130,15 @@ where
/// Trait for using various Waveforms from different LUTs
/// E.g. for partial refreshes
///
/// A full refresh is needed after a certain amount of quick refreshes!
///
///
/// A full refresh is needed after a certain amount of quick refreshes!
///
/// WARNING: Quick Refresh might lead to ghosting-effects/problems with your display. Especially for the 4.2in Display!
///
///
/// If None is used the old value will be loaded on the LUTs once more
fn set_lut(&mut self, spi: &mut SPI, refresh_rate: Option<RefreshLUT>) -> Result<(), SPI::Error>;
fn set_lut(
&mut self,
spi: &mut SPI,
refresh_rate: Option<RefreshLUT>,
) -> Result<(), SPI::Error>;
}

2
src/type_a/constants.rs
View File

@ -11,4 +11,4 @@ pub(crate) const LUT_PARTIAL_UPDATE: [u8; 30] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x13, 0x14, 0x44, 0x12,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
];
];

2
src/type_a/mod.rs
View File

@ -1,2 +1,2 @@
pub(crate) mod command;
pub(crate) mod constants;
pub(crate) mod constants;