Run cargo fmt (reverted for constants and some graphic calculations)

src/color.rs

@@ -1,6 +1,5 @@
 //! B/W Color for EPDs
 
-
 /// Only for the Black/White-Displays
 #[derive(Clone, Copy, PartialEq, Debug)]
 pub enum Color {
@@ -34,7 +33,10 @@ impl Color {
         match val {
             0 => Color::Black,
             1 => Color::White,
-            e => panic!("DisplayColor only parses 0 and 1 (Black and White) and not `{}`", e),
+            e => panic!(
+                "DisplayColor only parses 0 and 1 (Black and White) and not `{}`",
+                e
+            ),
         }
     }
 
@@ -60,8 +62,6 @@ impl From<u8> for Color {
     }
 }
 
-
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/epd1in54/graphics.rs

@@ -1,4 +1,4 @@
-use epd1in54::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
+use epd1in54::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
 
 /// Full size buffer for use with the 1in54 EPD
 ///
@@ -11,23 +11,20 @@ pub struct Buffer1in54BlackWhite {
 impl Default for Buffer1in54BlackWhite {
     fn default() -> Self {
         Buffer1in54BlackWhite {
-            buffer: [
-                DEFAULT_BACKGROUND_COLOR.get_byte_value();
-                WIDTH as usize * HEIGHT as usize / 8                
-            ]
+            buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value();
+                WIDTH as usize * HEIGHT as usize / 8],
         }
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use graphics::{DisplayRotation, Display};
-    use embedded_graphics::coord::Coord;
-    use embedded_graphics::primitives::Line;
     use color::Color;
+    use embedded_graphics::coord::Coord;
     use embedded_graphics::prelude::*;
+    use embedded_graphics::primitives::Line;
+    use graphics::{Display, DisplayRotation};
 
     // test buffer length
     #[test]
@@ -107,7 +104,6 @@ mod tests {
         for &byte in buffer.iter().skip(1) {
             assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
         }
-        
     }
 
     #[test]
@@ -131,6 +127,5 @@ mod tests {
         for &byte in buffer.iter().skip(1) {
             assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
         }
-        
     }
 }

src/epd1in54/mod.rs

@@ -45,12 +45,12 @@ use hal::{
 
 use type_a::{
     command::Command,
-    constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}
+    constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE},
 };
 
 use color::Color;
 
-use traits::{WaveshareDisplay, RefreshLUT};
+use traits::{RefreshLUT, WaveshareDisplay};
 
 use interface::DisplayInterface;
 
@@ -76,7 +76,11 @@ where
     DC: OutputPin,
     RST: OutputPin,
 {
-    fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
+    fn init<DELAY: DelayMs<u8>>(
+        &mut self,
+        spi: &mut SPI,
+        delay: &mut DELAY,
+    ) -> Result<(), SPI::Error> {
         self.interface.reset(delay);
 
         // 3 Databytes:
@@ -87,7 +91,7 @@ where
         self.interface.cmd_with_data(
             spi,
             Command::DRIVER_OUTPUT_CONTROL,
-            &[HEIGHT as u8, (HEIGHT >> 8) as u8, 0x00]
+            &[HEIGHT as u8, (HEIGHT >> 8) as u8, 0x00],
         )?;
 
         // 3 Databytes: (and default values from datasheet and arduino)
@@ -95,24 +99,31 @@ where
         // 1 .. B[6:0]  = 0xCE | 0xD6
         // 1 .. C[6:0]  = 0x8D | 0x9D
         //TODO: test
-        self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START_CONTROL, &[0xD7, 0xD6, 0x9D])?;
+        self.interface.cmd_with_data(
+            spi,
+            Command::BOOSTER_SOFT_START_CONTROL,
+            &[0xD7, 0xD6, 0x9D],
+        )?;
 
         // One Databyte with value 0xA8 for 7V VCOM
-        self.interface.cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
+        self.interface
+            .cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
 
         // One Databyte with default value 0x1A for 4 dummy lines per gate
-        self.interface.cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
+        self.interface
+            .cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
 
         // One Databyte with default value 0x08 for 2us per line
-        self.interface.cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
+        self.interface
+            .cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
 
         // One Databyte with default value 0x03
         //  -> address: x increment, y increment, address counter is updated in x direction
-        self.interface.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
+        self.interface
+            .cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
 
         self.set_lut(spi, None)
     }
-
 }
 
 impl<SPI, CS, BUSY, DC, RST, E> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
@@ -133,14 +144,19 @@ where
     }
 
     fn new<DELAY: DelayMs<u8>>(
-        spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY,
+        spi: &mut SPI,
+        cs: CS,
+        busy: BUSY,
+        dc: DC,
+        rst: RST,
+        delay: &mut DELAY,
     ) -> Result<Self, SPI::Error> {
         let interface = DisplayInterface::new(cs, busy, dc, rst);
 
         let mut epd = EPD1in54 {
             interface,
             background_color: DEFAULT_BACKGROUND_COLOR,
-            refresh: RefreshLUT::FULL
+            refresh: RefreshLUT::FULL,
         };
 
         epd.init(spi, delay)?;
@@ -148,16 +164,19 @@ where
         Ok(epd)
     }
 
