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

Merge pull request #12 from Caemor/Cleanup-Interface 

[WIP] Cleanup interface
embedded-hal-1.0
Chris 2018-10-10 20:12:55 +02:00 committed by GitHub
parent e489b7af30 f131636b01
commit 2e2e70c59c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 414 additions and 460 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -9,7 +9,7 @@ use eink_waveshare_rs::{
EPD1in54,
//drawing::{Graphics},
color::Color,
WaveshareInterface,
WaveshareDisplay,
};
use lin_hal::spidev::{self, SpidevOptions};
@ -108,45 +108,45 @@ fn run() -> Result<(), std::io::Error> {
rst.set_value(1).expect("rst Value set to 1");
// Configure Delay
let delay = 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(spi, cs_pin, busy_in, dc, rst, delay)?;
let mut epd = EPD1in54::new(&mut spi, cs_pin, busy_in, dc, rst, &mut delay)?;
// Clear the full screen
epd.clear_frame();
epd.display_frame();
epd.clear_frame(&mut spi)?;
epd.display_frame(&mut spi)?;
// Speeddemo
let small_buffer = [Color::Black.get_byte_value(), 16 as u8 / 8 * 16 as u8];
let number_of_runs = 100;
for i in 0..number_of_runs {
let offset = i * 8 % 150;
epd.update_partial_frame(&small_buffer, 25 + offset, 25 + offset, 16, 16)?;
epd.display_frame()?;
epd.update_partial_frame(&mut spi, &small_buffer, 25 + offset, 25 + offset, 16, 16)?;
epd.display_frame(&mut spi)?;
}
// Clear the full screen
epd.clear_frame();
epd.display_frame();
epd.clear_frame(&mut spi)?;
epd.display_frame(&mut spi)?;
// Draw some squares
let mut small_buffer = [Color::Black.get_byte_value(), 160 as u8 / 8 * 160 as u8];
epd.update_partial_frame(&small_buffer, 20, 20, 160, 160)?;
let mut small_buffer = [Color::Black.get_byte_value(), 160 as u8 / 8 * 160 as u8];
epd.update_partial_frame(&mut spi, &small_buffer, 20, 20, 160, 160)?;
small_buffer = [Color::White.get_byte_value(), 80 as u8 / 8 * 80 as u8];
epd.update_partial_frame(&small_buffer, 60, 60, 80, 80)?;
epd.update_partial_frame(&mut spi, &small_buffer, 60, 60, 80, 80)?;
small_buffer = [Color::Black.get_byte_value(), 8];
epd.update_partial_frame(&small_buffer, 96, 96, 8, 8)?;
epd.update_partial_frame(&mut spi, &small_buffer, 96, 96, 8, 8)?;
// Display updated frame
epd.display_frame()?;
epd.display_frame(&mut spi)?;
// Set the EPD to sleep
epd.sleep()?;
epd.sleep(&mut spi)?;
Ok(())
}

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

