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

Merge pull request #21 from caemor/v0.2-cleanup 

Cleanup for v0.2
embedded-hal-1.0
Chris 2018-11-06 18:24:57 +01:00 committed by GitHub
parent 63d1de0417 68cd8006dc
commit 101c8b897b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 652 additions and 526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
.travis.yml
View File

@ -4,6 +4,8 @@
dist: trusty
language: rust
rust:
- stable
- beta
- nightly
sudo: required
@ -12,6 +14,8 @@ sudo: required
matrix:
allow_failures:
# - nightly
# TODO These are all the build jobs. Adjust as necessary. Comment out what you
# don't need
include:
@ -95,15 +99,18 @@ install:
- rustup override set nightly
- rustup target add thumbv7m-none-eabi
- rustup component add clippy-preview
- rustup component add rustfmt-preview
#TODO: remove -A clippy::new_ret_no_self when new version of clippy gets released!
script:
- cargo check
- cargo fmt --all -- --check
- cargo clippy --all-targets --all-features -- -D warnings -A clippy::new_ret_no_self
- cargo check
- cargo test --all-features --release
- cargo doc --all-features --release
- cd examples/embedded_linux_epd4in2 && cargo check && cd ../../
- cd examples/embedded_linux_epd1in54 && cargo check && cd ../../
- cd examples/embedded_linux_epd4in2 && cargo fmt --all -- --check && cargo check && cd ../../
- cd examples/embedded_linux_epd1in54 && cargo fmt --all -- --check && cargo check && cd ../../
- cd examples/embedded_linux_epd2in9 && cargo fmt --all -- --check && cargo check && cd ../../
# - cd examples/stm32f3discovery && cargo check --target thumbv7m-none-eabi && cd ../../
#- cd ../f3_stm32f30x && cargo build

29
CHANGELOG.md Normal file
View File

