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

Made SPI shareable 

Disown spi for better shareabilty
embedded-hal-1.0
Chris 2018-10-10 16:06:27 +02:00
parent 6a24acf62b
commit 87832f6043
5 changed files with 241 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
src/epd1in54/mod.rs
View File

@ -48,15 +48,15 @@ pub struct EPD1in54<SPI, CS, BUSY, DC, RST> {
background_color: Color, background_color: Color,
} }
impl<SPI, CS, BUSY, DC, RST, E> EPD1in54<SPI, CS, BUSY, DC, RST> impl<SPI, CS, BUSY, DC, RST> EPD1in54<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = E>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
RST: OutputPin, RST: OutputPin,
{ {
fn init<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) -> Result<(), E> { fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.interface.reset(delay); self.interface.reset(delay);
// 3 Databytes: // 3 Databytes:
@ -65,6 +65,7 @@ where
// 0.. B[2:0] // 0.. B[2:0]
// Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?) // Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?)
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::DRIVER_OUTPUT_CONTROL, Command::DRIVER_OUTPUT_CONTROL,
&[HEIGHT as u8, (HEIGHT >> 8) as u8, 0x00] &[HEIGHT as u8, (HEIGHT >> 8) as u8, 0x00]
)?; )?;
@ -74,27 +75,27 @@ where
// 1 .. B[6:0] = 0xCE | 0xD6 // 1 .. B[6:0] = 0xCE | 0xD6
// 1 .. C[6:0] = 0x8D | 0x9D // 1 .. C[6:0] = 0x8D | 0x9D
//TODO: test //TODO: test
self.interface.cmd_with_data(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 // One Databyte with value 0xA8 for 7V VCOM
self.interface.cmd_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 // One Databyte with default value 0x1A for 4 dummy lines per gate
self.interface.cmd_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 // One Databyte with default value 0x08 for 2us per line
self.interface.cmd_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 // One Databyte with default value 0x03
// -> address: x increment, y increment, address counter is updated in x direction // -> address: x increment, y increment, address counter is updated in x direction
self.interface.cmd_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, E> WaveshareInterface<SPI, CS, BUSY, DC, RST, E> impl<SPI, CS, BUSY, DC, RST, E> WaveshareInterface<SPI, CS, BUSY, DC, RST>
for EPD1in54<SPI, CS, BUSY, DC, RST> for EPD1in54<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = E>, SPI: Write<u8, Error = E>,
@ -112,74 +113,76 @@ where
} }
fn new<DELAY: DelayMs<u8>>( fn new<DELAY: DelayMs<u8>>(
spi: 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, E> { ) -> Result<Self, SPI::Error> {
let interface = ConnectionInterface::new(spi, cs, busy, dc, rst); let interface = ConnectionInterface::new(cs, busy, dc, rst);
let mut epd = EPD1in54 { let mut epd = EPD1in54 {
interface, interface,
background_color: DEFAULT_BACKGROUND_COLOR, background_color: DEFAULT_BACKGROUND_COLOR,
}; };
epd.init(delay)?; epd.init(spi, delay)?;
Ok(epd) Ok(epd)
} }
fn wake_up<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) -> Result<(), E> { fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.init(delay) 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 // 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
//TODO: is 0x00 needed here or would 0x01 be even more efficient? //TODO: is 0x00 needed here or would 0x01 be even more efficient?
self.interface.cmd_with_data(Command::DEEP_SLEEP_MODE, &[0x00])?; self.interface.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
self.wait_until_idle(); self.wait_until_idle();
Ok(()) Ok(())
} }
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E> { fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
self.use_full_frame()?; self.use_full_frame(spi)?;
self.interface.cmd_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 //TODO: update description: last 3 bits will be ignored for width and x_pos
fn update_partial_frame( fn update_partial_frame(
&mut self, &mut self,
spi: &mut SPI,
buffer: &[u8], buffer: &[u8],
x: u16, x: u16,
y: u16, y: u16,
width: u16, width: u16,
height: u16, height: u16,
) -> Result<(), E> { ) -> Result<(), SPI::Error> {
self.set_ram_area(x, y, x + width, y + height)?; self.set_ram_area(spi, x, y, x + width, y + height)?;
self.set_ram_counter(x, y)?; self.set_ram_counter(spi, x, y)?;
self.interface.cmd_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) // 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) //TODO: test control_1 or control_2 with default value 0xFF (from the datasheet)
self.interface.cmd_with_data(Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?; self.interface.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface.cmd(Command::MASTER_ACTIVATION)?; self.interface.cmd(spi, Command::MASTER_ACTIVATION)?;
// MASTER Activation should not be interupted to avoid currption of panel images // MASTER Activation should not be interupted to avoid currption of panel images
// therefore a terminate command is send // therefore a terminate command is send
self.interface.cmd(Command::NOP) self.interface.cmd(spi, Command::NOP)
} }
fn clear_frame(&mut self) -> Result<(), E> { fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.use_full_frame()?; self.use_full_frame(spi)?;
// clear the ram with the background color // clear the ram with the background color
let color = self.background_color.get_byte_value(); 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? //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::WRITE_RAM, Command::WRITE_RAM,
&[color; WIDTH as usize / 8 * HEIGHT as usize] &[color; WIDTH as usize / 8 * HEIGHT as usize]
) )
@ -196,9 +199,9 @@ where
} }
} }
impl<SPI, CS, BUSY, DC, RST, E> EPD1in54<SPI, CS, BUSY, DC, RST> impl<SPI, CS, BUSY, DC, RST> EPD1in54<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = E>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
@ -208,45 +211,49 @@ where
self.interface.wait_until_idle(false); 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 // 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 // start from the beginning
self.set_ram_counter(0, 0) self.set_ram_counter(spi, 0, 0)
} }
pub(crate) fn set_ram_area( pub(crate) fn set_ram_area(
&mut self, &mut self,
spi: &mut SPI,
start_x: u16, start_x: u16,
start_y: u16, start_y: u16,
end_x: u16, end_x: u16,
end_y: u16, end_y: u16,
) -> Result<(), E> { ) -> Result<(), SPI::Error> {
assert!(start_x < end_x); assert!(start_x < end_x);
assert!(start_y < end_y); 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 // x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant // aren't relevant
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::SET_RAM_X_ADDRESS_START_END_POSITION, 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 // 2 Databytes: A[7:0] & 0..A[8] for each - start and end
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::SET_RAM_Y_ADDRESS_START_END_POSITION, 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, 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 // x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant // aren't relevant
self.interface.cmd_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] // 2 Databytes: A[7:0] & 0..A[8]
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::SET_RAM_Y_ADDRESS_COUNTER, Command::SET_RAM_Y_ADDRESS_COUNTER,
&[ &[
y as u8, y as u8,
@ -258,13 +265,13 @@ where
} }
/// Uses the slower full update /// Uses the slower full update
pub fn set_lut(&mut self) -> Result<(), E> { pub fn set_lut(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(&LUT_FULL_UPDATE) self.set_lut_helper(spi, &LUT_FULL_UPDATE)
} }
/// Uses the quick partial refresh /// Uses the quick partial refresh
pub fn set_lut_quick(&mut self) -> Result<(), E> { pub fn set_lut_quick(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(&LUT_PARTIAL_UPDATE) self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE)
} }
//TODO: assert length for LUT is exactly 30 //TODO: assert length for LUT is exactly 30
@ -272,9 +279,9 @@ where
// self.set_lut_helper(buffer) // 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); assert!(buffer.len() == 30);
self.interface.cmd_with_data(Command::WRITE_LUT_REGISTER, buffer) self.interface.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
} }
} }