-    fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
+    fn wake_up<DELAY: DelayMs<u8>>(
+        &mut self,
+        spi: &mut SPI,
+        delay: &mut DELAY,
+    ) -> Result<(), SPI::Error> {
         self.init(spi, delay)
     }
 
-    
-
     fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
         // 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
         //TODO: is 0x00 needed here or would 0x01 be even more efficient?
-        self.interface.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
+        self.interface
+            .cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
 
         self.wait_until_idle();
         Ok(())
@@ -165,7 +184,8 @@ where
 
     fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
         self.use_full_frame(spi)?;
-        self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
+        self.interface
+            .cmd_with_data(spi, Command::WRITE_RAM, buffer)
     }
 
     //TODO: update description: last 3 bits will be ignored for width and x_pos
@@ -181,13 +201,15 @@ where
         self.set_ram_area(spi, x, y, x + width, y + height)?;
         self.set_ram_counter(spi, x, y)?;
 
-        self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
+        self.interface
+            .cmd_with_data(spi, Command::WRITE_RAM, buffer)
     }
 
     fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
         // enable clock signal, enable cp, display pattern -> 0xC4 (tested with the arduino version)
         //TODO: test control_1 or control_2 with default value 0xFF (from the datasheet)
-        self.interface.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
+        self.interface
+            .cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
 
         self.interface.cmd(spi, Command::MASTER_ACTIVATION)?;
         // MASTER Activation should not be interupted to avoid currption of panel images
@@ -202,34 +224,29 @@ where
         let color = self.background_color.get_byte_value();
 
         //TODO: this is using a big buffer atm, is it better to just loop over sending a single byte?
-        self.interface.cmd(
-            spi,
-            Command::WRITE_RAM
-        )?;
+        self.interface.cmd(spi, Command::WRITE_RAM)?;
         self.interface.data_x_times(spi, color, WIDTH / 8 * HEIGHT)
     }
 
-
     fn set_background_color(&mut self, background_color: Color) {
         self.background_color = background_color;
     }
 
-
     fn background_color(&self) -> &Color {
         &self.background_color
     }
 
-    fn set_lut(&mut self, spi: &mut SPI, refresh_rate: Option<RefreshLUT>) -> Result<(), SPI::Error> {
+    fn set_lut(
+        &mut self,
+        spi: &mut SPI,
+        refresh_rate: Option<RefreshLUT>,
+    ) -> Result<(), SPI::Error> {
         if let Some(refresh_lut) = refresh_rate {
             self.refresh = refresh_lut;
         }
         match self.refresh {
-            RefreshLUT::FULL => {
-                self.set_lut_helper(spi, &LUT_FULL_UPDATE)
-            },
-            RefreshLUT::QUICK => {
-                self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE)
-            }
+            RefreshLUT::FULL => self.set_lut_helper(spi, &LUT_FULL_UPDATE),
+            RefreshLUT::QUICK => self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE),
         }
     }
 }
@@ -240,7 +257,7 @@ where
     CS: OutputPin,
     BUSY: InputPin,
     DC: OutputPin,