@ -0,0 +1,29 @@
# Change Log
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](http://keepachangelog.com/)
and this project adheres to [Semantic Versioning](http://semver.org/).
## [Unreleased]
<!-- ## [v0.2.1] - 2018-12-06 -->
## v0.2.0 - 2018-10-30
Initial release with Changelog
### Added
- Uses embedded-graphics now
- Tested and fixed 1.54 inch, 2.9 inch and 4.2 inch display
### Removed
- Old included Graphics Library
### Changed
- Lots of internal changes
- Renamed to `epd-waveshare`
[Unreleased]: https://github.com/Caemor/eink-waveshare-rs/compare/v0.2.0...HEAD
[v0.2.1]: https://github.com/Caemor/eink-waveshare-rs/compare/v0.2.0...v0.2.1

18
Cargo.toml
View File

@ -1,20 +1,20 @@
[package]
authors = ["Christoph Groß <christoph-gross@mailbox.org>"]
authors = ["Christoph Groß <caemor@mailbox.org>"]
categories = ["embedded", "hardware-support", "no-std"]
description = "An embedded-hal based driver for ePaper displays from Waveshare"
documentation = "https://docs.rs/eink-waveshare-rs"
homepage = "https://github.com/Caemor/eink-waveshare-rs"
keywords = ["ePaper", "Display"]
documentation = "https://docs.rs/epd-waveshare"
homepage = "https://github.com/caemor/epd-waveshare"
keywords = ["ePaper", "Display", "epd"]
license = "ISC"
name = "eink_waveshare_rs"
name = "epd-waveshare"
readme = "README.md"
repository = "https://github.com/Caemor/eink-waveshare-rs.git"
version = "0.1.2"
repository = "https://github.com/Caemor/epd_waveshare.git"
version = "0.2.0"
[badges]
# Travis CI: `repository` in format "<user>/<project>" is required.
# `branch` is optional; default is `master`
travis-ci = { repository = "Caemor/eink-waveshare-rs" }
travis-ci = { repository = "caemor/epd-waveshare" }
[features]
@ -24,8 +24,6 @@ graphics = ["embedded-graphics"]
epd1in54 = []
epd2in9 = []
epd4in2 = []
# Activates the fast LUT for EPD4in2
epd4in2_fast_update = []
[dependencies.embedded-graphics]
optional = true

34
README.md
View File

@ -1,9 +1,37 @@
# eink-waveshare-rs [![Build Status](https://travis-ci.com/Caemor/eink-waveshare-rs.svg?branch=master)](https://travis-ci.com/Caemor/eink-waveshare-rs)
[![Build Status](https://travis-ci.com/caemor/epd-waveshare.svg?branch=master)](https://travis-ci.com/caemor/epd-waveshare)
This library contains a driver for E-Paper Modules from Waveshare.
It uses the [embedded graphics](https://crates.io/crates/embedded-graphics) library for the optional graphics support.
## Examples
There are multiple examples in the examples folder. For more infos about the examples see the seperate Readme [there](/examples/Readme.md).
```Rust
// Setup the epd
let mut epd = EPD4in2::new(&mut spi, cs, busy, dc, rst, &mut delay)?;
// Setup the graphics
let mut buffer = Buffer4in2::default();
let mut display = Display::new(epd.width(), epd.height(), &mut buffer.buffer);
// Draw some text
display.draw(
Font12x16::render_str("Hello Rust!")
.with_stroke(Some(Color::Black))
.with_fill(Some(Color::White))
.translate(Coord::new(5, 50))
.into_iter(),
);
// Transfer the frame data to the epd
epd.update_frame(&mut spi, &display.buffer())?;
// Display the frame on the epd
epd.display_frame(&mut spi)?;
```
## (Supported) Devices
| Device (with Link) | Colors | Flexible Display | Partial Refresh | Supported | Tested |
@ -64,9 +92,7 @@ They are also called A and B, but you shouldn't get confused and mix it with the
- [ ] improve the partial drawing/check the timings/timing improvements/....
## Examples
There are multiple examples in the examples folder. For more infos see the seperate Readme [there](/examples/Readme.md):

2
examples/embedded_linux_epd1in54/Cargo.toml
View File

@ -5,7 +5,7 @@ authors = ["Christoph Groß <christoph-gross@mailbox.org>"]
[dependencies]
eink_waveshare_rs = { path = "../../", default-features = false, features = ["epd1in54", "graphics"]}
epd-waveshare = { path = "../../", default-features = false, features = ["epd1in54", "graphics"]}
linux-embedded-hal = "0.2.1"

27
examples/embedded_linux_epd1in54/src/main.rs
View File

@ -1,17 +1,14 @@
// the library for the embedded linux device
extern crate linux_embedded_hal as lin_hal;
use lin_hal::spidev::{self, SpidevOptions};
use lin_hal::{Pin, Spidev};
use lin_hal::sysfs_gpio::Direction;
use lin_hal::Delay;
use lin_hal::{Pin, Spidev};
// the eink library
extern crate eink_waveshare_rs;
use eink_waveshare_rs::{
epd1in54::{
EPD1in54,
Buffer1in54,
},
extern crate epd_waveshare;
use epd_waveshare::{
epd1in54::{Buffer1in54, EPD1in54},
graphics::{Display, DisplayRotation},
prelude::*,
};
@ -19,7 +16,7 @@ use eink_waveshare_rs::{
// Graphics
extern crate embedded_graphics;
use embedded_graphics::coord::Coord;
use embedded_graphics::fonts::{Font6x8};
use embedded_graphics::fonts::Font6x8;
use embedded_graphics::prelude::*;
//use embedded_graphics::primitives::{Circle, Line};
use embedded_graphics::Drawing;
@ -51,7 +48,9 @@ fn run() -> Result<(), std::io::Error> {
let cs_pin = Pin::new(26); //BCM7 CE0
cs_pin.export().expect("cs_pin export");
while !cs_pin.is_exported() {}
cs_pin.set_direction(Direction::Out).expect("cs_pin Direction");
cs_pin
.set_direction(Direction::Out)
.expect("cs_pin Direction");
cs_pin.set_value(1).expect("cs_pin Value set to 1");
// Configure Busy Input Pin
@ -78,7 +77,6 @@ fn run() -> Result<(), std::io::Error> {
// Configure Delay
let mut delay = Delay {};
// Setup of the needed pins is finished here
// Now the "real" usage of the eink-waveshare-rs crate begins
let mut epd = EPD1in54::new(&mut spi, cs_pin, busy, dc, rst, &mut delay)?;
@ -128,12 +126,14 @@ fn run() -> Result<(), std::io::Error> {
// Display updated frame
epd.update_frame(&mut spi, &display.buffer()).unwrap();
epd.display_frame(&mut spi).expect("display frame new graphics");
epd.display_frame(&mut spi)
.expect("display frame new graphics");
delay.delay_ms(5000u16);
// a quickly moving `Hello World!`
display.set_rotation(DisplayRotation::Rotate0);
epd.set_lut_quick(&mut spi).expect("SET LUT QUICK error");
epd.set_lut(&mut spi, Some(RefreshLUT::QUICK))
.expect("SET LUT QUICK error");
let limit = 20;
for i in 0..limit {
println!("Moving Hello World. Loop {} from {}", (i + 1), limit);
@ -150,7 +150,8 @@ fn run() -> Result<(), std::io::Error> {
);
epd.update_frame(&mut spi, &display.buffer()).unwrap();
epd.display_frame(&mut spi).expect("display frame new graphics");
epd.display_frame(&mut spi)
.expect("display frame new graphics");
}
// Set the EPD to sleep

2
examples/embedded_linux_epd2in9/Cargo.toml
View File

@ -5,7 +5,7 @@ authors = ["Christoph Groß <christoph-gross@mailbox.org>"]
[dependencies]
eink_waveshare_rs = { path = "../../", default-features = false, features = ["epd2in9", "graphics"]}
epd-waveshare = { path = "../../", default-features = false, features = ["epd2in9", "graphics"]}
linux-embedded-hal = "0.2.1"

29
examples/embedded_linux_epd2in9/src/main.rs
View File

@ -1,17 +1,14 @@
// the library for the embedded linux device
extern crate linux_embedded_hal as lin_hal;
use lin_hal::spidev::{self, SpidevOptions};
use lin_hal::{Pin, Spidev};
use lin_hal::sysfs_gpio::Direction;
use lin_hal::Delay;
use lin_hal::{Pin, Spidev};
// the eink library
extern crate eink_waveshare_rs;
use eink_waveshare_rs::{
epd2in9::{
EPD2in9,
Buffer2in9,
},
extern crate epd_waveshare;
use epd_waveshare::{
epd2in9::{Buffer2in9, EPD2in9},
graphics::{Display, DisplayRotation},
prelude::*,
};
@ -19,7 +16,7 @@ use eink_waveshare_rs::{
// Graphics
extern crate embedded_graphics;
use embedded_graphics::coord::Coord;
use embedded_graphics::fonts::{Font6x8};
use embedded_graphics::fonts::Font6x8;
use embedded_graphics::prelude::*;
//use embedded_graphics::primitives::{Circle, Line};
use embedded_graphics::Drawing;
@ -52,7 +49,9 @@ fn run() -> Result<(), std::io::Error> {
let cs_pin = Pin::new(26); //BCM7 CE0
cs_pin.export().expect("cs_pin export");
while !cs_pin.is_exported() {}
cs_pin.set_direction(Direction::Out).expect("cs_pin Direction");
cs_pin
.set_direction(Direction::Out)
.expect("cs_pin Direction");
cs_pin.set_value(1).expect("cs_pin Value set to 1");
// Configure Busy Input Pin
@ -79,7 +78,6 @@ fn run() -> Result<(), std::io::Error> {
// Configure Delay
let mut delay = Delay {};
// Setup of the needed pins is finished here
// Now the "real" usage of the eink-waveshare-rs crate begins
let mut epd = EPD2in9::new(&mut spi, cs_pin, busy, dc, rst, &mut delay)?;
@ -92,7 +90,7 @@ fn run() -> Result<(), std::io::Error> {
let mut buffer = Buffer2in9::default();
let mut display = Display::new(epd.width(), epd.height(), &mut buffer.buffer);
epd.update_frame(&mut spi, display.buffer()).unwrap();
epd.display_frame(&mut spi);
epd.display_frame(&mut spi).expect("display frame x03");
display.set_rotation(DisplayRotation::Rotate0);
display.draw(
@ -132,12 +130,14 @@ fn run() -> Result<(), std::io::Error> {
// Display updated frame
epd.update_frame(&mut spi, &display.buffer()).unwrap();
epd.display_frame(&mut spi).expect("display frame new graphics");
epd.display_frame(&mut spi)
.expect("display frame new graphics");
delay.delay_ms(5000u16);
// a quickly moving `Hello World!`
display.set_rotation(DisplayRotation::Rotate0);
epd.set_lut_quick(&mut spi).expect("SET LUT QUICK error");
epd.set_lut(&mut spi, Some(RefreshLUT::QUICK))
.expect("SET LUT QUICK error");
let limit = 20;
for i in 0..limit {
println!("Moving Hello World. Loop {} from {}", (i + 1), limit);
@ -154,7 +154,8 @@ fn run() -> Result<(), std::io::Error> {
);
epd.update_frame(&mut spi, &display.buffer()).unwrap();
epd.display_frame(&mut spi).expect("display frame new graphics");
epd.display_frame(&mut spi)
.expect("display frame new graphics");
}
// Set the EPD to sleep

4
examples/embedded_linux_epd4in2/Cargo.toml
View File

@ -6,8 +6,8 @@ authors = ["Christoph Groß <christoph-gross@mailbox.org>"]
[dependencies]
## The Only difference between this one and the one without default features sizewise seems to be a different .d-file Size (dependencies-file)
#eink_waveshare_rs = { path = "../../"}
eink_waveshare_rs = { path = "../../", default-features = false, features = ["epd4in2", "graphics"]}
#epd_waveshare = { path = "../../"}
epd-waveshare = { path = "../../", default-features = false, features = ["epd4in2", "graphics"]}
linux-embedded-hal = "0.2.1"

35
examples/embedded_linux_epd4in2/src/main.rs
View File

@ -1,17 +1,14 @@
// the library for the embedded linux device
extern crate linux_embedded_hal as lin_hal;
use lin_hal::spidev::{self, SpidevOptions};
use lin_hal::{Pin, Spidev};
use lin_hal::sysfs_gpio::Direction;
use lin_hal::Delay;
use lin_hal::{Pin, Spidev};
// the eink library
extern crate eink_waveshare_rs;
use eink_waveshare_rs::{
epd4in2::{
EPD4in2,
Buffer4in2,
},
extern crate epd_waveshare;
use epd_waveshare::{
epd4in2::{Buffer4in2, EPD4in2},
graphics::{Display, DisplayRotation},
prelude::*,
};
@ -19,7 +16,7 @@ use eink_waveshare_rs::{
// Graphics
extern crate embedded_graphics;
use embedded_graphics::coord::Coord;
use embedded_graphics::fonts::{Font6x8, Font12x16};
use embedded_graphics::fonts::{Font12x16, Font6x8};
use embedded_graphics::prelude::*;
use embedded_graphics::primitives::{Circle, Line};
use embedded_graphics::Drawing;
@ -37,7 +34,6 @@ fn main() {
}
fn run() -> Result<(), std::io::Error> {
// Configure SPI
// Settings are taken from
let mut spi = Spidev::open("/dev/spidev0.0").expect("spidev directory");
@ -75,13 +71,8 @@ fn run() -> Result<(), std::io::Error> {
let mut delay = Delay {};
//TODO: wait for Digital::InputPin
//fixed currently with the HackInputPin, see further above
let mut epd4in2 = EPD4in2::new(&mut spi, cs, busy, dc, rst, &mut delay).expect("eink initalize error");
let mut epd4in2 =
EPD4in2::new(&mut spi, cs, busy, dc, rst, &mut delay).expect("eink initalize error");
println!("Test all the rotations");
let mut buffer = Buffer4in2::default();
@ -122,12 +113,12 @@ fn run() -> Result<(), std::io::Error> {
.into_iter(),
);
epd4in2.update_frame(&mut spi, &display.buffer()).unwrap();
epd4in2.display_frame(&mut spi).expect("display frame new graphics");
epd4in2
.display_frame(&mut spi)
.expect("display frame new graphics");
delay.delay_ms(5000u16);
println!("Now test new graphics with default rotation and some special stuff:");
display.clear_buffer(Color::White);
@ -174,7 +165,6 @@ fn run() -> Result<(), std::io::Error> {
.into_iter(),
);
// a moving `Hello World!`
let limit = 10;
for i in 0..limit {
@ -192,12 +182,13 @@ fn run() -> Result<(), std::io::Error> {
);
epd4in2.update_frame(&mut spi, &display.buffer()).unwrap();
epd4in2.display_frame(&mut spi).expect("display frame new graphics");
epd4in2
.display_frame(&mut spi)
.expect("display frame new graphics");
delay.delay_ms(1_000u16);
}
println!("Finished tests - going to sleep");
epd4in2.sleep(&mut spi)
}

8
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,7 +33,10 @@ 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
),
}
}
@ -60,8 +62,6 @@ impl From<u8> for Color {
}
}
#[cfg(test)]
mod tests {
use super::*;

17
src/epd1in54/graphics.rs
View File

@ -1,4 +1,4 @@
use epd1in54::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
use epd1in54::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
/// Full size buffer for use with the 1in54 EPD
///
@ -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]
@ -107,7 +104,6 @@ mod tests {
for &byte in buffer.iter().skip(1) {
assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
}
}
#[test]
@ -131,6 +127,5 @@ mod tests {
for &byte in buffer.iter().skip(1) {
assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
}
}
}

134
src/epd1in54/mod.rs
View File

@ -3,7 +3,7 @@
//! # Example for the 1.54 in E-Ink Display
//!
//! ```ignore
//! use eink_waveshare_rs::{
//! use epd_waveshare::{
//! epd1in54::{EPD1in54, Buffer1in54},
//! graphics::{Display, DisplayRotation},
//! prelude::*,
@ -45,12 +45,12 @@ use hal::{
use type_a::{
command::Command,
constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}
constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE},
};
use color::Color;
use traits::{WaveshareDisplay};
use traits::{RefreshLUT, WaveshareDisplay};
use interface::DisplayInterface;
@ -62,10 +62,10 @@ pub use epd1in54::graphics::Buffer1in54BlackWhite as Buffer1in54;
pub struct EPD1in54<SPI, CS, BUSY, DC, RST> {
/// SPI
interface: DisplayInterface<SPI, CS, BUSY, DC, RST>,
/// EPD (width, height)
//epd: EPD,
/// Color
background_color: Color,
/// Refresh LUT
refresh: RefreshLUT,
}
impl<SPI, CS, BUSY, DC, RST> EPD1in54<SPI, CS, BUSY, DC, RST>
@ -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:
@ -87,7 +91,7 @@ where
self.interface.cmd_with_data(
spi,
Command::DRIVER_OUTPUT_CONTROL,
&[HEIGHT as u8, (HEIGHT >> 8) as u8, 0x00]
&[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)
self.set_lut(spi, None)
}
}
impl<SPI, CS, BUSY, DC, RST, E> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
@ -133,13 +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,
};
epd.init(spi, delay)?;
@ -147,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(())
@ -164,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
@ -180,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
@ -200,23 +223,31 @@ where
// clear the ram with the background color
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> {
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),
}
}
}
impl<SPI, CS, BUSY, DC, RST> EPD1in54<SPI, CS, BUSY, DC, RST>
@ -225,7 +256,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,53 +286,48 @@ 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,
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
])?;
&[y as u8, (y >> 8) as u8],
)?;
self.wait_until_idle();
Ok(())
}
/// Uses the slower full update
pub fn set_lut(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(spi, &LUT_FULL_UPDATE)
}
/// Uses the quick partial refresh
pub fn set_lut_quick(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE)
}
//TODO: assert length for LUT is exactly 30
//fn set_lut_manual(&mut self, buffer: &[u8]) -> Result<(), E> {
// self.set_lut_helper(buffer)
//}
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)
}
}

9
src/epd2in9/graphics.rs
View File

@ -1,4 +1,4 @@
use epd2in9::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
use epd2in9::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
/// Full size buffer for use with the 2in9 EPD
///
@ -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::*;

138
src/epd2in9/mod.rs
View File

@ -5,7 +5,7 @@
//! # Example for the 2.9 in E-Ink Display
//!
//! ```ignore
//! use eink_waveshare_rs::{
//! use epd_waveshare::{
//! epd2in9::{EPD2in9, Buffer2in9},
//! graphics::{Display, DisplayRotation},
//! prelude::*,
@ -46,7 +46,7 @@ use hal::{
use type_a::{
command::Command,
constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}
constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE},
};
use color::Color;
@ -63,10 +63,10 @@ pub use epd2in9::graphics::Buffer2in9;
pub struct EPD2in9<SPI, CS, BUSY, DC, RST> {
/// SPI
interface: DisplayInterface<SPI, CS, BUSY, DC, RST>,
/// EPD (width, height)
//epd: EPD,
/// Color
background_color: Color,
/// Refresh LUT
refresh: RefreshLUT,
}
impl<SPI, CS, BUSY, DC, RST> EPD2in9<SPI, CS, BUSY, DC, RST>
@ -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)
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,13 +142,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 = EPD2in9 {
interface,
background_color: DEFAULT_BACKGROUND_COLOR,
refresh: RefreshLUT::FULL,
};
epd.init(spi, delay)?;
@ -144,25 +162,29 @@ 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
@ -178,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
@ -198,15 +222,10 @@ where
// clear the ram with the background color
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_with_data(
spi,
Command::WRITE_RAM,
&[color; WIDTH as usize / 8 * HEIGHT as usize]
)
self.interface.cmd(spi, Command::WRITE_RAM)?;
self.interface.data_x_times(spi, color, WIDTH / 8 * HEIGHT)
}
/// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame())
fn set_background_color(&mut self, background_color: Color) {
self.background_color = background_color;
}
@ -214,6 +233,20 @@ where
fn background_color(&self) -> &Color {
&self.background_color
}
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),
}
}
}
impl<SPI, CS, BUSY, DC, RST> EPD2in9<SPI, CS, BUSY, DC, RST>
@ -228,7 +261,7 @@ where
self.interface.wait_until_idle(false);
}
pub(crate) fn use_full_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
fn use_full_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
// choose full frame/ram
self.set_ram_area(spi, 0, 0, WIDTH - 1, HEIGHT - 1)?;
@ -236,7 +269,7 @@ where
self.set_ram_counter(spi, 0, 0)
}
pub(crate) fn set_ram_area(
fn set_ram_area(
&mut self,
spi: &mut SPI,
start_x: u32,
@ -252,49 +285,46 @@ 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, 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,
],
)
}
pub(crate) fn set_ram_counter(&mut self, spi: &mut SPI, x: u32, y: u32) -> Result<(), SPI::Error> {
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(())
}
/// Uses the slower full update
pub fn set_lut(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(spi, &LUT_FULL_UPDATE)
}
/// Uses the quick partial refresh
pub fn set_lut_quick(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE)
}
//TODO: assert length for LUT is exactly 30
//fn set_lut_manual(&mut self, buffer: &[u8]) -> Result<(), E> {
// self.set_lut_helper(buffer)
//}
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::*;