104
src/epd2in9/mod.rs
View File

@ -47,15 +47,15 @@ pub struct EPD2in9<SPI, CS, BUSY, DC, RST> {
background_color: Color, background_color: Color,
} }
impl<SPI, CS, BUSY, DC, RST, E> EPD2in9<SPI, CS, BUSY, DC, RST> impl<SPI, CS, BUSY, DC, RST> EPD2in9<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = E>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
RST: OutputPin, RST: OutputPin,
{ {
fn init<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) -> Result<(), E> { fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.interface.reset(delay); self.interface.reset(delay);
// 3 Databytes: // 3 Databytes:
@ -63,37 +63,37 @@ where
// 0.. A[8] // 0.. A[8]
// 0.. B[2:0] // 0.. B[2:0]
// Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?) // Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?)
self.interface.cmd_with_data(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) // 3 Databytes: (and default values from datasheet and arduino)
// 1 .. A[6:0] = 0xCF | 0xD7 // 1 .. A[6:0] = 0xCF | 0xD7
// 1 .. B[6:0] = 0xCE | 0xD6 // 1 .. B[6:0] = 0xCE | 0xD6
// 1 .. C[6:0] = 0x8D | 0x9D // 1 .. C[6:0] = 0x8D | 0x9D
//TODO: test //TODO: test
self.interface.cmd_with_data(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 // One Databyte with value 0xA8 for 7V VCOM
self.interface.cmd_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 // One Databyte with default value 0x1A for 4 dummy lines per gate
self.interface.cmd_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 // One Databyte with default value 0x08 for 2us per line
self.interface.cmd_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 // One Databyte with default value 0x03
// -> address: x increment, y increment, address counter is updated in x direction // -> address: x increment, y increment, address counter is updated in x direction
self.interface.cmd_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, ERR> impl<SPI, CS, BUSY, DC, RST>
WaveshareInterface<SPI, CS, BUSY, DC, RST, ERR> WaveshareInterface<SPI, CS, BUSY, DC, RST>
for EPD2in9<SPI, CS, BUSY, DC, RST> for EPD2in9<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = ERR>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
@ -108,75 +108,77 @@ where
} }
fn new<DELAY: DelayMs<u8>>( fn new<DELAY: DelayMs<u8>>(
spi: 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, ERR> { ) -> Result<Self, SPI::Error> {
let interface = ConnectionInterface::new(spi, cs, busy, dc, rst); let interface = ConnectionInterface::new(cs, busy, dc, rst);
let mut epd = EPD2in9 { let mut epd = EPD2in9 {
interface, interface,
background_color: DEFAULT_BACKGROUND_COLOR, background_color: DEFAULT_BACKGROUND_COLOR,
}; };
epd.init(delay)?; epd.init(spi, delay)?;
Ok(epd) 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 // 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
//TODO: is 0x00 needed here? (see also epd1in54) //TODO: is 0x00 needed here? (see also epd1in54)
self.interface.cmd_with_data(Command::DEEP_SLEEP_MODE, &[0x00])?; self.interface.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
self.wait_until_idle(); self.wait_until_idle();
Ok(()) Ok(())
} }
fn wake_up<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) -> Result<(), ERR> { fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.init(delay) self.init(spi, delay)
} }
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), ERR> { fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
self.use_full_frame()?; self.use_full_frame(spi)?;
self.interface.cmd_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 //TODO: update description: last 3 bits will be ignored for width and x_pos
fn update_partial_frame( fn update_partial_frame(
&mut self, &mut self,
spi: &mut SPI,
buffer: &[u8], buffer: &[u8],
x: u16, x: u16,
y: u16, y: u16,
width: u16, width: u16,
height: u16, height: u16,
) -> Result<(), ERR> { ) -> Result<(), SPI::Error> {
self.set_ram_area(x, y, x + width, y + height)?; self.set_ram_area(spi, x, y, x + width, y + height)?;
self.set_ram_counter(x, y)?; self.set_ram_counter(spi, x, y)?;
self.interface.cmd_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) // 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) //TODO: test control_1 or control_2 with default value 0xFF (from the datasheet)
self.interface.cmd_with_data(Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?; self.interface.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
self.interface.cmd(Command::MASTER_ACTIVATION)?; self.interface.cmd(spi, Command::MASTER_ACTIVATION)?;
// MASTER Activation should not be interupted to avoid currption of panel images // MASTER Activation should not be interupted to avoid currption of panel images
// therefore a terminate command is send // therefore a terminate command is send
self.interface.cmd(Command::NOP) self.interface.cmd(spi, Command::NOP)
} }
fn clear_frame(&mut self) -> Result<(), ERR> { fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.use_full_frame()?; self.use_full_frame(spi)?;
// clear the ram with the background color // clear the ram with the background color
let color = self.background_color.get_byte_value(); 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? //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::WRITE_RAM, Command::WRITE_RAM,
&[color; WIDTH as usize / 8 * HEIGHT as usize] &[color; WIDTH as usize / 8 * HEIGHT as usize]
) )
@ -192,9 +194,9 @@ where
} }
} }
impl<SPI, CS, BUSY, DC, RST, E> EPD2in9<SPI, CS, BUSY, DC, RST> impl<SPI, CS, BUSY, DC, RST> EPD2in9<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = E>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
@ -204,57 +206,59 @@ where
self.interface.wait_until_idle(false); 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 // 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 // start from the beginning
self.set_ram_counter(0, 0) self.set_ram_counter(spi, 0, 0)
} }
pub(crate) fn set_ram_area( pub(crate) fn set_ram_area(
&mut self, &mut self,
spi: &mut SPI,
start_x: u16, start_x: u16,
start_y: u16, start_y: u16,
end_x: u16, end_x: u16,
end_y: u16, end_y: u16,
) -> Result<(), E> { ) -> Result<(), SPI::Error> {
assert!(start_x < end_x); assert!(start_x < end_x);
assert!(start_y < end_y); 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 // x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant // aren't relevant
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::SET_RAM_X_ADDRESS_START_END_POSITION, 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 // 2 Databytes: A[7:0] & 0..A[8] for each - start and end
self.interface.cmd_with_data(Command::SET_RAM_Y_ADDRESS_START_END_POSITION, 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, 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 // x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant // aren't relevant
self.interface.cmd_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] // 2 Databytes: A[7:0] & 0..A[8]
self.interface.cmd_with_data(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(); self.wait_until_idle();
Ok(()) Ok(())
} }
/// Uses the slower full update /// Uses the slower full update
pub fn set_lut(&mut self) -> Result<(), E> { pub fn set_lut(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(&LUT_FULL_UPDATE) self.set_lut_helper(spi, &LUT_FULL_UPDATE)
} }
/// Uses the quick partial refresh /// Uses the quick partial refresh
pub fn set_lut_quick(&mut self) -> Result<(), E> { pub fn set_lut_quick(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(&LUT_PARTIAL_UPDATE) self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE)
} }
//TODO: assert length for LUT is exactly 30 //TODO: assert length for LUT is exactly 30
@ -262,9 +266,9 @@ where
// self.set_lut_helper(buffer) // 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); assert!(buffer.len() == 30);
self.interface.cmd_with_data(Command::WRITE_LUT_REGISTER, buffer) self.interface.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
} }
} }