-    RST: OutputPin
+    RST: OutputPin,
 {
     fn wait_until_idle(&mut self) {
         self.interface.wait_until_idle(false);
@@ -270,30 +287,39 @@ where
         self.interface.cmd_with_data(
             spi,
             Command::SET_RAM_X_ADDRESS_START_END_POSITION,
-            &[(start_x >> 3) as u8, (end_x >> 3) as u8]
+            &[(start_x >> 3) as u8, (end_x >> 3) as u8],
         )?;
 
         // 2 Databytes: A[7:0] & 0..A[8] for each - start and end
         self.interface.cmd_with_data(
             spi,
             Command::SET_RAM_Y_ADDRESS_START_END_POSITION,
-            &[start_y as u8, (start_y >> 8) as u8, end_y as u8, (end_y >> 8) as u8]
+            &[
+                start_y as u8,
+                (start_y >> 8) as u8,
+                end_y as u8,
+                (end_y >> 8) as u8,
+            ],
         )
     }
 
-    pub(crate) fn set_ram_counter(&mut self, spi: &mut SPI, x: u32, y: u32) -> Result<(), SPI::Error> {
+    pub(crate) fn set_ram_counter(
+        &mut self,
+        spi: &mut SPI,
+        x: u32,
+        y: u32,
+    ) -> Result<(), SPI::Error> {
         // x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
         // aren't relevant
-        self.interface.cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?;
+        self.interface
+            .cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?;
 
         // 2 Databytes: A[7:0] & 0..A[8]
         self.interface.cmd_with_data(
             spi,
             Command::SET_RAM_Y_ADDRESS_COUNTER,
-            &[
-                y as u8, 
-                (y >> 8) as u8
-        ])?;
+            &[y as u8, (y >> 8) as u8],
+        )?;
 
         self.wait_until_idle();
         Ok(())
@@ -301,7 +327,8 @@ where
 
     fn set_lut_helper(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
         assert!(buffer.len() == 30);
-        self.interface.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
+        self.interface
+            .cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
     }
 }
 

src/epd2in9/graphics.rs

@@ -1,4 +1,4 @@
-use epd2in9::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
+use epd2in9::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
 
 /// Full size buffer for use with the 2in9 EPD
 ///
@@ -11,15 +11,12 @@ pub struct Buffer2in9 {
 impl Default for Buffer2in9 {
     fn default() -> Self {
         Buffer2in9 {
-            buffer: [
-                DEFAULT_BACKGROUND_COLOR.get_byte_value();
-                WIDTH as usize * HEIGHT as usize / 8                
-            ]
+            buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value();
+                WIDTH as usize * HEIGHT as usize / 8],
         }
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/epd2in9/mod.rs

@@ -46,7 +46,7 @@ use hal::{
 
 use type_a::{
     command::Command,
-    constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}
+    constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE},
 };
 
 use color::Color;
@@ -77,7 +77,11 @@ where
     DC: OutputPin,
     RST: OutputPin,
 {
-    fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
+    fn init<DELAY: DelayMs<u8>>(
+        &mut self,
+        spi: &mut SPI,
+        delay: &mut DELAY,
+    ) -> Result<(), SPI::Error> {
         self.interface.reset(delay);
 
         // 3 Databytes:
@@ -85,34 +89,42 @@ where
         // 0.. A[8]
         // 0.. B[2:0]
         // Default Values: A = Height of Screen (0x127), B = 0x00 (GD, SM and TB=0?)
-        self.interface.cmd_with_data(spi, Command::DRIVER_OUTPUT_CONTROL, &[0x27, 0x01, 0x00])?;
+        self.interface
+            .cmd_with_data(spi, Command::DRIVER_OUTPUT_CONTROL, &[0x27, 0x01, 0x00])?;
 
         // 3 Databytes: (and default values from datasheet and arduino)
         // 1 .. A[6:0]  = 0xCF | 0xD7
         // 1 .. B[6:0]  = 0xCE | 0xD6
         // 1 .. C[6:0]  = 0x8D | 0x9D
         //TODO: test
-        self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START_CONTROL, &[0xD7, 0xD6, 0x9D])?;
+        self.interface.cmd_with_data(
+            spi,
+            Command::BOOSTER_SOFT_START_CONTROL,
+            &[0xD7, 0xD6, 0x9D],
+        )?;
 
         // One Databyte with value 0xA8 for 7V VCOM
-        self.interface.cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
+        self.interface
+            .cmd_with_data(spi, Command::WRITE_VCOM_REGISTER, &[0xA8])?;
 
         // One Databyte with default value 0x1A for 4 dummy lines per gate
-        self.interface.cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
+        self.interface
+            .cmd_with_data(spi, Command::SET_DUMMY_LINE_PERIOD, &[0x1A])?;
 
         // One Databyte with default value 0x08 for 2us per line
-        self.interface.cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
+        self.interface
+            .cmd_with_data(spi, Command::SET_GATE_LINE_WIDTH, &[0x08])?;
 
         // One Databyte with default value 0x03
         //  -> address: x increment, y increment, address counter is updated in x direction
-        self.interface.cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
+        self.interface
+            .cmd_with_data(spi, Command::DATA_ENTRY_MODE_SETTING, &[0x03])?;
 
         self.set_lut(spi, None)
     }
 }
 
-impl<SPI, CS, BUSY, DC, RST>
-    WaveshareDisplay<SPI, CS, BUSY, DC, RST>
+impl<SPI, CS, BUSY, DC, RST> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
     for EPD2in9<SPI, CS, BUSY, DC, RST>
 where
     SPI: Write<u8>,
@@ -130,7 +142,12 @@ where
     }
 
     fn new<DELAY: DelayMs<u8>>(
-        spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY,
+        spi: &mut SPI,
+        cs: CS,
+        busy: BUSY,
+        dc: DC,
+        rst: RST,
+        delay: &mut DELAY,
     ) -> Result<Self, SPI::Error> {
         let interface = DisplayInterface::new(cs, busy, dc, rst);
 
@@ -145,25 +162,29 @@ where
         Ok(epd)
     }
 
-    
-
     fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
         // 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
         //TODO: is 0x00 needed here? (see also epd1in54)
-        self.interface.cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
+        self.interface
+            .cmd_with_data(spi, Command::DEEP_SLEEP_MODE, &[0x00])?;
 
         self.wait_until_idle();
         Ok(())
     }
 
-    fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
+    fn wake_up<DELAY: DelayMs<u8>>(
+        &mut self,
+        spi: &mut SPI,
+        delay: &mut DELAY,
+    ) -> Result<(), SPI::Error> {
         self.init(spi, delay)
     }
 
     fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
         self.use_full_frame(spi)?;
 
-        self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
+        self.interface
+            .cmd_with_data(spi, Command::WRITE_RAM, buffer)
     }
 
     //TODO: update description: last 3 bits will be ignored for width and x_pos
@@ -179,13 +200,15 @@ where
         self.set_ram_area(spi, x, y, x + width, y + height)?;
         self.set_ram_counter(spi, x, y)?;
 
-        self.interface.cmd_with_data(spi, Command::WRITE_RAM, buffer)
+        self.interface
+            .cmd_with_data(spi, Command::WRITE_RAM, buffer)
     }
 
     fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
         // enable clock signal, enable cp, display pattern -> 0xC4 (tested with the arduino version)
         //TODO: test control_1 or control_2 with default value 0xFF (from the datasheet)