25
src/epd4in2/constants.rs
View File

@ -4,7 +4,7 @@ pub const WIDTH: u32 = 400;
pub const HEIGHT: u32 = 300;
pub const DEFAULT_BACKGROUND_COLOR: Color = Color::White;
#[rustfmt::skip]
pub(crate) const LUT_VCOM0: [u8; 44] = [
0x00, 0x17, 0x00, 0x00, 0x00, 0x02,
0x00, 0x17, 0x17, 0x00, 0x00, 0x02,
@ -15,8 +15,7 @@ pub(crate) const LUT_VCOM0: [u8; 44] = [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[allow(dead_code)]
#[cfg(feature = "epd4in2_fast_update")]
#[rustfmt::skip]
pub(crate) const LUT_VCOM0_QUICK: [u8; 44] = [
0x00, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -27,7 +26,7 @@ pub(crate) const LUT_VCOM0_QUICK: [u8; 44] = [
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[rustfmt::skip]
pub(crate) const LUT_WW: [u8; 42] =[
0x40, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
@ -38,8 +37,7 @@ pub(crate) const LUT_WW: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[allow(dead_code)]
#[cfg(feature = "epd4in2_fast_update")]
#[rustfmt::skip]
pub(crate) const LUT_WW_QUICK: [u8; 42] =[
0xA0, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -50,7 +48,7 @@ pub(crate) const LUT_WW_QUICK: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[rustfmt::skip]
pub(crate) const LUT_BW: [u8; 42] =[
0x40, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
@ -61,8 +59,7 @@ pub(crate) const LUT_BW: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[allow(dead_code)]
#[cfg(feature = "epd4in2_fast_update")]
#[rustfmt::skip]
pub(crate) const LUT_BW_QUICK: [u8; 42] =[
0xA0, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -73,7 +70,7 @@ pub(crate) const LUT_BW_QUICK: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[rustfmt::skip]
pub(crate) const LUT_BB: [u8; 42] =[
0x80, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
@ -84,8 +81,7 @@ pub(crate) const LUT_BB: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[allow(dead_code)]
#[cfg(feature = "epd4in2_fast_update")]
#[rustfmt::skip]
pub(crate) const LUT_BB_QUICK: [u8; 42] =[
0x50, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -96,7 +92,7 @@ pub(crate) const LUT_BB_QUICK: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[rustfmt::skip]
pub(crate) const LUT_WB: [u8; 42] =[
0x80, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
@ -107,8 +103,7 @@ pub(crate) const LUT_WB: [u8; 42] =[
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
#[allow(dead_code)]
#[cfg(feature = "epd4in2_fast_update")]
#[rustfmt::skip]
pub(crate) const LUT_WB_QUICK: [u8; 42] =[
0x50, 0x0E, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

47
src/epd4in2/graphics.rs
View File

@ -1,4 +1,4 @@
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
///
@ -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]
@ -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()
);
}
}
@ -64,7 +64,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()
);
}
}
@ -84,7 +87,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()
);
}
}
@ -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]
@ -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()
);
}
}
}

