Merge pull request #12 from Caemor/Cleanup-Interface

[WIP] Cleanup interface

examples/embedded_linux_epd1in54/src/main.rs

@@ -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.clear_frame(&mut spi)?;
-    epd.display_frame();
+    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.update_partial_frame(&mut spi, &small_buffer, 25 + offset, 25 + offset, 16, 16)?;
-        epd.display_frame()?;
+        epd.display_frame(&mut spi)?;
     }
 
     // Clear the full screen
-    epd.clear_frame();
+    epd.clear_frame(&mut spi)?;
-    epd.display_frame();
+    epd.display_frame(&mut spi)?;
 
     // Draw some squares
-    let mut small_buffer =  [Color::Black.get_byte_value(), 160 as u8 / 8 * 160 as u8];
+    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)?;
+    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(())
 }

examples/embedded_linux_epd4in2/src/main.rs

@@ -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.update_frame(&mut spi, graphics.get_buffer())?;
-    epd4in2.display_frame().expect("Display Frame Error");
+    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.update_partial_frame(&mut spi, circle_graphics.get_buffer(), 16,16, 32, 32)?;
-    epd4in2.display_frame().expect("Display Frame Error");
+    epd4in2.display_frame(&mut spi)?;
 
-    epd4in2.update_partial_frame(circle_graphics.get_buffer(), 128,64, 32, 32).expect("Partial Window Error");
+    epd4in2.update_partial_frame(&mut spi, circle_graphics.get_buffer(), 128,64, 32, 32)?;
-    epd4in2.display_frame().expect("Display Frame Error");
+    epd4in2.display_frame(&mut spi)?;
 
-    epd4in2.update_partial_frame(circle_graphics.get_buffer(), 320,24, 32, 32).expect("Partial Window Error");
+    epd4in2.update_partial_frame(&mut spi, circle_graphics.get_buffer(), 320,24, 32, 32)?;
-    epd4in2.display_frame().expect("Display Frame Error");
+    epd4in2.display_frame(&mut spi)?;
 
-    epd4in2.update_partial_frame(circle_graphics.get_buffer(), 160,240, 32, 32).expect("Partial Window Error");
+    epd4in2.update_partial_frame(&mut spi, circle_graphics.get_buffer(), 160,240, 32, 32)?;
-    epd4in2.display_frame().expect("Display Frame Error");
+    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.update_frame(&mut spi, graphics.get_buffer())?;
-    epd4in2.display_frame().expect("Display Frame Error");
+    epd4in2.display_frame(&mut spi)?;
 
-    epd4in2.delay_ms(3000);
+    delay.delay_ms(3000u16);
 
-    epd4in2.sleep().expect("sleeping error");
+    epd4in2.sleep(&mut spi)
 }

examples/stm32f3discovery/src/main.rs

@@ -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.clear_frame(&mut spi).unwrap();
-    epd.display_frame().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.update_partial_frame(&mut spi, &small_buffer, 25 + offset, 25 + offset, 16, 16).unwrap();
-        epd.display_frame().unwrap();
+        epd.display_frame(&mut spi).unwrap();
     }
 
     // Clear the full screen
-    epd.clear_frame().unwrap();
+    epd.clear_frame(&mut spi).unwrap();
-    epd.display_frame().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 {}
 }

src/epd1in54/mod.rs