@ -9,7 +9,7 @@ use eink_waveshare_rs::{
EPD4in2,
drawing::{Graphics},
color::Color,
WaveshareInterface,
WaveshareDisplay,
};
use lin_hal::spidev::{self, SpidevOptions};
@ -26,7 +26,10 @@ use lin_hal::Delay;
// from https://github.com/rudihorn/max31865/blob/extra_examples/examples/rpi.rs
// (slightly changed now as OutputPin doesn't provide is_high and is_low anymore)
extern crate embedded_hal;
use embedded_hal::digital::{InputPin};
use embedded_hal::{
digital::{InputPin},
};
use embedded_hal::prelude::*;
struct HackInputPin<'a> {
pin: &'a Pin
@ -59,7 +62,7 @@ impl<'a> InputPin for HackInputPin<'a> {
*
*/
fn main() {
fn main() -> Result<(), std::io::Error> {
// Configure SPI
// Settings are taken from
@ -97,7 +100,7 @@ fn main() {
rst.set_direction(Direction::Out).expect("rst Direction");
rst.set_value(1).expect("rst Value set to 1");
let delay = Delay {};
let mut delay = Delay {};
@ -105,7 +108,7 @@ fn main() {
//TODO: wait for Digital::InputPin
//fixed currently with the HackInputPin, see further above
let mut epd4in2 = EPD4in2::new(spi, cs, busy_in, dc, rst, delay).expect("eink inialize error");
let mut epd4in2 = EPD4in2::new(&mut spi, cs, busy_in, dc, rst, &mut delay).expect("eink inialize error");
//let mut buffer = [0u8, epd4in2.get_width() / 8 * epd4in2.get_height()];
let mut buffer = [0u8; 15000];
@ -126,31 +129,31 @@ fn main() {
graphics.draw_vertical_line(200, 50, 200, &Color::Black);
epd4in2.update_frame(graphics.get_buffer()).expect("display and transfer error");
epd4in2.display_frame().expect("Display Frame Error");
epd4in2.update_frame(&mut spi, graphics.get_buffer())?;
epd4in2.display_frame(&mut spi)?;
epd4in2.delay_ms(3000);
delay.delay_ms(3000u16);
epd4in2.clear_frame().expect("clear frame error");
epd4in2.clear_frame(&mut spi)?;
//Test fast updating a bit more
let mut small_buffer = [0x00; 128];
let mut circle_graphics = Graphics::new(32,32, &mut small_buffer);
circle_graphics.draw_circle(16,16, 10, &Color::Black);
epd4in2.update_partial_frame(circle_graphics.get_buffer(), 16,16, 32, 32).expect("Partial Window Error");
epd4in2.display_frame().expect("Display Frame Error");
epd4in2.update_partial_frame(&mut spi, circle_graphics.get_buffer(), 16,16, 32, 32)?;
epd4in2.display_frame(&mut spi)?;
epd4in2.update_partial_frame(circle_graphics.get_buffer(), 128,64, 32, 32).expect("Partial Window Error");
epd4in2.display_frame().expect("Display Frame Error");
epd4in2.update_partial_frame(&mut spi, circle_graphics.get_buffer(), 128,64, 32, 32)?;
epd4in2.display_frame(&mut spi)?;
epd4in2.update_partial_frame(circle_graphics.get_buffer(), 320,24, 32, 32).expect("Partial Window Error");
epd4in2.display_frame().expect("Display Frame Error");
epd4in2.update_partial_frame(&mut spi, circle_graphics.get_buffer(), 320,24, 32, 32)?;
epd4in2.display_frame(&mut spi)?;
epd4in2.update_partial_frame(circle_graphics.get_buffer(), 160,240, 32, 32).expect("Partial Window Error");
epd4in2.display_frame().expect("Display Frame Error");
epd4in2.update_partial_frame(&mut spi, circle_graphics.get_buffer(), 160,240, 32, 32)?;
epd4in2.display_frame(&mut spi)?;
epd4in2.delay_ms(3000);
delay.delay_ms(3000u16);
@ -159,10 +162,10 @@ fn main() {
graphics.draw_string_8x8(16, 16, "hello", &Color::Black);
graphics.draw_char_8x8(250, 250, '#', &Color::Black);
graphics.draw_char_8x8(300, 16, '7', &Color::Black);
epd4in2.update_frame(graphics.get_buffer()).expect("display and transfer error");
epd4in2.display_frame().expect("Display Frame Error");
epd4in2.update_frame(&mut spi, graphics.get_buffer())?;
epd4in2.display_frame(&mut spi)?;
epd4in2.delay_ms(3000);
delay.delay_ms(3000u16);
epd4in2.sleep().expect("sleeping error");
epd4in2.sleep(&mut spi)
}

30
examples/stm32f3discovery/src/main.rs
View File

@ -30,7 +30,7 @@ use eink_waveshare_rs::{
SPI_MODE,
//drawing::{Graphics},
color::Color,
WaveshareInterface,
WaveshareDisplay,
};
@ -109,7 +109,7 @@ fn main() -> ! {
// rst.set_value(1).expect("rst Value set to 1");
// // Configure Delay
let delay = Delay::new(cp.SYST, clocks);
let mut delay = Delay::new(cp.SYST, clocks);
// copied from the l3gd20 example
// The `L3gd20` abstraction exposed by the `f3` crate requires a specific pin configuration to
@ -119,7 +119,7 @@ fn main() -> ! {
let miso = gpioa.pa6.into_af5(&mut gpioa.moder, &mut gpioa.afrl);
let mosi = gpioa.pa7.into_af5(&mut gpioa.moder, &mut gpioa.afrl);
let spi = Spi::spi1(
let mut spi = Spi::spi1(
p.SPI1,
(sck, miso, mosi),
SPI_MODE,
@ -130,42 +130,42 @@ fn main() -> ! {
// // Setup of the needed pins is finished here
// // Now the "real" usage of the eink-waveshare-rs crate begins
let mut epd = EPD1in54::new(spi, cs, busy, dc, rst, delay).unwrap();
let mut epd = EPD1in54::new(&mut spi, cs, busy, dc, rst, &mut delay).unwrap();
// Clear the full screen
epd.clear_frame().unwrap();
epd.display_frame().unwrap();
epd.clear_frame(&mut spi).unwrap();
epd.display_frame(&mut spi).unwrap();
// Speeddemo
let small_buffer = [Color::Black.get_byte_value(), 16 as u8 / 8 * 16 as u8];
let number_of_runs = 100;
for i in 0..number_of_runs {
let offset = i * 8 % 150;
epd.update_partial_frame(&small_buffer, 25 + offset, 25 + offset, 16, 16).unwrap();
epd.display_frame().unwrap();
epd.update_partial_frame(&mut spi, &small_buffer, 25 + offset, 25 + offset, 16, 16).unwrap();
epd.display_frame(&mut spi).unwrap();
}
// Clear the full screen
epd.clear_frame().unwrap();
epd.display_frame().unwrap();
epd.clear_frame(&mut spi).unwrap();
epd.display_frame(&mut spi).unwrap();
// Draw some squares
let mut small_buffer = [Color::Black.get_byte_value(), 160 as u8 / 8 * 160 as u8];
epd.update_partial_frame(&small_buffer, 20, 20, 160, 160).unwrap();
epd.update_partial_frame(&mut spi, &small_buffer, 20, 20, 160, 160).unwrap();
small_buffer = [Color::White.get_byte_value(), 80 as u8 / 8 * 80 as u8];
epd.update_partial_frame(&small_buffer, 60, 60, 80, 80).unwrap();
epd.update_partial_frame(&mut spi, &small_buffer, 60, 60, 80, 80).unwrap();
small_buffer = [Color::Black.get_byte_value(), 8];
epd.update_partial_frame(&small_buffer, 96, 96, 8, 8).unwrap();
epd.update_partial_frame(&mut spi, &small_buffer, 96, 96, 8, 8).unwrap();
// Display updated frame
epd.display_frame().unwrap();
epd.display_frame(&mut spi).unwrap();
// Set the EPD to sleep
epd.sleep().unwrap();
epd.sleep(&mut spi).unwrap();
loop {}
}

158
src/epd1in54/mod.rs
View File

@ -33,80 +33,76 @@ use type_a::{command::Command, LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE};
use color::Color;
use interface::{WaveshareInterface};
use traits::{WaveshareDisplay};
use interface::connection_interface::ConnectionInterface;
use interface::DisplayInterface;
/// EPD1in54 driver
///
pub struct EPD1in54<SPI, CS, BUSY, DC, RST, Delay> {
pub struct EPD1in54<SPI, CS, BUSY, DC, RST> {
/// SPI
interface: ConnectionInterface<SPI, CS, BUSY, DC, RST, Delay>,
interface: DisplayInterface<SPI, CS, BUSY, DC, RST>,
/// EPD (width, height)
//epd: EPD,
/// Color
background_color: Color,
}
impl<SPI, CS, BUSY, DC, RST, Delay, E> EPD1in54<SPI, CS, BUSY, DC, RST, Delay>
impl<SPI, CS, BUSY, DC, RST> EPD1in54<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = E>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
fn init(&mut self) -> Result<(), E> {
self.interface.reset();
fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.interface.reset(delay);
// 3 Databytes:
// A[7:0]
// 0.. A[8]
// 0.. B[2:0]
// Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?)
self.interface.command(Command::DRIVER_OUTPUT_CONTROL)?;
self.interface.data(HEIGHT as u8)?;
self.interface.data((HEIGHT >> 8) as u8)?;
self.interface.data(0x00)?;
self.interface.cmd_with_data(
spi,
Command::DRIVER_OUTPUT_CONTROL,
&[HEIGHT as u8, (HEIGHT >> 8) as u8, 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.command(Command::BOOSTER_SOFT_START_CONTROL)?;
self.interface.data(0xD7)?;
self.interface.data(0xD6)?;
self.interface.data(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.command_with_data(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.command_with_data(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.command_with_data(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.command_with_data(Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
self.interface.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
self.set_lut()
self.set_lut(spi)
}
}
impl<SPI, CS, BUSY, DC, RST, Delay, E> WaveshareInterface<SPI, CS, BUSY, DC, RST, Delay, E>
for EPD1in54<SPI, CS, BUSY, DC, RST, Delay>
impl<SPI, CS, BUSY, DC, RST, E> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
for EPD1in54<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = E>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
fn width(&self) -> u16 {
WIDTH
@ -116,79 +112,80 @@ where
HEIGHT
}
fn new(
spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: Delay,
) -> Result<Self, E> {
let interface = ConnectionInterface::new(spi, cs, busy, dc, rst, delay);
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 mut epd = EPD1in54 {
interface,
background_color: DEFAULT_BACKGROUND_COLOR,
};
epd.init()?;
epd.init(spi, delay)?;
Ok(epd)
}
fn wake_up(&mut self) -> Result<(), E> {
self.init()
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) -> Result<(), E> {
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.command_with_data(Command::DEEP_SLEEP_MODE, &[0x00])?;
self.interface.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
self.wait_until_idle();
Ok(())
}
fn delay_ms(&mut self, delay: u16) {
self.interface.delay_ms(delay)
}
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E> {
self.use_full_frame()?;
self.interface.command_with_data(Command::WRITE_RAM, buffer)
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)
}
//TODO: update description: last 3 bits will be ignored for width and x_pos
fn update_partial_frame(
&mut self,
spi: &mut SPI,
buffer: &[u8],
x: u16,
y: u16,
width: u16,
height: u16,
) -> Result<(), E> {
self.set_ram_area(x, y, x + width, y + height)?;
self.set_ram_counter(x, y)?;
) -> Result<(), SPI::Error> {
self.set_ram_area(spi, x, y, x + width, y + height)?;
self.set_ram_counter(spi, x, y)?;
self.interface.command_with_data(Command::WRITE_RAM, buffer)
self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
}
fn display_frame(&mut self) -> Result<(), E> {
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.command_with_data(Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface.command(Command::MASTER_ACTIVATION)?;
self.interface.cmd(spi, Command::MASTER_ACTIVATION)?;
// MASTER Activation should not be interupted to avoid currption of panel images
// therefore a terminate command is send
self.interface.command(Command::NOP)
self.interface.cmd(spi, Command::NOP)
}
fn clear_frame(&mut self) -> Result<(), E> {
self.use_full_frame()?;
fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.use_full_frame(spi)?;
// clear the ram with the background color
let color = self.background_color.get_byte_value();
self.interface.command(Command::WRITE_RAM)?;
self.interface.data_x_times(color, WIDTH / 8 * HEIGHT)
//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]
)
}
@ -202,58 +199,61 @@ where
}
}
impl<SPI, CS, BUSY, DC, RST, D, E> EPD1in54<SPI, CS, BUSY, DC, RST, D>
impl<SPI, CS, BUSY, DC, RST> EPD1in54<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = E>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
D: DelayUs<u16> + DelayMs<u16>,
RST: OutputPin
{
fn wait_until_idle(&mut self) {
self.interface.wait_until_idle(false);
}
pub(crate) fn use_full_frame(&mut self) -> Result<(), E> {
pub(crate) fn use_full_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
// choose full frame/ram
self.set_ram_area(0, 0, WIDTH - 1, HEIGHT - 1)?;
self.set_ram_area(spi, 0, 0, WIDTH - 1, HEIGHT - 1)?;
// start from the beginning
self.set_ram_counter(0, 0)
self.set_ram_counter(spi, 0, 0)
}
pub(crate) fn set_ram_area(
&mut self,
&mut self,
spi: &mut SPI,
start_x: u16,
start_y: u16,
end_x: u16,
end_y: u16,
) -> Result<(), E> {
) -> Result<(), SPI::Error> {
assert!(start_x < end_x);
assert!(start_y < end_y);
// x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant
self.interface.command(Command::SET_RAM_X_ADDRESS_START_END_POSITION)?;
self.interface.data((start_x >> 3) as u8)?;
self.interface.data((end_x >> 3) as u8)?;
self.interface.cmd_with_data(
spi,
Command::SET_RAM_X_ADDRESS_START_END_POSITION,
&[(start_x >> 3) as u8, (end_x >> 3) as u8]
)?;
// 2 Databytes: A[7:0] & 0..A[8] for each - start and end
self.interface.command(Command::SET_RAM_Y_ADDRESS_START_END_POSITION)?;
self.interface.data(start_y as u8)?;
self.interface.data((start_y >> 8) as u8)?;
self.interface.data(end_y as u8)?;
self.interface.data((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, x: u16, y: u16) -> Result<(), E> {
pub(crate) fn set_ram_counter(&mut self, spi: &mut SPI, x: u16, y: u16) -> 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.command_with_data(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.command_with_data(
self.interface.cmd_with_data(
spi,
Command::SET_RAM_Y_ADDRESS_COUNTER,
&[
y as u8,
@ -265,13 +265,13 @@ where
}
/// Uses the slower full update
pub fn set_lut(&mut self) -> Result<(), E> {
self.set_lut_helper(&LUT_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) -> Result<(), E> {
self.set_lut_helper(&LUT_PARTIAL_UPDATE)
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
@ -279,9 +279,9 @@ where
// self.set_lut_helper(buffer)
//}
fn set_lut_helper(&mut self, buffer: &[u8]) -> Result<(), E> {
fn set_lut_helper(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
assert!(buffer.len() == 30);
self.interface.command_with_data(Command::WRITE_LUT_REGISTER, buffer)
self.interface.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
}
}

163
src/epd2in9/mod.rs
View File

@ -32,86 +32,72 @@ use type_a::{command::Command, LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE};
use color::Color;
use interface::*;
use traits::*;
use interface::connection_interface::ConnectionInterface;
use interface::DisplayInterface;
/// EPD2in9 driver
///
pub struct EPD2in9<SPI, CS, BUSY, DC, RST, Delay> {
pub struct EPD2in9<SPI, CS, BUSY, DC, RST> {
/// SPI
interface: ConnectionInterface<SPI, CS, BUSY, DC, RST, Delay>,
interface: DisplayInterface<SPI, CS, BUSY, DC, RST>,
/// EPD (width, height)
//epd: EPD,
/// Color
background_color: Color,
}
impl<SPI, CS, BUSY, DC, RST, Delay, E> EPD2in9<SPI, CS, BUSY, DC, RST, Delay>
impl<SPI, CS, BUSY, DC, RST> EPD2in9<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = E>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
fn init(&mut self) -> Result<(), E> {
self.interface.reset();
fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.interface.reset(delay);
// 3 Databytes:
// A[7:0]
// 0.. A[8]
// 0.. B[2:0]
// Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?)
self.interface.command(Command::DRIVER_OUTPUT_CONTROL)?;
self.interface.data(HEIGHT as u8)?;
self.interface.data((HEIGHT >> 8) as u8)?;
self.interface.data(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.command(Command::BOOSTER_SOFT_START_CONTROL)?;
self.interface.data(0xD7)?;
self.interface.data(0xD6)?;
self.interface.data(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.command(Command::WRITE_VCOM_REGISTER)?;
self.interface.data(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.command(Command::SET_DUMMY_LINE_PERIOD)?;
self.interface.data(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.command(Command::SET_GATE_LINE_WIDTH)?;
self.interface.data(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.command(Command::DATA_ENTRY_MODE_SETTING)?;
self.interface.data(0x03)?;
self.interface.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
self.set_lut()
self.set_lut(spi)
}
}
impl<SPI, CS, BUSY, DC, RST, Delay, ERR>
WaveshareInterface<SPI, CS, BUSY, DC, RST, Delay, ERR>
for EPD2in9<SPI, CS, BUSY, DC, RST, Delay>
impl<SPI, CS, BUSY, DC, RST>
WaveshareDisplay<SPI, CS, BUSY, DC, RST>
for EPD2in9<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = ERR>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
fn width(&self) -> u16 {
WIDTH
@ -121,80 +107,81 @@ where
HEIGHT
}
fn new(
spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: Delay,
) -> Result<Self, ERR> {
let interface = ConnectionInterface::new(spi, cs, busy, dc, rst, delay);
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 mut epd = EPD2in9 {
interface,
background_color: DEFAULT_BACKGROUND_COLOR,
};
epd.init()?;
epd.init(spi, delay)?;
Ok(epd)
}
fn sleep(&mut self) -> Result<(), ERR> {
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.command_with_data(Command::DEEP_SLEEP_MODE, &[0x00])?;
self.interface.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
self.wait_until_idle();
Ok(())
}
fn wake_up(&mut self) -> Result<(), ERR> {
self.init()
fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.init(spi, delay)
}
fn delay_ms(&mut self, delay: u16) {
self.interface.delay_ms(delay)
}
fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
self.use_full_frame(spi)?;
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), ERR> {
self.use_full_frame()?;
self.interface.command_with_data(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: u16,
y: u16,
width: u16,
height: u16,
) -> Result<(), ERR> {
self.set_ram_area(x, y, x + width, y + height)?;
self.set_ram_counter(x, y)?;
) -> Result<(), SPI::Error> {
self.set_ram_area(spi, x, y, x + width, y + height)?;
self.set_ram_counter(spi, x, y)?;
self.interface.command_with_data(Command::WRITE_RAM, buffer)
self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
}
fn display_frame(&mut self) -> Result<(), ERR> {
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.command_with_data(Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface.command(Command::MASTER_ACTIVATION)?;
self.interface.cmd(spi, Command::MASTER_ACTIVATION)?;
// MASTER Activation should not be interupted to avoid currption of panel images
// therefore a terminate command is send
self.interface.command(Command::NOP)
self.interface.cmd(spi, Command::NOP)
}
fn clear_frame(&mut self) -> Result<(), ERR> {
self.use_full_frame()?;
fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.use_full_frame(spi)?;
// clear the ram with the background color
let color = self.background_color.get_byte_value();
self.interface.command(Command::WRITE_RAM)?;
self.interface.data_x_times(color, WIDTH / 8 * HEIGHT)
//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]
)
}
/// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame())
@ -207,73 +194,71 @@ where
}
}
impl<SPI, CS, BUSY, DC, RST, D, E> EPD2in9<SPI, CS, BUSY, DC, RST, D>
impl<SPI, CS, BUSY, DC, RST> EPD2in9<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = E>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
D: DelayUs<u16> + DelayMs<u16>,
{
fn wait_until_idle(&mut self) {
self.interface.wait_until_idle(false);
}
pub(crate) fn use_full_frame(&mut self) -> Result<(), E> {
pub(crate) fn use_full_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
// choose full frame/ram
self.set_ram_area(0, 0, WIDTH - 1, HEIGHT - 1)?;
self.set_ram_area(spi, 0, 0, WIDTH - 1, HEIGHT - 1)?;
// start from the beginning
self.set_ram_counter(0, 0)
self.set_ram_counter(spi, 0, 0)
}
pub(crate) fn set_ram_area(
&mut self,
&mut self,
spi: &mut SPI,
start_x: u16,
start_y: u16,
end_x: u16,
end_y: u16,
) -> Result<(), E> {
) -> Result<(), SPI::Error> {
assert!(start_x < end_x);
assert!(start_y < end_y);
// x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant
self.interface.command(Command::SET_RAM_X_ADDRESS_START_END_POSITION)?;
self.interface.data((start_x >> 3) as u8)?;
self.interface.data((end_x >> 3) as u8)?;
self.interface.cmd_with_data(
spi,
Command::SET_RAM_X_ADDRESS_START_END_POSITION,
&[(start_x >> 3) as u8, (end_x >> 3) as u8]
)?;
// 2 Databytes: A[7:0] & 0..A[8] for each - start and end
self.interface.command(Command::SET_RAM_Y_ADDRESS_START_END_POSITION)?;
self.interface.data(start_y as u8)?;
self.interface.data((start_y >> 8) as u8)?;
self.interface.data(end_y as u8)?;
self.interface.data((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, x: u16, y: u16) -> Result<(), E> {
pub(crate) fn set_ram_counter(&mut self, spi: &mut SPI, x: u16, y: u16) -> 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.command_with_data(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.command(Command::SET_RAM_Y_ADDRESS_COUNTER)?;
self.interface.data(y as u8)?;
self.interface.data((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) -> Result<(), E> {
self.set_lut_helper(&LUT_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) -> Result<(), E> {
self.set_lut_helper(&LUT_PARTIAL_UPDATE)
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
@ -281,9 +266,9 @@ where
// self.set_lut_helper(buffer)
//}
fn set_lut_helper(&mut self, buffer: &[u8]) -> Result<(), E> {
fn set_lut_helper(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
assert!(buffer.len() == 30);
self.interface.command_with_data(Command::WRITE_LUT_REGISTER, buffer)
self.interface.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
}
}

17
src/epd4in2/command.rs
View File

@ -1,5 +1,5 @@
//! SPI Commands for the Waveshare 4.2" E-Ink Display
use interface;
use traits;
/// EPD4IN2 commands
///
/// Should rarely (never?) be needed directly.
@ -12,8 +12,18 @@ use interface;
#[derive(Copy, Clone)]
pub(crate) enum Command {
/// Set Resolution, LUT selection, BWR pixels, gate scan direction, source shift direction, booster switch, soft reset
/// One Byte of Data:
/// 0x0F Red Mode, LUT from OTP
/// 0x1F B/W Mode, LUT from OTP
/// 0x2F Red Mode, LUT set by registers
/// 0x3F B/W Mode, LUT set by registers
PANEL_SETTING = 0x00,
/// selecting internal and external power
/// self.send_data(0x03)?; //VDS_EN, VDG_EN
/// self.send_data(0x00)?; //VCOM_HV, VGHL_LV[1], VGHL_LV[0]
/// self.send_data(0x2b)?; //VDH
/// self.send_data(0x2b)?; //VDL
/// self.send_data(0xff)?; //VDHR
POWER_SETTING = 0x01,
/// After the Power Off command, the driver will power off following the Power Off Sequence. This command will turn off charge
/// pump, T-con, source driver, gate driver, VCOM, and temperature sensor, but register data will be kept until VDD becomes OFF.
@ -26,6 +36,7 @@ pub(crate) enum Command {
/// This command enables the internal bandgap, which will be cleared by the next POF.
POWER_ON_MEASURE = 0x05,
/// Starting data transmission
/// 3-times: self.send_data(0x17)?; //07 0f 17 1f 27 2F 37 2f
BOOSTER_SOFT_START = 0x06,
/// After this command is transmitted, the chip would enter the deep-sleep mode to save power.
///
@ -144,7 +155,7 @@ pub(crate) enum Command {
POWER_SAVING = 0xE3,
}
impl interface::Command for Command {
impl traits::Command for Command {
/// Returns the address of the command
fn address(self) -> u8 {
self as u8
@ -154,7 +165,7 @@ impl interface::Command for Command {
#[cfg(test)]
mod tests {
use super::*;
use interface::Command as CommandTrait;
use traits::Command as CommandTrait;
#[test]
fn command_addr() {

260
src/epd4in2/mod.rs
View File

@ -51,7 +51,8 @@ use hal::{
digital::*,
};
use interface::{connection_interface::ConnectionInterface, WaveshareInterface, InternalWiAdditions};
use traits::{WaveshareDisplay, InternalWiAdditions};
use interface::DisplayInterface;
//The Lookup Tables for the Display
mod constants;
@ -64,9 +65,9 @@ use self::command::Command;
/// EPD4in2 driver
///
pub struct EPD4in2<SPI, CS, BUSY, DC, RST, D> {
pub struct EPD4in2<SPI, CS, BUSY, DC, RST> {
/// Connection Interface
interface: ConnectionInterface<SPI, CS, BUSY, DC, RST, D>,
interface: DisplayInterface<SPI, CS, BUSY, DC, RST>,
/// Background Color
color: Color,
}
@ -74,75 +75,54 @@ pub struct EPD4in2<SPI, CS, BUSY, DC, RST, D> {
impl<SPI, CS, BUSY, DC, RST, Delay, ERR>
InternalWiAdditions<SPI, CS, BUSY, DC, RST, Delay, ERR>
for EPD4in2<SPI, CS, BUSY, DC, RST, Delay>
impl<SPI, CS, BUSY, DC, RST>
InternalWiAdditions<SPI, CS, BUSY, DC, RST>
for EPD4in2<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = ERR>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
fn init(&mut self) -> Result<(), ERR> {
fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
// reset the device
self.interface.reset();
self.interface.reset(delay);
// set the power settings
self.command(Command::POWER_SETTING)?;
self.send_data(0x03)?; //VDS_EN, VDG_EN
self.send_data(0x00)?; //VCOM_HV, VGHL_LV[1], VGHL_LV[0]
self.send_data(0x2b)?; //VDH
self.send_data(0x2b)?; //VDL
self.send_data(0xff)?; //VDHR
self.interface.cmd_with_data(spi, Command::POWER_SETTING, &[0x03, 0x00, 0x2b, 0x2b, 0xff])?;
// start the booster
self.command(Command::BOOSTER_SOFT_START)?;
for _ in 0..3 {
self.send_data(0x17)?; //07 0f 17 1f 27 2F 37 2f
}
self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START, &[0x17, 0x17, 0x17])?;
// power on
self.command(Command::POWER_ON)?;
self.command(spi, Command::POWER_ON)?;
self.wait_until_idle();
// set the panel settings
self.command(Command::PANEL_SETTING)?;
// 0x0F Red Mode, LUT from OTP
// 0x1F B/W Mode, LUT from OTP
// 0x2F Red Mode, LUT set by registers
// 0x3F B/W Mode, LUT set by registers
self.send_data(0x3F)?;
// the values used by waveshare before for the panel settings
// instead of our one liner:
// SendData(0xbf); // KW-BF KWR-AF BWROTP 0f
// SendData(0x0b);
self.cmd_with_data(spi, Command::PANEL_SETTING, &[0x3F])?;
// Set Frequency, 200 Hz didn't work on my board
// 150Hz and 171Hz wasn't tested yet
// TODO: Test these other frequencies
// 3A 100HZ 29 150Hz 39 200HZ 31 171HZ DEFAULT: 3c 50Hz
self.command(Command::PLL_CONTROL)?;
self.send_data(0x3A)?;
self.set_lut()?;
self.cmd_with_data(spi, Command::PLL_CONTROL, &[0x3A])?;
self.set_lut(spi)?;
Ok(())
}
}
impl<SPI, CS, BUSY, DC, RST, Delay, ERR>
WaveshareInterface<SPI, CS, BUSY, DC, RST, Delay, ERR>
for EPD4in2<SPI, CS, BUSY, DC, RST, Delay>
impl<SPI, CS, BUSY, DC, RST>
WaveshareDisplay<SPI, CS, BUSY, DC, RST>
for EPD4in2<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = ERR>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
/// Creates a new driver from a SPI peripheral, CS Pin, Busy InputPin, DC
///
@ -159,8 +139,8 @@ where
///
/// epd4in2.sleep();
/// ```
fn new(spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: Delay) -> Result<Self, ERR> {
let interface = ConnectionInterface::new(spi, cs, busy, dc, rst, delay);
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 {
@ -168,118 +148,135 @@ where
color,
};
epd.init()?;
epd.init(spi, delay)?;
Ok(epd)
}
fn wake_up(&mut self) -> Result<(), ERR> {
self.init()
fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.init(spi, delay)
}
//TODO: is such a long delay really needed inbetween?
fn sleep(&mut self) -> Result<(), ERR> {
self.interface.command_with_data(Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x17])?; //border floating
self.command(Command::VCM_DC_SETTING)?; // VCOM to 0V
self.command(Command::PANEL_SETTING)?;
self.delay_ms(100);
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.command(spi, Command::VCM_DC_SETTING)?; // VCOM to 0V
self.command(spi, Command::PANEL_SETTING)?;
self.command(Command::POWER_SETTING)?; //VG&VS to 0V fast
//TODO: Removal of delay. TEST!
//self.delay_ms(100);
self.command(spi, Command::POWER_SETTING)?; //VG&VS to 0V fast
for _ in 0..4 {
self.send_data(0x00)?;
self.send_data(spi, &[0x00])?;
}
self.delay_ms(100);
self.command(Command::POWER_OFF)?;
//TODO: Removal of delay. TEST!
//self.delay_ms(100);
self.command(spi, Command::POWER_OFF)?;
self.wait_until_idle();
self.interface.command_with_data(Command::DEEP_SLEEP, &[0xA5])
self.interface.cmd_with_data(spi, Command::DEEP_SLEEP, &[0xA5])
}
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), ERR> {
fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
let color_value = self.color.get_byte_value();
self.send_resolution()?;
self.send_resolution(spi)?;
self.interface.command_with_data(Command::VCM_DC_SETTING, &[0x12])?;
self.interface.cmd_with_data(spi, Command::VCM_DC_SETTING, &[0x12])?;
//TODO: this was a send_command instead of a send_data. check if it's alright and doing what it should do (setting the default values)
//self.send_command_u8(0x97)?; //VBDF 17|D7 VBDW 97 VBDB 57 VBDF F7 VBDW 77 VBDB 37 VBDR B7
self.interface.command_with_data(Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x97])?;
self.interface.cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x97])?;
self.command(Command::DATA_START_TRANSMISSION_1)?;
self.interface.data_x_times(color_value, buffer.len() as u16)?;
self.command(spi, Command::DATA_START_TRANSMISSION_1)?;
for _ in 0..buffer.len() {
self.send_data(spi, &[color_value])?;
}
self.delay_ms(2);
//TODO: Removal of delay. TEST!
//self.delay_ms(2);
self.interface.command_with_data(Command::DATA_START_TRANSMISSION_2, buffer)
self.interface.cmd_with_data(spi, Command::DATA_START_TRANSMISSION_2, buffer)
}
fn update_partial_frame(
&mut self,
&mut self,
spi: &mut SPI,
buffer: &[u8],
x: u16,
y: u16,
width: u16,
height: u16,
) -> Result<(), ERR> {
) -> Result<(), SPI::Error> {
if buffer.len() as u16 != width / 8 * height {
//TODO: panic!! or sth like that
//return Err("Wrong buffersize");
}
self.command(Command::PARTIAL_IN)?;
self.command(Command::PARTIAL_WINDOW)?;
self.send_data((x >> 8) as u8)?;
self.command(spi, Command::PARTIAL_IN)?;
self.command(spi, Command::PARTIAL_WINDOW)?;
self.send_data(spi, &[(x >> 8) as u8])?;
let tmp = x & 0xf8;
self.send_data(tmp as u8)?; // x should be the multiple of 8, the last 3 bit will always be ignored
self.send_data(spi, &[tmp as u8])?; // x should be the multiple of 8, the last 3 bit will always be ignored
let tmp = tmp + width - 1;
self.send_data((tmp >> 8) as u8)?;
self.send_data((tmp | 0x07) as u8)?;
self.send_data(spi, &[(tmp >> 8) as u8])?;
self.send_data(spi, &[(tmp | 0x07) as u8])?;
self.send_data((y >> 8) as u8)?;
self.send_data(y as u8)?;
self.send_data(spi, &[(y >> 8) as u8])?;
self.send_data(spi, &[y as u8])?;
self.send_data(((y + height - 1) >> 8) as u8)?;
self.send_data((y + height - 1) as u8)?;
self.send_data(spi, &[((y + height - 1) >> 8) as u8])?;
self.send_data(spi, &[(y + height - 1) as u8])?;
self.send_data(0x01)?; // Gates scan both inside and outside of the partial window. (default)
self.send_data(spi, &[0x01])?; // Gates scan both inside and outside of the partial window. (default)
//TODO: handle dtm somehow
let is_dtm1 = false;
if is_dtm1 {
self.command(Command::DATA_START_TRANSMISSION_1)?
self.command(spi, Command::DATA_START_TRANSMISSION_1)?
} else {
self.command(Command::DATA_START_TRANSMISSION_2)?
self.command(spi, Command::DATA_START_TRANSMISSION_2)?
}
self.send_multiple_data(buffer)?;
self.send_data(spi, buffer)?;
self.command(Command::PARTIAL_OUT)
self.command(spi, Command::PARTIAL_OUT)
}
fn display_frame(&mut self) -> Result<(), ERR> {
self.command(Command::DISPLAY_REFRESH)?;
fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.command(spi, Command::DISPLAY_REFRESH)?;
self.wait_until_idle();
Ok(())
}
fn clear_frame(&mut self) -> Result<(), ERR> {
self.send_resolution()?;
fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.send_resolution(spi)?;
let size = WIDTH / 8 * HEIGHT;
//let size = WIDTH as usize / 8 * HEIGHT as usize;
let color_value = self.color.get_byte_value();
self.command(Command::DATA_START_TRANSMISSION_1)?;
self.interface.data_x_times(color_value, size)?;
//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.delay_ms(2);
//TODO: Removal of delay. TEST!
//self.delay_ms(2);
self.command(Command::DATA_START_TRANSMISSION_2)?;
self.interface.data_x_times(color_value, size)
//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]
)
}
/// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame())
@ -298,53 +295,47 @@ where
fn height(&self) -> u16 {
HEIGHT
}
fn delay_ms(&mut self, delay: u16) {
self.interface.delay_ms(delay)
}
}
impl<SPI, CS, BUSY, DC, RST, D, ERR> EPD4in2<SPI, CS, BUSY, DC, RST, D>
impl<SPI, CS, BUSY, DC, RST> EPD4in2<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = ERR>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
D: DelayUs<u16> + DelayMs<u16>,
{
fn command(&mut self, command: Command) -> Result<(), ERR> {
self.interface.command(command)
fn command(&mut self, spi: &mut SPI, command: Command) -> Result<(), SPI::Error> {
self.interface.cmd(spi, command)
}
fn send_data(&mut self, val: u8) -> Result<(), ERR> {
self.interface.data(val)
fn send_data(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> {
self.interface.data(spi, data)
}
fn send_multiple_data(&mut self, data: &[u8]) -> Result<(), ERR> {
self.interface.multiple_data(data)
fn cmd_with_data(&mut self, spi: &mut SPI, command: Command, data: &[u8]) -> Result<(), SPI::Error> {
self.interface.cmd_with_data(spi, command, data)
}
fn wait_until_idle(&mut self) {
self.interface.wait_until_idle(true)
}
fn send_resolution(&mut self) -> Result<(), ERR> {
fn send_resolution(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
let w = self.width();
let h = self.height();
self.command(Command::RESOLUTION_SETTING)?;
self.send_data((w >> 8) as u8)?;
self.send_data(w as u8)?;
self.send_data((h >> 8) as u8)?;
self.send_data(h as u8)
self.command(spi, Command::RESOLUTION_SETTING)?;
self.send_data(spi, &[(w >> 8) as u8])?;
self.send_data(spi, &[w as u8])?;
self.send_data(spi, &[(h >> 8) as u8])?;
self.send_data(spi, &[h as u8])
}
/// Fill the look-up table for the EPD
//TODO: make public?
fn set_lut(&mut self) -> Result<(), ERR> {
self.set_lut_helper(&LUT_VCOM0, &LUT_WW, &LUT_BW, &LUT_WB, &LUT_BB)
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 display (partial refresh)
@ -352,8 +343,9 @@ where
/// Is automatically done by [EPD4in2::display_frame_quick()](EPD4in2::display_frame_quick())
/// //TODO: make public?
#[cfg(feature = "epd4in2_fast_update")]
fn set_lut_quick(&mut self) -> Result<(), ERR> {
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,
@ -364,33 +356,47 @@ where
fn set_lut_helper(
&mut self,
spi: &mut SPI,
lut_vcom: &[u8],
lut_ww: &[u8],
lut_bw: &[u8],
lut_wb: &[u8],
lut_bb: &[u8],
) -> Result<(), ERR> {
) -> Result<(), SPI::Error> {
// LUT VCOM
self.command(Command::LUT_FOR_VCOM)?;
self.send_multiple_data(lut_vcom)?;
self.cmd_with_data(
spi,
Command::LUT_FOR_VCOM,
lut_vcom
)?;
// LUT WHITE to WHITE
self.command(Command::LUT_WHITE_TO_WHITE)?;
self.send_multiple_data(lut_ww)?;
self.cmd_with_data(
spi,
Command::LUT_WHITE_TO_WHITE,
lut_ww
)?;
// LUT BLACK to WHITE
self.command(Command::LUT_BLACK_TO_WHITE)?;
self.send_multiple_data(lut_bw)?;
self.cmd_with_data(
spi,
Command::LUT_BLACK_TO_WHITE,
lut_bw
)?;
// LUT WHITE to BLACK
self.command(Command::LUT_WHITE_TO_BLACK)?;
self.send_multiple_data(lut_wb)?;
self.cmd_with_data(
spi,
Command::LUT_WHITE_TO_BLACK,
lut_wb,
)?;
// LUT BLACK to BLACK
self.command(Command::LUT_BLACK_TO_BLACK)?;
self.send_multiple_data(lut_bb)?;
Ok(())
self.cmd_with_data(
spi,
Command::LUT_BLACK_TO_BLACK,
lut_bb,
)
}
}

120
src/interface/connection_interface.rs → src/interface.rs
View File

@ -2,14 +2,14 @@ use hal::{
blocking::{delay::*, spi::Write},
digital::*,
};
use interface::Command;
use core::marker::PhantomData;
use traits::Command;
/// The Connection Interface of all (?) Waveshare EPD-Devices
///
pub(crate) struct ConnectionInterface<SPI, CS, BUSY, DC, RST, D> {
pub(crate) struct DisplayInterface<SPI, CS, BUSY, DC, RST> {
/// SPI
spi: SPI,
_spi: PhantomData<SPI>,
/// CS for SPI
cs: CS,
/// Low for busy, Wait until display is ready!
@ -18,85 +18,38 @@ pub(crate) struct ConnectionInterface<SPI, CS, BUSY, DC, RST, D> {
dc: DC,
/// Pin for Reseting
rst: RST,
/// The concrete Delay implementation
delay: D,
}
impl<SPI, CS, BUSY, DC, RST, Delay, ERR>
ConnectionInterface<SPI, CS, BUSY, DC, RST, Delay>
impl<SPI, CS, BUSY, DC, RST>
DisplayInterface<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8, Error = ERR>,
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
pub fn new(spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: Delay) -> Self {
ConnectionInterface {
spi,
pub fn new(cs: CS, busy: BUSY, dc: DC, rst: RST) -> Self {
DisplayInterface {
_spi: PhantomData::default(),
cs,
busy,
dc,
rst,
delay,
}
}
/// Basic function for sending [Commands](Command).
///
/// Enables direct interaction with the device with the help of [data()](ConnectionInterface::data())
/// Enables direct interaction with the device with the help of [data()](DisplayInterface::data())
///
/// //TODO: make public?
pub(crate) fn command<T: Command>(&mut self, command: T) -> Result<(), ERR> {
pub(crate) fn cmd<T: Command>(&mut self, spi: &mut SPI, command: T) -> Result<(), SPI::Error> {
// low for commands
self.dc.set_low();
// Transfer the command over spi
self.with_cs(|epd| epd.spi.write(&[command.address()]))
}
/// Basic function for sending a single u8 of data over spi
///
/// Enables direct interaction with the device with the help of [Ecommand()](ConnectionInterface::command())
///
/// //TODO: make public?
pub(crate) fn data(&mut self, val: u8) -> Result<(), ERR> {
// high for data
self.dc.set_high();
// Transfer data (u8) over spi
self.with_cs(|epd| epd.spi.write(&[val]))
}
/// Basic function for sending [Commands](Command) and the data belonging to it.
///
/// //TODO: make public?
pub(crate) fn command_with_data<T: Command>(&mut self, command: T, data: &[u8]) -> Result<(), ERR> {
self.command(command)?;
self.multiple_data(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,
val: u8,
repetitions: u16,
) -> Result<(), ERR> {
// high for data
self.dc.set_high();
// Transfer data (u8) over spi
self.with_cs(|epd| {
for _ in 0..repetitions {
epd.spi.write(&[val])?;
}
Ok(())
})
self.write(spi, &[command.address()])
}
/// Basic function for sending an array of u8-values of data over spi
@ -104,27 +57,34 @@ where
/// Enables direct interaction with the device with the help of [command()](EPD4in2::command())
///
/// //TODO: make public?
pub(crate) fn multiple_data(&mut self, data: &[u8]) -> Result<(), ERR> {
pub(crate) fn data(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> {
// high for data
self.dc.set_high();
// Transfer data (u8-array) over spi
self.with_cs(|epd| epd.spi.write(data))
self.write(spi, data)
}
/// 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> {
self.cmd(spi, command)?;
self.data(spi, data)
}
// spi write helper/abstraction function
fn with_cs<F>(&mut self, f: F) -> Result<(), ERR>
where
F: FnOnce(&mut Self) -> Result<(), ERR>,
fn write(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error>
{
// activate spi with cs low
self.cs.set_low();
// transfer spi data
let result = f(self);
spi.write(data)?;
// deativate spi with cs high
self.cs.set_high();
// return result
result
Ok(())
}
/// Waits until device isn't busy anymore (busy == HIGH)
@ -141,35 +101,27 @@ 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) {
self.delay_ms(1);
// 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()) {
//TODO: shorten the time? it was 100 in the beginning
self.delay_ms(5);
//TODO: REMOVAL of DELAY: it's only waiting for the signal anyway and should continue work asap
//old: shorten the time? it was 100 in the beginning
//self.delay_ms(5);
}
}
/// Abstraction of setting the delay for simpler calls
///
/// maximum delay ~65 seconds (u16:max in ms)
pub(crate) fn delay_ms(&mut self, delay: u16) {
self.delay.delay_ms(delay);
}
/// Resets the device.
///
/// Often used to awake the module from deep sleep. See [EPD4in2::sleep()](EPD4in2::sleep())
///
/// TODO: Takes at least 400ms of delay alone, can it be shortened?
pub(crate) fn reset(&mut self) {
pub(crate) fn reset<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) {
self.rst.set_low();
//TODO: why 200ms? (besides being in the arduino version)
self.delay_ms(200);
delay.delay_ms(200);
self.rst.set_high();
//TODO: same as 3 lines above
self.delay_ms(200);
delay.delay_ms(200);
}
}

7
src/lib.rs
View File

@ -50,11 +50,14 @@ use hal::spi::{Mode, Phase, Polarity};
#[cfg(feature = "graphics")]
pub mod drawing;
mod interface;
pub use interface::{WaveshareInterface};
mod traits;
pub use traits::{WaveshareDisplay};
pub mod color;
/// Interface for the physical connection between display and the controlling device
mod interface;
#[cfg(feature = "epd4in2")]
mod epd4in2;
#[cfg(feature = "epd4in2")]

36
src/interface/mod.rs → src/traits.rs
View File

@ -6,8 +6,8 @@ use hal::{
use color::Color;
/// Interface for the physical connection between display and the controlling device
pub(crate) mod connection_interface;
/// All commands need to have this trait which gives the address of the command
@ -26,14 +26,13 @@ trait LUTSupport<ERR> {
}
pub(crate) trait InternalWiAdditions<SPI, CS, BUSY, DC, RST, Delay, ERR>
pub(crate) trait InternalWiAdditions<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
/// This initialises the EPD and powers it up
///
@ -45,27 +44,26 @@ 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(&mut self) -> Result<(), ERR>;
fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error>;
}
pub trait WaveshareInterface<SPI, CS, BUSY, DC, RST, Delay, ERR>
pub trait WaveshareDisplay<SPI, CS, BUSY, DC, RST>
where
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
DC: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
/// Creates a new driver from a SPI peripheral, CS Pin, Busy InputPin, DC
///
/// This already initialises the device. That means [init()](WaveshareInterface::init()) isn't needed directly afterwards
fn new(
spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: Delay,
) -> Result<Self, ERR>
fn new<DELAY: DelayMs<u8>>(
spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY,
) -> Result<Self, SPI::Error>
where
Self: Sized;
@ -75,9 +73,9 @@ where
/// But you can also use [wake_up()](WaveshareInterface::wake_up()) to awaken.
/// But as you need to power it up once more anyway you can also just directly use [new()](WaveshareInterface::new()) for resetting
/// and initialising which already contains the reset
fn sleep(&mut self) -> Result<(), ERR>;
fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error>;
fn wake_up(&mut self) -> Result<(), ERR>;
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())
@ -92,30 +90,26 @@ where
/// Get the height of the display
fn height(&self) -> u16;
/// Abstraction of setting the delay for simpler calls
///
/// maximum delay ~65 seconds (u16:max in ms)
fn delay_ms(&mut self, delay: u16);
/// Transmit a full frame to the SRAM of the EPD
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), ERR>;
fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error>;
/// Transmits partial data to the SRAM of the EPD
///
/// BUFFER needs to be of size: w / 8 * h !
fn update_partial_frame(
&mut self,
spi: &mut SPI,
buffer: &[u8],
x: u16,
y: u16,
width: u16,
height: u16,
) -> Result<(), ERR>;
) -> Result<(), SPI::Error>;
/// Displays the frame data from SRAM
fn display_frame(&mut self) -> Result<(), ERR>;
fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error>;
/// 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) -> Result<(), ERR>;
fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error>;
}

6
src/type_a/command.rs
View File

@ -1,6 +1,6 @@
//! SPI Commands for the Waveshare 2.9" and 1.54" E-Ink Display
use interface;
use traits;
/// EPD1in54 and EPD2IN9 commands
///
@ -71,7 +71,7 @@ pub(crate) enum Command {
NOP = 0xFF,
}
impl interface::Command for Command {
impl traits::Command for Command {
/// Returns the address of the command
fn address(self) -> u8 {
self as u8
@ -81,7 +81,7 @@ impl interface::Command for Command {
#[cfg(test)]
mod tests {
use super::Command;
use interface::Command as CommandTrait;
use traits::Command as CommandTrait;
#[test]
fn command_addr() {