182
src/epd4in2/mod.rs
View File

@ -51,11 +51,11 @@ use hal::{
digital::*,
};
use traits::{WaveshareDisplay, InternalWiAdditions};
use interface::DisplayInterface;
use traits::{InternalWiAdditions, RefreshLUT, WaveshareDisplay};
//The Lookup Tables for the Display
pub(crate) mod constants; //TODO: Limit to crate::drawing
mod constants;
pub use self::constants::*;
use color::Color;
@ -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> {
@ -74,13 +73,11 @@ pub struct EPD4in2<SPI, CS, BUSY, DC, RST> {
interface: DisplayInterface<SPI, CS, BUSY, DC, RST>,
/// Background Color
color: Color,
/// Refresh LUT
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>,
@ -89,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)?;
@ -113,14 +119,13 @@ where
// 3A 100HZ 29 150Hz 39 200HZ 31 171HZ DEFAULT: 3c 50Hz
self.cmd_with_data(spi, Command::PLL_CONTROL, &[0x3A])?;
self.set_lut(spi)?;
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>,
@ -144,13 +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,
};
epd.init(spi, delay)?;
@ -158,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)?;
@ -174,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> {
@ -182,15 +201,20 @@ 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])?;
//TODO: compare with using a loop instead of the full buffer
self.interface.cmd_with_data(spi, Command::DATA_START_TRANSMISSION_1, &[color_value; WIDTH as usize / 8 * HEIGHT as usize])?;
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(
@ -227,7 +251,7 @@ where
//TODO: handle dtm somehow
let is_dtm1 = false;
if is_dtm1 {
self.command(spi, Command::DATA_START_TRANSMISSION_1)?
self.command(spi, Command::DATA_START_TRANSMISSION_1)? //TODO: check if data_start transmission 1 also needs "old"/background data here
} else {
self.command(spi, Command::DATA_START_TRANSMISSION_2)?
}
@ -237,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)?;
@ -249,28 +271,19 @@ where
fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.send_resolution(spi)?;
//let size = WIDTH as usize / 8 * HEIGHT as usize;
let color_value = self.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_with_data(
spi,
Command::DATA_START_TRANSMISSION_1,
&[color_value; WIDTH as usize / 8 * HEIGHT as usize]
)?;
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);
//TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
self.interface.cmd_with_data(
spi,
Command::DATA_START_TRANSMISSION_2,
&[color_value; WIDTH as usize / 8 * HEIGHT as usize]
)
self.interface
.cmd(spi, Command::DATA_START_TRANSMISSION_2)?;
self.interface
.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)
}
/// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame())
fn set_background_color(&mut self, color: Color) {
self.color = color;
}
@ -286,6 +299,29 @@ where
fn height(&self) -> u32 {
HEIGHT
}
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,
),
}
}
}
impl<SPI, CS, BUSY, DC, RST> EPD4in2<SPI, CS, BUSY, DC, RST>
@ -304,7 +340,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)
}
@ -323,28 +364,6 @@ where
self.send_data(spi, &[h as u8])
}
/// Fill the look-up table for the EPD for a full refresh (slower)
pub fn set_lut(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(spi, &LUT_VCOM0, &LUT_WW, &LUT_BW, &LUT_WB, &LUT_BB)
}
/// Fill the look-up table for a quick refresh (partial refresh)
///
/// WARNING: Might lead to ghosting-effects
#[allow(dead_code)]
#[deprecated(note = "Might lead to ghosting-effects/problems with your display. Use set_lut instead!")]
#[cfg(feature = "epd4in2_fast_update")]
pub fn set_lut_quick(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(
spi,
&LUT_VCOM0_QUICK,
&LUT_WW_QUICK,
&LUT_BW_QUICK,
&LUT_WB_QUICK,
&LUT_BB_QUICK,
)
}
fn set_lut_helper(
&mut self,
spi: &mut SPI,
@ -355,43 +374,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::*;

30
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 {
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;
@ -106,6 +103,8 @@ fn outside_display(x: u32, y: u32, width: u32, height: u32, rotation: DisplayRot
false
}
#[rustfmt::skip]
//returns index position in the u8-slice and the bit-position inside that u8
fn rotation(x: u32, y: u32, width: u32, height: u32, rotation: DisplayRotation) -> (u32, u8) {
match rotation {
DisplayRotation::Rotate0 => (
@ -127,19 +126,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::constants::{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 +152,21 @@ mod tests {
}
}
#[test]
fn rotation_overflow() {
use epd4in2::constants::{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 +178,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 +204,7 @@ mod tests {
#[test]
fn graphics_rotation_90() {
use epd2in9::{DEFAULT_BACKGROUND_COLOR};
use epd2in9::DEFAULT_BACKGROUND_COLOR;
let width = 128;
let height = 296;

23
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,
@ -42,8 +41,6 @@ where
/// Basic function for sending [Commands](Command).
///
/// Enables direct interaction with the device with the help of [data()](DisplayInterface::data())
///
/// //TODO: make public?
pub(crate) fn cmd<T: Command>(&mut self, spi: &mut SPI, command: T) -> Result<(), SPI::Error> {
// low for commands
self.dc.set_low();
@ -55,8 +52,6 @@ where
/// Basic function for sending an array of u8-values of data over spi
///
/// Enables direct interaction with the device with the help of [command()](EPD4in2::command())
///
/// //TODO: make public?
pub(crate) fn data(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> {
// high for data
self.dc.set_high();
@ -67,19 +62,20 @@ where
/// Basic function for sending [Commands](Command) and the data belonging to it.
///
/// //TODO: make public?
/// 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> {
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())
///
/// //TODO: make public?
pub(crate) fn data_x_times(
&mut self,
spi: &mut SPI,
@ -96,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();

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};
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};

61
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)
@ -12,12 +11,19 @@ pub(crate) trait Command {
fn address(self) -> u8;
}
// Trait for using various Waveforms from different LUTs
// E.g. for partial updates
trait LUTSupport<ERR> {
fn set_lut(&mut self) -> Result<(), ERR>;
fn set_lut_quick(&mut self) -> Result<(), ERR>;
fn set_lut_manual(&mut self, data: &[u8]) -> Result<(), ERR>;
/// Seperates the different LUT for the Display Refresh process
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,
}
impl Default for RefreshLUT {
fn default() -> Self {
RefreshLUT::FULL
}
}
pub(crate) trait InternalWiAdditions<SPI, CS, BUSY, DC, RST>
@ -38,10 +44,13 @@ where
/// 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
@ -57,7 +66,12 @@ 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;
@ -71,8 +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);
@ -91,7 +108,9 @@ where
/// Transmits partial data to the SRAM of the EPD
///
/// BUFFER needs to be of size: w / 8 * h !
/// (x,y) is the top left corner
///
/// BUFFER needs to be of size: width / 8 * height !
fn update_partial_frame(
&mut self,
spi: &mut SPI,
@ -108,4 +127,18 @@ where
/// Clears the frame buffer on the EPD with the declared background color
/// The background color can be changed with [`set_background_color`]
fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error>;
/// 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!
///
/// 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>;
}

2
src/type_a/constants.rs
View File

@ -1,4 +1,5 @@
// Original Waveforms from Waveshare
#[rustfmt::skip]
pub(crate) const LUT_FULL_UPDATE: [u8; 30] =[
0x02, 0x02, 0x01, 0x11, 0x12, 0x12, 0x22, 0x22,
0x66, 0x69, 0x69, 0x59, 0x58, 0x99, 0x99, 0x88,
@ -6,6 +7,7 @@ pub(crate) const LUT_FULL_UPDATE: [u8; 30] =[
0x35, 0x51, 0x51, 0x19, 0x01, 0x00
];
#[rustfmt::skip]
pub(crate) const LUT_PARTIAL_UPDATE: [u8; 30] =[
0x10, 0x18, 0x18, 0x08, 0x18, 0x18, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,