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

Made SPI shareable 

Disown spi for better shareabilty
embedded-hal-1.0
Chris 7 years ago
parent
6a24acf62b
commit
87832f6043
5 changed files with 241 additions and 211 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 99
      src/epd1in54/mod.rs
  2. 108
      src/epd2in9/mod.rs
  3. 186
      src/epd4in2/mod.rs
  4. 36
      src/traits/connection_interface.rs
  5. 23
      src/traits/mod.rs

99
src/epd1in54/mod.rs
Unescape 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)
} }
} }

108
src/epd2in9/mod.rs
Unescape 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)
} }
} }

186
src/epd4in2/mod.rs
Unescape 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
Unescape 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
Unescape 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>;
} }

Write Preview
Loading…
Cancel
Save