-        self.interface.cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
+        self.interface
+            .cmd_with_data(spi, Command::DISPLAY_UPDATE_CONTROL_2, &[0xC4])?;
 
         self.interface.cmd(spi, Command::MASTER_ACTIVATION)?;
         // MASTER Activation should not be interupted to avoid currption of panel images
@@ -212,17 +235,17 @@ where
         &self.background_color
     }
 
-    fn set_lut(&mut self, spi: &mut SPI, refresh_rate: Option<RefreshLUT>) -> Result<(), SPI::Error> {
+    fn set_lut(
+        &mut self,
+        spi: &mut SPI,
+        refresh_rate: Option<RefreshLUT>,
+    ) -> Result<(), SPI::Error> {
         if let Some(refresh_lut) = refresh_rate {
             self.refresh = refresh_lut;
         }
         match self.refresh {
-            RefreshLUT::FULL => {
-                self.set_lut_helper(spi, &LUT_FULL_UPDATE)
-            },
-            RefreshLUT::QUICK => {
-                self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE)
-            }
+            RefreshLUT::FULL => self.set_lut_helper(spi, &LUT_FULL_UPDATE),
+            RefreshLUT::QUICK => self.set_lut_helper(spi, &LUT_PARTIAL_UPDATE),
         }
     }
 }
@@ -263,22 +286,34 @@ where
         self.interface.cmd_with_data(
             spi,
             Command::SET_RAM_X_ADDRESS_START_END_POSITION,
-            &[(start_x >> 3) as u8, (end_x >> 3) as u8]
+            &[(start_x >> 3) as u8, (end_x >> 3) as u8],
         )?;
 
         // 2 Databytes: A[7:0] & 0..A[8] for each - start and end