184
src/epd4in2/mod.rs
View File

@ -74,50 +74,50 @@ pub struct EPD4in2<SPI, CS, BUSY, DC, RST> {
impl<SPI, CS, BUSY, DC, RST, ERR> impl<SPI, CS, BUSY, DC, RST>
InternalWiAdditions<SPI, CS, BUSY, DC, RST, ERR> InternalWiAdditions<SPI, CS, BUSY, DC, RST>
for EPD4in2<SPI, CS, BUSY, DC, RST> for EPD4in2<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = ERR>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
RST: OutputPin, RST: OutputPin,
{ {
fn init<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) -> Result<(), ERR> { fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
// reset the device // reset the device
self.interface.reset(delay); self.interface.reset(delay);
// set the power settings // set the power settings
self.interface.cmd_with_data(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 // start the booster
self.interface.cmd_with_data(Command::BOOSTER_SOFT_START, &[0x17, 0x17, 0x17])?; self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START, &[0x17, 0x17, 0x17])?;
// power on // power on
self.command(Command::POWER_ON)?; self.command(spi, Command::POWER_ON)?;
self.wait_until_idle(); self.wait_until_idle();
// set the panel settings // set the panel settings
self.cmd_with_data(Command::PANEL_SETTING, &[0x3F])?; self.cmd_with_data(spi, Command::PANEL_SETTING, &[0x3F])?;
// Set Frequency, 200 Hz didn't work on my board // Set Frequency, 200 Hz didn't work on my board
// 150Hz and 171Hz wasn't tested yet // 150Hz and 171Hz wasn't tested yet
// TODO: Test these other frequencies // TODO: Test these other frequencies
// 3A 100HZ 29 150Hz 39 200HZ 31 171HZ DEFAULT: 3c 50Hz // 3A 100HZ 29 150Hz 39 200HZ 31 171HZ DEFAULT: 3c 50Hz
self.cmd_with_data(Command::PLL_CONTROL, &[0x3A])?; self.cmd_with_data(spi, Command::PLL_CONTROL, &[0x3A])?;
self.set_lut()?; self.set_lut(spi)?;
Ok(()) Ok(())
} }
} }
impl<SPI, CS, BUSY, DC, RST, ERR> impl<SPI, CS, BUSY, DC, RST>
WaveshareInterface<SPI, CS, BUSY, DC, RST, ERR> WaveshareInterface<SPI, CS, BUSY, DC, RST>
for EPD4in2<SPI, CS, BUSY, DC, RST> for EPD4in2<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = ERR>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
@ -138,8 +138,8 @@ where
/// ///
/// epd4in2.sleep(); /// epd4in2.sleep();
/// ``` /// ```
fn new<DELAY: DelayMs<u8>>(spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut 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> {
let interface = ConnectionInterface::new(spi, cs, busy, dc, rst); let interface = ConnectionInterface::new(cs, busy, dc, rst);
let color = DEFAULT_BACKGROUND_COLOR; let color = DEFAULT_BACKGROUND_COLOR;
let mut epd = EPD4in2 { let mut epd = EPD4in2 {
@ -147,120 +147,122 @@ where
color, color,
}; };
epd.init(delay)?; epd.init(spi, delay)?;
Ok(epd) Ok(epd)
} }
fn wake_up<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) -> Result<(), ERR> { fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
self.init(delay) self.init(spi, delay)
} }
//TODO: is such a long delay really needed inbetween? //TODO: is such a long delay really needed inbetween?
fn sleep(&mut self) -> Result<(), ERR> { fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.interface.cmd_with_data(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(Command::VCM_DC_SETTING)?; // VCOM to 0V self.command(spi, Command::VCM_DC_SETTING)?; // VCOM to 0V
self.command(Command::PANEL_SETTING)?; self.command(spi, Command::PANEL_SETTING)?;
//TODO: Removal of delay. TEST! //TODO: Removal of delay. TEST!
//self.delay_ms(100); //self.delay_ms(100);
self.command(Command::POWER_SETTING)?; //VG&VS to 0V fast self.command(spi, Command::POWER_SETTING)?; //VG&VS to 0V fast
for _ in 0..4 { for _ in 0..4 {
self.send_data(&[0x00])?; self.send_data(spi, &[0x00])?;
} }
//TODO: Removal of delay. TEST! //TODO: Removal of delay. TEST!
//self.delay_ms(100); //self.delay_ms(100);
self.command(Command::POWER_OFF)?; self.command(spi, Command::POWER_OFF)?;
self.wait_until_idle(); self.wait_until_idle();
self.interface.cmd_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(); let color_value = self.color.get_byte_value();
self.send_resolution()?; self.send_resolution(spi)?;
self.interface.cmd_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) //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.send_command_u8(0x97)?; //VBDF 17|D7 VBDW 97 VBDB 57 VBDF F7 VBDW 77 VBDB 37 VBDR B7
self.interface.cmd_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.command(spi, Command::DATA_START_TRANSMISSION_1)?;
for _ in 0..buffer.len() { for _ in 0..buffer.len() {
self.send_data(&[color_value])?; self.send_data(spi, &[color_value])?;
} }
//TODO: Removal of delay. TEST! //TODO: Removal of delay. TEST!
//self.delay_ms(2); //self.delay_ms(2);
self.interface.cmd_with_data(Command::DATA_START_TRANSMISSION_2, buffer) self.interface.cmd_with_data(spi, Command::DATA_START_TRANSMISSION_2, buffer)
} }
fn update_partial_frame( fn update_partial_frame(
&mut self, &mut self,
spi: &mut SPI,
buffer: &[u8], buffer: &[u8],
x: u16, x: u16,
y: u16, y: u16,
width: u16, width: u16,
height: u16, height: u16,
) -> Result<(), ERR> { ) -> Result<(), SPI::Error> {
if buffer.len() as u16 != width / 8 * height { if buffer.len() as u16 != width / 8 * height {
//TODO: panic!! or sth like that //TODO: panic!! or sth like that
//return Err("Wrong buffersize"); //return Err("Wrong buffersize");
} }
self.command(Command::PARTIAL_IN)?; self.command(spi, Command::PARTIAL_IN)?;
self.command(Command::PARTIAL_WINDOW)?; self.command(spi, Command::PARTIAL_WINDOW)?;
self.send_data(&[(x >> 8) as u8])?; self.send_data(spi, &[(x >> 8) as u8])?;
let tmp = x & 0xf8; 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; let tmp = tmp + width - 1;
self.send_data(&[(tmp >> 8) as u8])?; self.send_data(spi, &[(tmp >> 8) as u8])?;
self.send_data(&[(tmp | 0x07) as u8])?; self.send_data(spi, &[(tmp | 0x07) as u8])?;
self.send_data(&[(y >> 8) as u8])?; self.send_data(spi, &[(y >> 8) as u8])?;
self.send_data(&[y as u8])?; self.send_data(spi, &[y as u8])?;
self.send_data(&[((y + height - 1) >> 8) as u8])?; self.send_data(spi, &[((y + height - 1) >> 8) as u8])?;
self.send_data(&[(y + height - 1) 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 //TODO: handle dtm somehow
let is_dtm1 = false; let is_dtm1 = false;
if is_dtm1 { if is_dtm1 {
self.command(Command::DATA_START_TRANSMISSION_1)? self.command(spi, Command::DATA_START_TRANSMISSION_1)?
} else { } else {
self.command(Command::DATA_START_TRANSMISSION_2)? self.command(spi, Command::DATA_START_TRANSMISSION_2)?
} }
self.send_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> { fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.command(Command::DISPLAY_REFRESH)?; self.command(spi, Command::DISPLAY_REFRESH)?;
self.wait_until_idle(); self.wait_until_idle();
Ok(()) Ok(())
} }
fn clear_frame(&mut self) -> Result<(), ERR> { fn clear_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.send_resolution()?; self.send_resolution(spi)?;
//let size = WIDTH as usize / 8 * HEIGHT as usize; //let size = WIDTH as usize / 8 * HEIGHT as usize;
let color_value = self.color.get_byte_value(); 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? //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::DATA_START_TRANSMISSION_1, Command::DATA_START_TRANSMISSION_1,
&[color_value; WIDTH as usize / 8 * HEIGHT as usize] &[color_value; WIDTH as usize / 8 * HEIGHT as usize]
)?; )?;
@ -270,6 +272,7 @@ where
//TODO: this is using a big buffer atm, is it better to just loop over sending a single byte? //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
self.interface.cmd_with_data( self.interface.cmd_with_data(
spi,
Command::DATA_START_TRANSMISSION_2, Command::DATA_START_TRANSMISSION_2,
&[color_value; WIDTH as usize / 8 * HEIGHT as usize] &[color_value; WIDTH as usize / 8 * HEIGHT as usize]
) )
@ -293,45 +296,45 @@ where
} }
} }
impl<SPI, CS, BUSY, DC, RST, ERR> EPD4in2<SPI, CS, BUSY, DC, RST> impl<SPI, CS, BUSY, DC, RST> EPD4in2<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = ERR>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
RST: OutputPin, RST: OutputPin,
{ {
fn command(&mut self, command: Command) -> Result<(), ERR> { fn command(&mut self, spi: &mut SPI, command: Command) -> Result<(), SPI::Error> {
self.interface.cmd(command) self.interface.cmd(spi, command)
} }
fn send_data(&mut self, data: &[u8]) -> Result<(), ERR> { fn send_data(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> {
self.interface.data(data) self.interface.data(spi, data)
} }
fn cmd_with_data(&mut self, command: Command, data: &[u8]) -> Result<(), ERR> { fn cmd_with_data(&mut self, spi: &mut SPI, command: Command, data: &[u8]) -> Result<(), SPI::Error> {
self.interface.cmd_with_data(command, data) self.interface.cmd_with_data(spi, command, data)
} }
fn wait_until_idle(&mut self) { fn wait_until_idle(&mut self) {
self.interface.wait_until_idle(true) 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 w = self.width();
let h = self.height(); let h = self.height();
self.command(Command::RESOLUTION_SETTING)?; self.command(spi, Command::RESOLUTION_SETTING)?;
self.send_data(&[(w >> 8) as u8])?; self.send_data(spi, &[(w >> 8) as u8])?;
self.send_data(&[w as u8])?; self.send_data(spi, &[w as u8])?;
self.send_data(&[(h >> 8) as u8])?; self.send_data(spi, &[(h >> 8) as u8])?;
self.send_data(&[h as u8]) self.send_data(spi, &[h as u8])
} }
/// Fill the look-up table for the EPD /// Fill the look-up table for the EPD
//TODO: make public? //TODO: make public?
fn set_lut(&mut self) -> Result<(), ERR> { fn set_lut(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
self.set_lut_helper(&LUT_VCOM0, &LUT_WW, &LUT_BW, &LUT_WB, &LUT_BB) 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) /// Fill the look-up table for a quick display (partial refresh)
@ -339,8 +342,9 @@ where
/// Is automatically done by [EPD4in2::display_frame_quick()](EPD4in2::display_frame_quick()) /// Is automatically done by [EPD4in2::display_frame_quick()](EPD4in2::display_frame_quick())
/// //TODO: make public? /// //TODO: make public?
#[cfg(feature = "epd4in2_fast_update")] #[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( self.set_lut_helper(
spi,
&LUT_VCOM0_QUICK, &LUT_VCOM0_QUICK,
&LUT_WW_QUICK, &LUT_WW_QUICK,
&LUT_BW_QUICK, &LUT_BW_QUICK,
@ -351,33 +355,47 @@ where
fn set_lut_helper( fn set_lut_helper(
&mut self, &mut self,
spi: &mut SPI,
lut_vcom: &[u8], lut_vcom: &[u8],
lut_ww: &[u8], lut_ww: &[u8],
lut_bw: &[u8], lut_bw: &[u8],
lut_wb: &[u8], lut_wb: &[u8],
lut_bb: &[u8], lut_bb: &[u8],
) -> Result<(), ERR> { ) -> Result<(), SPI::Error> {
// LUT VCOM // LUT VCOM
self.command(Command::LUT_FOR_VCOM)?; self.cmd_with_data(
self.send_data(lut_vcom)?; spi,
Command::LUT_FOR_VCOM,
lut_vcom
)?;
// LUT WHITE to WHITE // LUT WHITE to WHITE
self.command(Command::LUT_WHITE_TO_WHITE)?; self.cmd_with_data(
self.send_data(lut_ww)?; spi,
Command::LUT_WHITE_TO_WHITE,
lut_ww
)?;
// LUT BLACK to WHITE // LUT BLACK to WHITE
self.command(Command::LUT_BLACK_TO_WHITE)?; self.cmd_with_data(
self.send_data(lut_bw)?; spi,
Command::LUT_BLACK_TO_WHITE,
lut_bw
)?;
// LUT WHITE to BLACK // LUT WHITE to BLACK
self.command(Command::LUT_WHITE_TO_BLACK)?; self.cmd_with_data(
self.send_data(lut_wb)?; spi,
Command::LUT_WHITE_TO_BLACK,
lut_wb,
)?;
// LUT BLACK to BLACK // LUT BLACK to BLACK
self.command(Command::LUT_BLACK_TO_BLACK)?; self.cmd_with_data(
self.send_data(lut_bb)?; spi,
Command::LUT_BLACK_TO_BLACK,
Ok(()) lut_bb,
)
} }
} }

36
src/traits/connection_interface.rs
View File

@ -3,13 +3,15 @@ use hal::{
digital::*, digital::*,
}; };
use core::marker::PhantomData;
use traits::Command; use traits::Command;
/// The Connection Interface of all (?) Waveshare EPD-Devices /// The Connection Interface of all (?) Waveshare EPD-Devices
/// ///
pub(crate) struct ConnectionInterface<SPI, CS, BUSY, DC, RST> { pub(crate) struct ConnectionInterface<SPI, CS, BUSY, DC, RST> {
/// SPI /// SPI
spi: SPI, _spi: PhantomData<SPI>,
/// CS for SPI /// CS for SPI
cs: CS, cs: CS,
/// Low for busy, Wait until display is ready! /// Low for busy, Wait until display is ready!
@ -20,18 +22,18 @@ pub(crate) struct ConnectionInterface<SPI, CS, BUSY, DC, RST> {
rst: RST, rst: RST,
} }
impl<SPI, CS, BUSY, DC, RST, ERR> impl<SPI, CS, BUSY, DC, RST>
ConnectionInterface<SPI, CS, BUSY, DC, RST> ConnectionInterface<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8, Error = ERR>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
BUSY: InputPin, BUSY: InputPin,
DC: OutputPin, DC: OutputPin,
RST: OutputPin, RST: OutputPin,
{ {
pub fn new(spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST) -> Self { pub fn new(cs: CS, busy: BUSY, dc: DC, rst: RST) -> Self {
ConnectionInterface { ConnectionInterface {
spi, _spi: PhantomData::default(),
cs, cs,
busy, busy,
dc, dc,
@ -44,12 +46,12 @@ where
/// Enables direct interaction with the device with the help of [data()](ConnectionInterface::data()) /// Enables direct interaction with the device with the help of [data()](ConnectionInterface::data())
/// ///
/// //TODO: make public? /// //TODO: make public?
pub(crate) fn cmd<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 // low for commands
self.dc.set_low(); self.dc.set_low();
// Transfer the command over spi // Transfer the command over spi
self.with_cs(|epd| epd.spi.write(&[command.address()])) self.write(spi, &[command.address()])
} }
/// Basic function for sending an array of u8-values of data over spi /// Basic function for sending an array of u8-values of data over spi
@ -57,35 +59,33 @@ where
/// Enables direct interaction with the device with the help of [command()](EPD4in2::command()) /// Enables direct interaction with the device with the help of [command()](EPD4in2::command())
/// ///
/// //TODO: make public? /// //TODO: make public?
pub(crate) fn data(&mut self, data: &[u8]) -> Result<(), ERR> { pub(crate) fn data(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> {
// high for data // high for data
self.dc.set_high(); self.dc.set_high();
// Transfer data (u8-array) over spi // 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. /// Basic function for sending [Commands](Command) and the data belonging to it.
/// ///
/// //TODO: make public? /// //TODO: make public?
pub(crate) fn cmd_with_data<T: Command>(&mut self, command: T, data: &[u8]) -> Result<(), ERR> { pub(crate) fn cmd_with_data<T: Command>(&mut self, spi: &mut SPI, command: T, data: &[u8]) -> Result<(), SPI::Error> {
self.cmd(command)?; self.cmd(spi, command)?;
self.data(data) self.data(spi, data)
} }
// spi write helper/abstraction function // spi write helper/abstraction function
fn with_cs<F>(&mut self, f: F) -> Result<(), ERR> fn write(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error>
where
F: FnOnce(&mut Self) -> Result<(), ERR>,
{ {
// activate spi with cs low // activate spi with cs low
self.cs.set_low(); self.cs.set_low();
// transfer spi data // transfer spi data
let result = f(self); spi.write(data)?;
// deativate spi with cs high // deativate spi with cs high
self.cs.set_high(); self.cs.set_high();
// return result
result Ok(())
} }
/// Waits until device isn't busy anymore (busy == HIGH) /// Waits until device isn't busy anymore (busy == HIGH)

23
src/traits/mod.rs
View File

@ -26,7 +26,7 @@ trait LUTSupport<ERR> {
} }
pub(crate) trait InternalWiAdditions<SPI, CS, BUSY, DC, RST, ERR> pub(crate) trait InternalWiAdditions<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
@ -44,11 +44,11 @@ where
/// This function calls [reset()](WaveshareInterface::reset()), /// This function calls [reset()](WaveshareInterface::reset()),
/// so you don't need to call reset your self when trying to wake your device up /// so you don't need to call reset your self when trying to wake your device up
/// after setting it to sleep. /// after setting it to sleep.
fn init<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) -> 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, ERR> pub trait WaveshareInterface<SPI, CS, BUSY, DC, RST>
where where
SPI: Write<u8>, SPI: Write<u8>,
CS: OutputPin, CS: OutputPin,
@ -62,8 +62,8 @@ where
/// ///
/// This already initialises the device. That means [init()](WaveshareInterface::init()) isn't needed directly afterwards /// This already initialises the device. That means [init()](WaveshareInterface::init()) isn't needed directly afterwards
fn new<DELAY: DelayMs<u8>>( fn new<DELAY: DelayMs<u8>>(
spi: 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, ERR> ) -> Result<Self, SPI::Error>
where where
Self: Sized; Self: Sized;
@ -73,9 +73,9 @@ where
/// But you can also use [wake_up()](WaveshareInterface::wake_up()) to awaken. /// 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 /// 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 /// 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<DELAY: DelayMs<u8>>(&mut self, delay: &mut DELAY) -> 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()) /// Sets the backgroundcolor for various commands like [clear_frame()](WaveshareInterface::clear_frame())
@ -91,24 +91,25 @@ where
fn height(&self) -> u16; fn height(&self) -> u16;
/// Transmit a full frame to the SRAM of the EPD /// 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 /// Transmits partial data to the SRAM of the EPD
/// ///
/// BUFFER needs to be of size: w / 8 * h ! /// BUFFER needs to be of size: w / 8 * h !
fn update_partial_frame( fn update_partial_frame(
&mut self, &mut self,
spi: &mut SPI,
buffer: &[u8], buffer: &[u8],
x: u16, x: u16,
y: u16, y: u16,
width: u16, width: u16,
height: u16, height: u16,
) -> Result<(), ERR>; ) -> Result<(), SPI::Error>;
/// Displays the frame data from SRAM /// 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 /// Clears the frame buffer on the EPD with the declared background color
/// The background color can be changed with [`set_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>;
} }