@@ -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> {
+    fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
-        self.interface.reset();
+        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.cmd_with_data(
-        self.interface.data(HEIGHT as u8)?;
+            spi, 
-        self.interface.data((HEIGHT >> 8) as u8)?;
+            Command::DRIVER_OUTPUT_CONTROL, 
-        self.interface.data(0x00)?;
+            &[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.cmd_with_data(spi, Command::BOOSTER_SOFT_START_CONTROL, &[0xD7, 0xD6, 0x9D])?;
-        self.interface.data(0xD7)?;
-        self.interface.data(0xD6)?;
-        self.interface.data(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>
+impl<SPI, CS, BUSY, DC, RST, E> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
-    for EPD1in54<SPI, CS, BUSY, DC, RST, Delay>
+    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(
+    fn new<DELAY: DelayMs<u8>>(
-        spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: 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, delay);
+        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> {
+    fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
-        self.init()
+        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) {
+    fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
-        self.interface.delay_ms(delay)
+        self.use_full_frame(spi)?;
-    }
+        self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
-
-    fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E> {
-        self.use_full_frame()?;
-        self.interface.command_with_data(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> {
+    ) -> 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.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> {
+    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
         let color = self.background_color.get_byte_value();
 
-        self.interface.command(Command::WRITE_RAM)?;
+        //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
-        self.interface.data_x_times(color, WIDTH / 8 * HEIGHT)
+        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,
+    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.cmd_with_data(
-        self.interface.data((start_x >> 3) as u8)?;
+            spi,
-        self.interface.data((end_x >> 3) as u8)?;
+            Command::SET_RAM_X_ADDRESS_START_END_POSITION,
+            &[(start_x >> 3) as u8, (end_x >> 3) as u8]
+        )?;
 
         // 2 Databytes: A[7:0] & 0..A[8] for each - start and end
-        self.interface.command(Command::SET_RAM_Y_ADDRESS_START_END_POSITION)?;
+        self.interface.cmd_with_data(
-        self.interface.data(start_y as u8)?;
+            spi, 
-        self.interface.data((start_y >> 8) as u8)?;
+            Command::SET_RAM_Y_ADDRESS_START_END_POSITION,
-        self.interface.data(end_y as u8)?;
+            &[start_y as u8, (start_y >> 8) as u8, end_y as u8, (end_y >> 8) as u8]
-        self.interface.data((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> {
+    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
-    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
@@ -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)
     }
 }
 

src/epd2in9/mod.rs

@@ -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> {
+    fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
-        self.interface.reset();
+        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.cmd_with_data(spi, Command::DRIVER_OUTPUT_CONTROL, &[0x27, 0x01, 0x00])?;
-        self.interface.data(HEIGHT as u8)?;
-        self.interface.data((HEIGHT >> 8) as u8)?;
-        self.interface.data(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.cmd_with_data(spi, Command::BOOSTER_SOFT_START_CONTROL, &[0xD7, 0xD6, 0x9D])?;
-        self.interface.data(0xD7)?;
-        self.interface.data(0xD6)?;
-        self.interface.data(0x9D)?;
 
         // One Databyte with value 0xA8 for 7V VCOM
-        self.interface.command(Command::WRITE_VCOM_REGISTER)?;
+        self.interface.cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
-        self.interface.data(0xA8)?;
 
         // One Databyte with default value 0x1A for 4 dummy lines per gate
-        self.interface.command(Command::SET_DUMMY_LINE_PERIOD)?;
+        self.interface.cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
-        self.interface.data(0x1A)?;
 
         // One Databyte with default value 0x08 for 2us per line
-        self.interface.command(Command::SET_GATE_LINE_WIDTH)?;
+        self.interface.cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
-        self.interface.data(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.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
-        self.interface.data(0x03)?;
 
-        self.set_lut()
+        self.set_lut(spi)
     }
-
-
 }
 
-impl<SPI, CS, BUSY, DC, RST, Delay, ERR>
+impl<SPI, CS, BUSY, DC, RST>
-    WaveshareInterface<SPI, CS, BUSY, DC, RST, Delay, ERR>
+    WaveshareDisplay<SPI, CS, BUSY, DC, RST>
-    for EPD2in9<SPI, CS, BUSY, DC, RST, Delay>
+    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(
+    fn new<DELAY: DelayMs<u8>>(
-        spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: 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, delay);
+        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> {
+    fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
-        self.init()
+        self.init(spi, delay)
-    }
-
-    fn delay_ms(&mut self, delay: u16) {
-        self.interface.delay_ms(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.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> {
+    ) -> 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.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> {
+    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
         let color = self.background_color.get_byte_value();
 
-        self.interface.command(Command::WRITE_RAM)?;
+        //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
-        self.interface.data_x_times(color, WIDTH / 8 * HEIGHT)
+        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.cmd_with_data(
-        self.interface.data((start_x >> 3) as u8)?;
+            spi,
-        self.interface.data((end_x >> 3) as u8)?;
+            Command::SET_RAM_X_ADDRESS_START_END_POSITION, 
+            &[(start_x >> 3) as u8, (end_x >> 3) as u8]
+        )?;
 
         // 2 Databytes: A[7:0] & 0..A[8] for each - start and end
-        self.interface.command(Command::SET_RAM_Y_ADDRESS_START_END_POSITION)?;
+        self.interface.cmd_with_data(spi, Command::SET_RAM_Y_ADDRESS_START_END_POSITION,
-        self.interface.data(start_y as u8)?;
+            &[start_y as u8, (start_y >> 8) as u8, end_y as u8, (end_y >> 8) 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)
     }
 
-    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.cmd_with_data(spi, Command::SET_RAM_Y_ADDRESS_COUNTER, &[y as u8, (y >> 8) as u8])?;
-        self.interface.data(y as u8)?;
-        self.interface.data((y >> 8) as u8)?;
 
         self.wait_until_idle();
         Ok(())
     }
 
     /// 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
-    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
@@ -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)
     }
 }
 

src/epd4in2/command.rs

@@ -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() {

src/epd4in2/mod.rs

@@ -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>
+impl<SPI, CS, BUSY, DC, RST>
-    InternalWiAdditions<SPI, CS, BUSY, DC, RST, Delay, ERR>
+    InternalWiAdditions<SPI, CS, BUSY, DC, RST>
-    for EPD4in2<SPI, CS, BUSY, DC, RST, Delay>
+    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.interface.cmd_with_data(spi, Command::POWER_SETTING, &[0x03, 0x00, 0x2b, 0x2b, 0xff])?;
-        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
 
         // start the booster
-        self.command(Command::BOOSTER_SOFT_START)?;
+        self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START, &[0x17, 0x17, 0x17])?;        
-        for _ in 0..3 {
-            self.send_data(0x17)?; //07 0f 17 1f 27 2F 37 2f
-        }
 
         // 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)?;
+        self.cmd_with_data(spi, Command::PANEL_SETTING, &[0x3F])?;
-        // 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);
 
         // 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.cmd_with_data(spi, Command::PLL_CONTROL, &[0x3A])?;
-        self.send_data(0x3A)?;
+        
-
+        self.set_lut(spi)?;
-        self.set_lut()?;
 
         Ok(())
     }
 }
 
-impl<SPI, CS, BUSY, DC, RST, Delay, ERR>
+impl<SPI, CS, BUSY, DC, RST>
-    WaveshareInterface<SPI, CS, BUSY, DC, RST, Delay, ERR>
+    WaveshareDisplay<SPI, CS, BUSY, DC, RST>
-    for EPD4in2<SPI, CS, BUSY, DC, RST, Delay>
+    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> {
+    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, delay);
+        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> {
+    fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
-        self.init()
+        self.init(spi, delay)
     }
 
     //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.command_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)?;
-        self.delay_ms(100);
 
-        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.command(spi, Command::DATA_START_TRANSMISSION_1)?;
-        self.interface.data_x_times(color_value, buffer.len() as u16)?;
+        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(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;
-        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(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
         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> {
+    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();
         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 / 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)?;
+        //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
-        self.interface.data_x_times(color_value, size)?;
+        self.interface.cmd_with_data(
-
+            spi,
-        self.delay_ms(2);
+            Command::DATA_START_TRANSMISSION_1,
-
+            &[color_value; WIDTH as usize / 8 * HEIGHT as usize]
-        self.command(Command::DATA_START_TRANSMISSION_2)?;
+        )?;
-        self.interface.data_x_times(color_value, size)
+
+        //TODO: Removal of delay. TEST!
+        //self.delay_ms(2);
+
+        //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
+        self.interface.cmd_with_data(
+            spi,
+            Command::DATA_START_TRANSMISSION_2,
+            &[color_value; WIDTH as usize / 8 * HEIGHT as usize]
+        )
     }
 
     /// 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> {
+    fn command(&mut self, spi: &mut SPI, command: Command) -> Result<(), SPI::Error> {
-        self.interface.command(command)
+        self.interface.cmd(spi, command)
     }
 
-    fn send_data(&mut self, val: u8) -> Result<(), ERR> {
+    fn send_data(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> {
-        self.interface.data(val)
+        self.interface.data(spi, data)
     }
 
-    fn send_multiple_data(&mut self, data: &[u8]) -> Result<(), ERR> {
+    fn cmd_with_data(&mut self, spi: &mut SPI, command: Command, data: &[u8]) -> Result<(), SPI::Error> {
-        self.interface.multiple_data(data)
+        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.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
     //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)
@@ -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.cmd_with_data(
-        self.send_multiple_data(lut_vcom)?;
+            spi, 
+            Command::LUT_FOR_VCOM,
+            lut_vcom
+        )?;
 
         // LUT WHITE to WHITE
-        self.command(Command::LUT_WHITE_TO_WHITE)?;
+        self.cmd_with_data(
-        self.send_multiple_data(lut_ww)?;
+            spi,
+            Command::LUT_WHITE_TO_WHITE, 
+            lut_ww
+        )?;
 
         // LUT BLACK to WHITE
-        self.command(Command::LUT_BLACK_TO_WHITE)?;
+        self.cmd_with_data(
-        self.send_multiple_data(lut_bw)?;
+            spi,
+            Command::LUT_BLACK_TO_WHITE,
+            lut_bw 
+        )?;
 
         // LUT WHITE to BLACK
-        self.command(Command::LUT_WHITE_TO_BLACK)?;
+        self.cmd_with_data(
-        self.send_multiple_data(lut_wb)?;
+            spi, 
+            Command::LUT_WHITE_TO_BLACK,
+            lut_wb, 
+        )?;
 
         // LUT BLACK to BLACK
-        self.command(Command::LUT_BLACK_TO_BLACK)?;
+        self.cmd_with_data(
-        self.send_multiple_data(lut_bb)?;
+            spi, 
-
+            Command::LUT_BLACK_TO_BLACK,
-        Ok(())
+            lut_bb,
+        )
     }
 }
 

src/interface.rs

@@ -2,14 +2,14 @@ use hal::{
     blocking::{delay::*, spi::Write},
     digital::*,
 };
-
+use core::marker::PhantomData;
-use interface::Command;
+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,113 +18,73 @@ 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>
+impl<SPI, CS, BUSY, DC, RST>
-    ConnectionInterface<SPI, CS, BUSY, DC, RST, Delay>
+    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 {
+    pub fn new(cs: CS, busy: BUSY, dc: DC, rst: RST) -> Self {
-        ConnectionInterface {
+        DisplayInterface {
-            spi,
+            _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()]))
+        self.write(spi, &[command.address()])
     }
 
-    /// Basic function for sending a single u8 of data over spi
+    /// Basic function for sending an array of u8-values of data over spi
     ///
-    /// Enables direct interaction with the device with the help of [Ecommand()](ConnectionInterface::command())
+    /// Enables direct interaction with the device with the help of [command()](EPD4in2::command())
     /// 
     /// //TODO: make public?
-    pub(crate) fn data(&mut self, val: 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) over spi
+        // Transfer data (u8-array) over spi
-        self.with_cs(|epd| epd.spi.write(&[val]))
+        self.write(spi, data)
     }
 
     /// 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> {
+    /// TODO: directly use ::write? cs wouldn't needed to be changed twice than
-       self.command(command)?;
+    pub(crate) fn cmd_with_data<T: Command>(&mut self, spi: &mut SPI, command: T, data: &[u8]) -> Result<(), SPI::Error> {
-       self.multiple_data(data)
+       self.cmd(spi, command)?;
-    }
+       self.data(spi, data)
-
-    /// Basic function for sending the same byte of data (one u8) multiple times over spi
-    ///
-    /// Enables direct interaction with the device with the help of [command()](ConnectionInterface::command())
-    /// 
-    /// //TODO: make public?
-    pub(crate) fn data_x_times(
-        &mut self,
-        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(())
-        })
-    }
-
-    /// Basic function for sending an array of u8-values of data over spi
-    ///
-    /// Enables direct interaction with the device with the help of [command()](EPD4in2::command())
-    /// 
-    /// //TODO: make public?
-    pub(crate) fn multiple_data(&mut self, data: &[u8]) -> Result<(), ERR> {
-        // high for data
-        self.dc.set_high();
-
-        // Transfer data (u8-array) over spi
-        self.with_cs(|epd| epd.spi.write(data))
     }
 
     // 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
         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
+            //TODO: REMOVAL of DELAY: it's only waiting for the signal anyway and should continue work asap
-            self.delay_ms(5);
+            //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);
     }
 }

src/lib.rs

@@ -50,11 +50,14 @@ use hal::spi::{Mode, Phase, Polarity};
 #[cfg(feature = "graphics")]
 pub mod drawing;
 
-mod interface;
+mod traits;
-pub use interface::{WaveshareInterface};
+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")]

src/traits.rs

@@ -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(
+    fn new<DELAY: DelayMs<u8>>(
-        spi: SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: Delay,
+        spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY,
-    ) -> Result<Self, ERR>
+    ) -> 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>;
 }

src/type_a/command.rs

@@ -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() {