-        self.interface.cmd_with_data(spi, Command::SET_RAM_Y_ADDRESS_START_END_POSITION,
-            &[start_y as u8, (start_y >> 8) as u8, end_y as u8, (end_y >> 8) as u8]
+        self.interface.cmd_with_data(
+            spi,
+            Command::SET_RAM_Y_ADDRESS_START_END_POSITION,
+            &[
+                start_y as u8,
+                (start_y >> 8) as u8,
+                end_y as u8,
+                (end_y >> 8) as u8,
+            ],
         )
     }
 
     fn set_ram_counter(&mut self, spi: &mut SPI, x: u32, y: u32) -> Result<(), SPI::Error> {
         // x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
         // aren't relevant
-        self.interface.cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?;
+        self.interface
+            .cmd_with_data(spi, Command::SET_RAM_X_ADDRESS_COUNTER, &[(x >> 3) as u8])?;
 
         // 2 Databytes: A[7:0] & 0..A[8]
-        self.interface.cmd_with_data(spi, Command::SET_RAM_Y_ADDRESS_COUNTER, &[y as u8, (y >> 8) as u8])?;
+        self.interface.cmd_with_data(
+            spi,
+            Command::SET_RAM_Y_ADDRESS_COUNTER,
+            &[y as u8, (y >> 8) as u8],
+        )?;
 
         self.wait_until_idle();
         Ok(())
@@ -286,11 +321,11 @@ where
 
     fn set_lut_helper(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
         assert!(buffer.len() == 30);
-        self.interface.cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
+        self.interface
+            .cmd_with_data(spi, Command::WRITE_LUT_REGISTER, buffer)
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/epd4in2/constants.rs

@@ -4,7 +4,6 @@ pub const WIDTH: u32 = 400;
 pub const HEIGHT: u32 = 300;
 pub const DEFAULT_BACKGROUND_COLOR: Color = Color::White;
 
-
 pub(crate) const LUT_VCOM0: [u8; 44] = [
 0x00, 0x17, 0x00, 0x00, 0x00, 0x02,        
 0x00, 0x17, 0x17, 0x00, 0x00, 0x02,        
@@ -15,7 +14,6 @@ pub(crate) const LUT_VCOM0: [u8; 44] = [
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 ];
 
-
 pub(crate) const LUT_VCOM0_QUICK: [u8; 44] = [
 0x00, 0x0E, 0x00, 0x00, 0x00, 0x01,        
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        

src/epd4in2/graphics.rs

@@ -1,4 +1,4 @@
-use epd4in2::constants::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
+use epd4in2::constants::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
 
 /// Full size buffer for use with the 4in2 EPD
 ///
@@ -11,24 +11,21 @@ pub struct Buffer4in2 {
 impl Default for Buffer4in2 {
     fn default() -> Self {
         Buffer4in2 {
-            buffer: [
-                DEFAULT_BACKGROUND_COLOR.get_byte_value();
-                WIDTH as usize * HEIGHT as usize / 8                
-            ]
+            buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value();
+                WIDTH as usize * HEIGHT as usize / 8],
         }
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use epd4in2;
-    use graphics::{DisplayRotation, Display};
-    use embedded_graphics::coord::Coord;
-    use embedded_graphics::primitives::Line;
     use color::Color;
+    use embedded_graphics::coord::Coord;
     use embedded_graphics::prelude::*;
+    use embedded_graphics::primitives::Line;
+    use epd4in2;
+    use graphics::{Display, DisplayRotation};
 
     // test buffer length
     #[test]
@@ -45,7 +42,10 @@ mod tests {
         let display = Display::new(WIDTH, HEIGHT, &mut display4in2.buffer);
         use epd4in2;
         for &byte in display.buffer() {
-            assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
+            assert_eq!(
+                byte,
+                epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
+            );
         }
     }
 
@@ -64,7 +64,10 @@ mod tests {
         assert_eq!(buffer[0], Color::Black.get_byte_value());
 
         for &byte in buffer.iter().skip(1) {
-            assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
+            assert_eq!(
+                byte,
+                epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
+            );
         }
     }
 
@@ -84,7 +87,10 @@ mod tests {
         assert_eq!(buffer[0], Color::Black.get_byte_value());
 
         for &byte in buffer.iter().skip(1) {
-            assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
+            assert_eq!(
+                byte,
+                epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
+            );
         }
     }
 
@@ -107,9 +113,11 @@ mod tests {
         assert_eq!(buffer[0], Color::Black.get_byte_value());
 
         for &byte in buffer.iter().skip(1) {
-            assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
+            assert_eq!(
+                byte,
+                epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
+            );
         }
-        
     }
 
     #[test]
@@ -131,9 +139,10 @@ mod tests {
         assert_eq!(buffer[0], Color::Black.get_byte_value());
 
         for &byte in buffer.iter().skip(1) {
-            assert_eq!(byte, epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value());
+            assert_eq!(
+                byte,
+                epd4in2::constants::DEFAULT_BACKGROUND_COLOR.get_byte_value()
+            );
         }
-        
     }
 }
-

src/epd4in2/mod.rs

@@ -51,8 +51,8 @@ use hal::{
     digital::*,
 };
 
-use traits::{WaveshareDisplay, InternalWiAdditions, RefreshLUT};
 use interface::DisplayInterface;
+use traits::{InternalWiAdditions, RefreshLUT, WaveshareDisplay};
 
 //The Lookup Tables for the Display
 mod constants; //TODO: Limit to crate::drawing
@@ -66,7 +66,6 @@ use self::command::Command;
 mod graphics;
 pub use self::graphics::Buffer4in2;
 
-
 /// EPD4in2 driver
 ///
 pub struct EPD4in2<SPI, CS, BUSY, DC, RST> {
@@ -78,11 +77,7 @@ pub struct EPD4in2<SPI, CS, BUSY, DC, RST> {
     refresh: RefreshLUT,
 }
 
-
-
-
-impl<SPI, CS, BUSY, DC, RST>
-    InternalWiAdditions<SPI, CS, BUSY, DC, RST>
+impl<SPI, CS, BUSY, DC, RST> InternalWiAdditions<SPI, CS, BUSY, DC, RST>
     for EPD4in2<SPI, CS, BUSY, DC, RST>
 where
     SPI: Write<u8>,
@@ -91,15 +86,24 @@ where
     DC: OutputPin,
     RST: OutputPin,
 {
-    fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
+    fn init<DELAY: DelayMs<u8>>(
+        &mut self,
+        spi: &mut SPI,
+        delay: &mut DELAY,
+    ) -> Result<(), SPI::Error> {
         // reset the device
         self.interface.reset(delay);
 
         // set the power settings
-        self.interface.cmd_with_data(spi, Command::POWER_SETTING, &[0x03, 0x00, 0x2b, 0x2b, 0xff])?;
+        self.interface.cmd_with_data(
+            spi,
+            Command::POWER_SETTING,
+            &[0x03, 0x00, 0x2b, 0x2b, 0xff],
+        )?;
 
         // start the booster
-        self.interface.cmd_with_data(spi, Command::BOOSTER_SOFT_START, &[0x17, 0x17, 0x17])?;        
+        self.interface
+            .cmd_with_data(spi, Command::BOOSTER_SOFT_START, &[0x17, 0x17, 0x17])?;
 
         // power on
         self.command(spi, Command::POWER_ON)?;
@@ -121,8 +125,7 @@ where
     }
 }
 
-impl<SPI, CS, BUSY, DC, RST>
-    WaveshareDisplay<SPI, CS, BUSY, DC, RST>
+impl<SPI, CS, BUSY, DC, RST> WaveshareDisplay<SPI, CS, BUSY, DC, RST>
     for EPD4in2<SPI, CS, BUSY, DC, RST>
 where
     SPI: Write<u8>,
@@ -146,14 +149,21 @@ where
     ///
     /// epd4in2.sleep();
     /// ```
-    fn new<DELAY: DelayMs<u8>>(spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY) -> Result<Self, SPI::Error> {
+    fn new<DELAY: DelayMs<u8>>(
+        spi: &mut SPI,
+        cs: CS,
+        busy: BUSY,
+        dc: DC,
+        rst: RST,
+        delay: &mut DELAY,
+    ) -> Result<Self, SPI::Error> {
         let interface = DisplayInterface::new(cs, busy, dc, rst);
         let color = DEFAULT_BACKGROUND_COLOR;
 
         let mut epd = EPD4in2 {
             interface,
             color,
-            refresh: RefreshLUT::FULL
+            refresh: RefreshLUT::FULL,
         };
 
         epd.init(spi, delay)?;
@@ -161,12 +171,17 @@ where
         Ok(epd)
     }
 
-    fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error> {
+    fn wake_up<DELAY: DelayMs<u8>>(
+        &mut self,
+        spi: &mut SPI,
+        delay: &mut DELAY,
+    ) -> Result<(), SPI::Error> {
         self.init(spi, delay)
     }
 
     fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
-        self.interface.cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x17])?; //border floating
+        self.interface
+            .cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x17])?; //border floating
         self.command(spi, Command::VCM_DC_SETTING)?; // VCOM to 0V
         self.command(spi, Command::PANEL_SETTING)?;
 
@@ -177,7 +192,8 @@ where
 
         self.command(spi, Command::POWER_OFF)?;
         self.wait_until_idle();
-        self.interface.cmd_with_data(spi, Command::DEEP_SLEEP, &[0xA5])
+        self.interface
+            .cmd_with_data(spi, Command::DEEP_SLEEP, &[0xA5])
     }
 
     fn update_frame(&mut self, spi: &mut SPI, buffer: &[u8]) -> Result<(), SPI::Error> {
@@ -185,15 +201,20 @@ where
 
         self.send_resolution(spi)?;
 
-        self.interface.cmd_with_data(spi, Command::VCM_DC_SETTING, &[0x12])?;
+        self.interface
+            .cmd_with_data(spi, Command::VCM_DC_SETTING, &[0x12])?;
 
         //VBDF 17|D7 VBDW 97  VBDB 57  VBDF F7  VBDW 77  VBDB 37  VBDR B7
-        self.interface.cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x97])?;
+        self.interface
+            .cmd_with_data(spi, Command::VCOM_AND_DATA_INTERVAL_SETTING, &[0x97])?;
 
-        self.interface.cmd(spi, Command::DATA_START_TRANSMISSION_1)?;
-        self.interface.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)?;
+        self.interface
+            .cmd(spi, Command::DATA_START_TRANSMISSION_1)?;
+        self.interface
+            .data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)?;
 
-        self.interface.cmd_with_data(spi, Command::DATA_START_TRANSMISSION_2, buffer)
+        self.interface
+            .cmd_with_data(spi, Command::DATA_START_TRANSMISSION_2, buffer)
     }
 
     fn update_partial_frame(
@@ -240,8 +261,6 @@ where
         self.command(spi, Command::PARTIAL_OUT)
     }
 
-
-
     fn display_frame(&mut self, spi: &mut SPI) -> Result<(), SPI::Error> {
         self.command(spi, Command::DISPLAY_REFRESH)?;
 
@@ -254,14 +273,18 @@ where
 
         let color_value = self.color.get_byte_value();
 
-        self.interface.cmd(spi, Command::DATA_START_TRANSMISSION_1)?;
-        self.interface.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)?;
+        self.interface
+            .cmd(spi, Command::DATA_START_TRANSMISSION_1)?;
+        self.interface
+            .data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)?;
 
         //TODO: Removal of delay. TEST!
         //self.delay_ms(2);
 
-        self.interface.cmd(spi, Command::DATA_START_TRANSMISSION_2)?;
-        self.interface.data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)
+        self.interface
+            .cmd(spi, Command::DATA_START_TRANSMISSION_2)?;
+        self.interface
+            .data_x_times(spi, color_value, WIDTH / 8 * HEIGHT)
     }
 
     fn set_background_color(&mut self, color: Color) {
@@ -280,24 +303,26 @@ where
         HEIGHT
     }
 
-    fn set_lut(&mut self, spi: &mut SPI, refresh_rate: Option<RefreshLUT>) -> Result<(), SPI::Error> {
+    fn set_lut(
+        &mut self,
+        spi: &mut SPI,
+        refresh_rate: Option<RefreshLUT>,
+    ) -> Result<(), SPI::Error> {
         if let Some(refresh_lut) = refresh_rate {
             self.refresh = refresh_lut;
         }
         match self.refresh {
             RefreshLUT::FULL => {
                 self.set_lut_helper(spi, &LUT_VCOM0, &LUT_WW, &LUT_BW, &LUT_WB, &LUT_BB)
-            },
-            RefreshLUT::QUICK => {
-                self.set_lut_helper(
+            }
+            RefreshLUT::QUICK => self.set_lut_helper(
                 spi,
                 &LUT_VCOM0_QUICK,
                 &LUT_WW_QUICK,
                 &LUT_BW_QUICK,
                 &LUT_WB_QUICK,
                 &LUT_BB_QUICK,
-                )
-            }
+            ),
         }
     }
 }
@@ -318,7 +343,12 @@ where
         self.interface.data(spi, data)
     }
 
-    fn cmd_with_data(&mut self, spi: &mut SPI, command: Command, data: &[u8]) -> Result<(), SPI::Error> {
+    fn cmd_with_data(
+        &mut self,
+        spi: &mut SPI,
+        command: Command,
+        data: &[u8],
+    ) -> Result<(), SPI::Error> {
         self.interface.cmd_with_data(spi, command, data)
     }
 
@@ -347,43 +377,22 @@ where
         lut_bb: &[u8],
     ) -> Result<(), SPI::Error> {
         // LUT VCOM
-        self.cmd_with_data(
-            spi, 
-            Command::LUT_FOR_VCOM,
-            lut_vcom
-        )?;
+        self.cmd_with_data(spi, Command::LUT_FOR_VCOM, lut_vcom)?;
 
         // LUT WHITE to WHITE
-        self.cmd_with_data(
-            spi,
-            Command::LUT_WHITE_TO_WHITE, 
-            lut_ww
-        )?;
+        self.cmd_with_data(spi, Command::LUT_WHITE_TO_WHITE, lut_ww)?;
 
         // LUT BLACK to WHITE
-        self.cmd_with_data(
-            spi,
-            Command::LUT_BLACK_TO_WHITE,
-            lut_bw 
-        )?;
+        self.cmd_with_data(spi, Command::LUT_BLACK_TO_WHITE, lut_bw)?;
 
         // LUT WHITE to BLACK
-        self.cmd_with_data(
-            spi, 
-            Command::LUT_WHITE_TO_BLACK,
-            lut_wb, 
-        )?;
+        self.cmd_with_data(spi, Command::LUT_WHITE_TO_BLACK, lut_wb)?;
 
         // LUT BLACK to BLACK
-        self.cmd_with_data(
-            spi, 
-            Command::LUT_BLACK_TO_BLACK,
-            lut_bb,
-        )
+        self.cmd_with_data(spi, Command::LUT_BLACK_TO_BLACK, lut_bb)
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/graphics.rs

@@ -60,14 +60,12 @@ impl<'a> Display<'a> {
     }
 }
 
-
 impl<'a> Drawing<Color> for Display<'a> {
     fn draw<T>(&mut self, item_pixels: T)
     where
-        T: Iterator<Item = Pixel<Color>>
+        T: Iterator<Item = Pixel<Color>>,
     {
-        for Pixel(UnsignedCoord(x,y), color) in item_pixels {
-
+        for Pixel(UnsignedCoord(x, y), color) in item_pixels {
             if outside_display(x, y, self.width, self.height, self.rotation) {
                 continue;
             }
@@ -89,14 +87,13 @@ impl<'a> Drawing<Color> for Display<'a> {
     }
 }
 
-
 fn outside_display(x: u32, y: u32, width: u32, height: u32, rotation: DisplayRotation) -> bool {
     match rotation {
         DisplayRotation::Rotate0 | DisplayRotation::Rotate180 => {
             if x >= width || y >= height {
                 return true;
             }
-        },
+        }
         DisplayRotation::Rotate90 | DisplayRotation::Rotate270 => {
             if y >= width || x >= height {
                 return true;
@@ -127,19 +124,17 @@ fn rotation(x: u32, y: u32, width: u32, height: u32, rotation: DisplayRotation)
     }
 }
 
-
-
 #[cfg(test)]
 mod tests {
-    use super::{DisplayRotation, outside_display, rotation, Display};
+    use super::{outside_display, rotation, Display, DisplayRotation};
     use color::Color;
     use embedded_graphics::coord::Coord;
-    use embedded_graphics::primitives::Line;
     use embedded_graphics::prelude::*;
+    use embedded_graphics::primitives::Line;
 
     #[test]
     fn buffer_clear() {
-        use epd4in2::{WIDTH, HEIGHT};
+        use epd4in2::{HEIGHT, WIDTH};
 
         let mut buffer = [Color::Black.get_byte_value(); WIDTH as usize / 8 * HEIGHT as usize];
         let mut display = Display::new(WIDTH, HEIGHT, &mut buffer);
@@ -155,22 +150,21 @@ mod tests {
         }        
     }
 
-
     #[test]
     fn rotation_overflow() {
-        use epd4in2::{WIDTH, HEIGHT};
+        use epd4in2::{HEIGHT, WIDTH};
         let width = WIDTH as u32;
         let height = HEIGHT as u32;
         test_rotation_overflow(width, height, DisplayRotation::Rotate0);
         test_rotation_overflow(width, height, DisplayRotation::Rotate90);
         test_rotation_overflow(width, height, DisplayRotation::Rotate180);
         test_rotation_overflow(width, height, DisplayRotation::Rotate270);
-        
     }
 
     fn test_rotation_overflow(width: u32, height: u32, rotation2: DisplayRotation) {
         let max_value = width / 8 * height;
-        for x in 0..(width + height) { //limit x because it runs too long 
+        for x in 0..(width + height) {
+            //limit x because it runs too long
             for y in 0..(u32::max_value()) {
                 if outside_display(x, y, width, height, rotation2) {
                     break;
@@ -182,11 +176,9 @@ mod tests {
         }
     }
 
-
-
     #[test]
     fn graphics_rotation_0() {
-        use epd2in9::{DEFAULT_BACKGROUND_COLOR};        
+        use epd2in9::DEFAULT_BACKGROUND_COLOR;
         let width = 128;
         let height = 296;
         
@@ -210,7 +202,7 @@ mod tests {
 
     #[test]
     fn graphics_rotation_90() {
-        use epd2in9::{DEFAULT_BACKGROUND_COLOR};        
+        use epd2in9::DEFAULT_BACKGROUND_COLOR;
         let width = 128;
         let height = 296;
         

src/interface.rs

@@ -1,8 +1,8 @@
+use core::marker::PhantomData;
 use hal::{
     blocking::{delay::*, spi::Write},
     digital::*,
 };
-use core::marker::PhantomData;
 use traits::Command;
 
 /// The Connection Interface of all (?) Waveshare EPD-Devices
@@ -20,8 +20,7 @@ pub(crate) struct DisplayInterface<SPI, CS, BUSY, DC, RST> {
     rst: RST,
 }
 
-impl<SPI, CS, BUSY, DC, RST>
-    DisplayInterface<SPI, CS, BUSY, DC, RST>
+impl<SPI, CS, BUSY, DC, RST> DisplayInterface<SPI, CS, BUSY, DC, RST>
 where
     SPI: Write<u8>,
     CS: OutputPin,
@@ -64,12 +63,16 @@ where
     /// Basic function for sending [Commands](Command) and the data belonging to it.
     ///
     /// TODO: directly use ::write? cs wouldn't needed to be changed twice than
-    pub(crate) fn cmd_with_data<T: Command>(&mut self, spi: &mut SPI, command: T, data: &[u8]) -> Result<(), SPI::Error> {
+    pub(crate) fn cmd_with_data<T: Command>(
+        &mut self,
+        spi: &mut SPI,
+        command: T,
+        data: &[u8],
+    ) -> Result<(), SPI::Error> {
         self.cmd(spi, command)?;
         self.data(spi, data)
     }
 
-
     /// Basic function for sending the same byte of data (one u8) multiple times over spi
     ///
     /// Enables direct interaction with the device with the help of [command()](ConnectionInterface::command())
@@ -89,8 +92,7 @@ where
     }
 
     // spi write helper/abstraction function
-    fn write(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error>
-    {
+    fn write(&mut self, spi: &mut SPI, data: &[u8]) -> Result<(), SPI::Error> {
         // activate spi with cs low
         self.cs.set_low();
 

src/lib.rs

@@ -67,12 +67,11 @@ pub mod epd2in9;
 pub(crate) mod type_a;
 
 pub mod prelude {
-    pub use traits::{WaveshareDisplay, RefreshLUT};
     pub use color::Color;
+    pub use traits::{RefreshLUT, WaveshareDisplay};
     pub use SPI_MODE;
 }
 
-
 extern crate embedded_hal as hal;
 use hal::spi::{Mode, Phase, Polarity};
 

src/traits.rs

@@ -1,10 +1,9 @@
+use color::Color;
 use core::marker::Sized;
 use hal::{
     blocking::{delay::*, spi::Write},
     digital::*,
 };
-use color::Color;
-
 
 /// All commands need to have this trait which gives the address of the command
 /// which needs to be send via SPI with activated CommandsPin (Data/Command Pin in CommandMode)
@@ -18,7 +17,7 @@ pub enum RefreshLUT {
     FULL,
     /// The quick LUT where not the full refresh sequence is followed.
     /// This might lead to some
-    QUICK
+    QUICK,
 }
 
 impl Default for RefreshLUT {
@@ -45,10 +44,13 @@ where
     /// This function calls [reset()](WaveshareInterface::reset()),
     /// so you don't need to call reset your self when trying to wake your device up
     /// after setting it to sleep.
-    fn init<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error>;
+    fn init<DELAY: DelayMs<u8>>(
+        &mut self,
+        spi: &mut SPI,
+        delay: &mut DELAY,
+    ) -> Result<(), SPI::Error>;
 }
 
-
 /// All the functions to interact with the EPDs
 ///
 /// This trait includes all public functions to use the EPDS
@@ -64,7 +66,12 @@ where
     ///
     /// This already initialises the device. That means [init()](WaveshareInterface::init()) isn't needed directly afterwards
     fn new<DELAY: DelayMs<u8>>(
-        spi: &mut SPI, cs: CS, busy: BUSY, dc: DC, rst: RST, delay: &mut DELAY,
+        spi: &mut SPI,
+        cs: CS,
+        busy: BUSY,
+        dc: DC,
+        rst: RST,
+        delay: &mut DELAY,
     ) -> Result<Self, SPI::Error>
     where
         Self: Sized;
@@ -78,7 +85,11 @@ where
     fn sleep(&mut self, spi: &mut SPI) -> Result<(), SPI::Error>;
 
     /// Wakes the device up from sleep
-    fn wake_up<DELAY: DelayMs<u8>>(&mut self, spi: &mut SPI, delay: &mut DELAY) -> Result<(), SPI::Error>;    
+    fn wake_up<DELAY: DelayMs<u8>>(
+        &mut self,
+        spi: &mut SPI,
+        delay: &mut DELAY,
+    ) -> Result<(), SPI::Error>;
 
     /// Sets the backgroundcolor for various commands like [clear_frame()](WaveshareInterface::clear_frame())
     fn set_background_color(&mut self, color: Color);
@@ -125,5 +136,9 @@ where
     /// WARNING: Quick Refresh might lead to ghosting-effects/problems with your display. Especially for the 4.2in Display!
     ///
     /// If None is used the old value will be loaded on the LUTs once more
-    fn set_lut(&mut self, spi: &mut SPI, refresh_rate: Option<RefreshLUT>) -> Result<(), SPI::Error>;
+    fn set_lut(
+        &mut self,
+        spi: &mut SPI,
+        refresh_rate: Option<RefreshLUT>,
+    ) -> Result<(), SPI::Error>;
 }