From e518265273c8252cc9c04faebdc5c871bb2ead91 Mon Sep 17 00:00:00 2001
From: Chris <github@caemor.de>
Date: Mon, 5 Nov 2018 15:31:52 +0100
Subject: [PATCH] Run cargo fmt (reverted for constants and some graphic
 calculations)

---
 src/color.rs             |  14 ++--
 src/epd1in54/graphics.rs |  35 ++++-----
 src/epd1in54/mod.rs      | 141 +++++++++++++++++++++---------------
 src/epd2in9/graphics.rs  |  17 ++---
 src/epd2in9/mod.rs       | 119 ++++++++++++++++++++-----------
 src/epd4in2/constants.rs |   2 -
 src/epd4in2/graphics.rs  |  59 +++++++++-------
 src/epd4in2/mod.rs       | 149 +++++++++++++++++++++------------------
 src/graphics.rs          |  32 ++++-----
 src/interface.rs         |  26 +++----
 src/lib.rs               |   3 +-
 src/traits.rs            |  51 +++++++++-----
 src/type_a/constants.rs  |   2 +-
 src/type_a/mod.rs        |   2 +-
 14 files changed, 365 insertions(+), 287 deletions(-)

diff --git a/src/color.rs b/src/color.rs
index 8c2ab0e..e9223de 100644
--- a/src/color.rs
+++ b/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,12 +33,15 @@ 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
+            ),
         }
     }
 
-    /// Returns the inverse of the given color. 
-    /// 
+    /// Returns the inverse of the given color.
+    ///
     /// Black returns White and White returns Black
     pub fn inverse(self) -> Color {
         match self {
@@ -60,8 +62,6 @@ impl From<u8> for Color {
     }
 }
 
-
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -79,7 +79,7 @@ mod tests {
             extern crate std;
             let result = std::panic::catch_unwind(|| Color::from(val));
             assert!(result.is_err());
-        }        
+        }
     }
 
     #[test]
diff --git a/src/epd1in54/graphics.rs b/src/epd1in54/graphics.rs
index 1a9d620..b787574 100644
--- a/src/epd1in54/graphics.rs
+++ b/src/epd1in54/graphics.rs
@@ -1,9 +1,9 @@
-use epd1in54::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
+use epd1in54::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
 
 /// Full size buffer for use with the 1in54 EPD
-/// 
+///
 /// Can also be manuall constructed:
-/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]` 
+/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
 pub struct Buffer1in54BlackWhite {
     pub buffer: [u8; WIDTH as usize * HEIGHT as usize / 8],
 }
@@ -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]
@@ -36,7 +33,7 @@ mod tests {
         let display = Display::new(WIDTH, HEIGHT, &mut display1in54.buffer);
         assert_eq!(display.buffer().len(), 5000);
     }
-    
+
     // test default background color on all bytes
     #[test]
     fn graphics_default() {
@@ -56,7 +53,7 @@ mod tests {
                 .with_stroke(Some(Color::Black))
                 .into_iter(),
         );
-        
+
         let buffer = display.buffer();
 
         assert_eq!(buffer[0], Color::Black.get_byte_value());
@@ -76,7 +73,7 @@ mod tests {
                 .with_stroke(Some(Color::Black))
                 .into_iter(),
         );
-        
+
         let buffer = display.buffer();
 
         assert_eq!(buffer[0], Color::Black.get_byte_value());
@@ -96,7 +93,7 @@ mod tests {
                 .with_stroke(Some(Color::Black))
                 .into_iter(),
         );
-        
+
         let buffer = display.buffer();
 
         extern crate std;
@@ -107,7 +104,6 @@ mod tests {
         for &byte in buffer.iter().skip(1) {
             assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
         }
-        
     }
 
     #[test]
@@ -120,7 +116,7 @@ mod tests {
                 .with_stroke(Some(Color::Black))
                 .into_iter(),
         );
-        
+
         let buffer = display.buffer();
 
         extern crate std;
@@ -131,6 +127,5 @@ mod tests {
         for &byte in buffer.iter().skip(1) {
             assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
         }
-        
     }
-}
\ No newline at end of file
+}
diff --git a/src/epd1in54/mod.rs b/src/epd1in54/mod.rs
index 6ea0ab1..9f8aaa1 100644
--- a/src/epd1in54/mod.rs
+++ b/src/epd1in54/mod.rs
@@ -1,21 +1,21 @@
 //! A simple Driver for the Waveshare 1.54" E-Ink Display via SPI
-//! 
+//!
 //! # Example for the 1.54 in E-Ink Display
-//! 
+//!
 //! ```ignore
 //! use eink_waveshare_rs::{
 //!     epd1in54::{EPD1in54, Buffer1in54},
 //!     graphics::{Display, DisplayRotation},
 //!     prelude::*,
-//! }; 
-//! 
+//! };
+//!
 //! // Setup EPD
 //! let mut epd = EPD1in54::new(&mut spi, cs_pin, busy_in, dc, rst, &mut delay)?;
 //!
 //! // Use display graphics
 //! let mut buffer = Buffer1in54::default();
 //! let mut display = Display::new(epd.width(), epd.height(), &mut buffer.buffer);
-//! 
+//!
 //! // Write some hello world in the screenbuffer
 //! display.draw(
 //!     Font6x8::render_str("Hello World!")
@@ -28,7 +28,7 @@
 //! // Display updated frame
 //! epd.update_frame(&mut spi, &display.buffer()).unwrap();
 //! epd.display_frame(&mut spi).expect("display frame new graphics");
-//! 
+//!
 //! // Set the EPD to sleep
 //! epd.sleep(&mut spi).expect("sleep");
 //! ```
@@ -44,13 +44,13 @@ use hal::{
 };
 
 use type_a::{
-    command::Command, 
-    constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}
+    command::Command,
+    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:
@@ -85,9 +89,9 @@ where
         // 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, 
-            &[HEIGHT as u8, (HEIGHT >> 8) as u8, 0x00]
+            spi,
+            Command::DRIVER_OUTPUT_CONTROL,
+            &[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);
@@ -255,7 +272,7 @@ where
     }
 
     pub(crate) fn set_ram_area(
-        &mut self, 
+        &mut self,
         spi: &mut SPI,
         start_x: u32,
         start_y: u32,
@@ -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, 
+            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
-        ])?;
+            spi,
+            Command::SET_RAM_Y_ADDRESS_COUNTER,
+            &[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)
     }
 }
 
@@ -315,4 +342,4 @@ mod tests {
         assert_eq!(HEIGHT, 200);
         assert_eq!(DEFAULT_BACKGROUND_COLOR, Color::White);
     }
-}
\ No newline at end of file
+}
diff --git a/src/epd2in9/graphics.rs b/src/epd2in9/graphics.rs
index 2e6c31d..044338a 100644
--- a/src/epd2in9/graphics.rs
+++ b/src/epd2in9/graphics.rs
@@ -1,9 +1,9 @@
-use epd2in9::{DEFAULT_BACKGROUND_COLOR, WIDTH, HEIGHT};
+use epd2in9::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
 
 /// Full size buffer for use with the 2in9 EPD
-/// 
+///
 /// Can also be manuall constructed:
-/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]` 
+/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
 pub struct Buffer2in9 {
     pub buffer: [u8; WIDTH as usize * HEIGHT as usize / 8],
 }
@@ -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::*;
@@ -32,7 +29,7 @@ mod tests {
         let display = Display::new(WIDTH, HEIGHT, &mut buffer.buffer);
         assert_eq!(display.buffer().len(), 4736);
     }
-    
+
     // test default background color on all bytes
     #[test]
     fn graphics_default() {
@@ -42,4 +39,4 @@ mod tests {
             assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/epd2in9/mod.rs b/src/epd2in9/mod.rs
index 6dedc53..920ca5d 100644
--- a/src/epd2in9/mod.rs
+++ b/src/epd2in9/mod.rs
@@ -3,21 +3,21 @@
 //! Untested!
 //!
 //! # Example for the 2.9 in E-Ink Display
-//! 
+//!
 //! ```ignore
 //! use eink_waveshare_rs::{
 //!     epd2in9::{EPD2in9, Buffer2in9},
 //!     graphics::{Display, DisplayRotation},
 //!     prelude::*,
-//! }; 
-//! 
+//! };
+//!
 //! // Setup EPD
 //! let mut epd = EPD2in9::new(&mut spi, cs_pin, busy_in, dc, rst, &mut delay)?;
 //!
 //! // Use display graphics
 //! let mut buffer = Buffer2in9::default();
 //! let mut display = Display::new(epd.width(), epd.height(), &mut buffer.buffer);
-//! 
+//!
 //! // Write some hello world in the screenbuffer
 //! display.draw(
 //!     Font6x8::render_str("Hello World!")
@@ -30,7 +30,7 @@
 //! // Display updated frame
 //! epd.update_frame(&mut spi, &display.buffer()).unwrap();
 //! epd.display_frame(&mut spi).expect("display frame new graphics");
-//! 
+//!
 //! // Set the EPD to sleep
 //! epd.sleep(&mut spi).expect("sleep");
 //! ```
@@ -45,8 +45,8 @@ use hal::{
 };
 
 use type_a::{
-    command::Command, 
-    constants::{LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE}
+    command::Command,
+    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,30 +162,34 @@ 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
     fn update_partial_frame(
-        &mut self, 
+        &mut self,
         spi: &mut SPI,
         buffer: &[u8],
         x: u32,
@@ -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),
         }
     }
 }
@@ -248,7 +271,7 @@ where
     }
 
     fn set_ram_area(
-        &mut self, 
+        &mut self,
         spi: &mut SPI,
         start_x: u32,
         start_y: u32,
@@ -262,23 +285,35 @@ where
         // aren't relevant
         self.interface.cmd_with_data(
             spi,
-            Command::SET_RAM_X_ADDRESS_START_END_POSITION, 
-            &[(start_x >> 3) as u8, (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.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::*;
@@ -301,4 +336,4 @@ mod tests {
         assert_eq!(HEIGHT, 296);
         assert_eq!(DEFAULT_BACKGROUND_COLOR, Color::White);
     }
-}
\ No newline at end of file
+}
diff --git a/src/epd4in2/constants.rs b/src/epd4in2/constants.rs
index e794d5f..f64548c 100644
--- a/src/epd4in2/constants.rs
+++ b/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,        
diff --git a/src/epd4in2/graphics.rs b/src/epd4in2/graphics.rs
index 601459a..da22261 100644
--- a/src/epd4in2/graphics.rs
+++ b/src/epd4in2/graphics.rs
@@ -1,9 +1,9 @@
-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
-/// 
+///
 /// Can also be manuall constructed:
-/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]` 
+/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
 pub struct Buffer4in2 {
     pub buffer: [u8; WIDTH as usize * HEIGHT as usize / 8],
 }
@@ -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]
@@ -37,7 +34,7 @@ mod tests {
         let display = Display::new(WIDTH, HEIGHT, &mut display4in2.buffer);
         assert_eq!(display.buffer().len(), 15000);
     }
-    
+
     // test default background color on all bytes
     #[test]
     fn graphics_default() {
@@ -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()
+            );
         }
     }
 
@@ -58,13 +58,16 @@ mod tests {
                 .with_stroke(Some(Color::Black))
                 .into_iter(),
         );
-        
+
         let buffer = display.buffer();
 
         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()
+            );
         }
     }
 
@@ -78,13 +81,16 @@ mod tests {
                 .with_stroke(Some(Color::Black))
                 .into_iter(),
         );
-        
+
         let buffer = display.buffer();
 
         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()
+            );
         }
     }
 
@@ -98,7 +104,7 @@ mod tests {
                 .with_stroke(Some(Color::Black))
                 .into_iter(),
         );
-        
+
         let buffer = display.buffer();
 
         extern crate std;
@@ -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]
@@ -122,7 +130,7 @@ mod tests {
                 .with_stroke(Some(Color::Black))
                 .into_iter(),
         );
-        
+
         let buffer = display.buffer();
 
         extern crate std;
@@ -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()
+            );
         }
-        
     }
 }
-
diff --git a/src/epd4in2/mod.rs b/src/epd4in2/mod.rs
index 0c0c44d..149fa07 100644
--- a/src/epd4in2/mod.rs
+++ b/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)?;
@@ -114,15 +118,14 @@ where
         // TODO: Test these other frequencies
         // 3A 100HZ   29 150Hz 39 200HZ  31 171HZ DEFAULT: 3c 50Hz
         self.cmd_with_data(spi, Command::PLL_CONTROL, &[0x3A])?;
-        
+
         self.set_lut(spi, None)?;
 
         Ok(())
     }
 }
 
-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,20 +201,25 @@ 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(
-        &mut self, 
-        spi: &mut SPI,        
+        &mut self,
+        spi: &mut SPI,
         buffer: &[u8],
         x: u32,
         y: u32,
@@ -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(
-                    spi,
-                    &LUT_VCOM0_QUICK,
-                    &LUT_WW_QUICK,
-                    &LUT_BW_QUICK,
-                    &LUT_WB_QUICK,
-                    &LUT_BB_QUICK,
-                )
             }
+            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::*;
@@ -394,4 +403,4 @@ mod tests {
         assert_eq!(HEIGHT, 300);
         assert_eq!(DEFAULT_BACKGROUND_COLOR, Color::White);
     }
-}
\ No newline at end of file
+}
diff --git a/src/graphics.rs b/src/graphics.rs
index 5a50d1a..1a5bb0f 100644
--- a/src/graphics.rs
+++ b/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;
         
@@ -236,4 +228,4 @@ mod tests {
             assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/interface.rs b/src/interface.rs
index ed3bfc4..179dd77 100644
--- a/src/interface.rs
+++ b/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,
@@ -62,14 +61,18 @@ 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> {
-       self.cmd(spi, command)?;
-       self.data(spi, data)
+    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();
 
@@ -104,7 +106,7 @@ where
         } else {
             spi.write(data)?;
         }
-        
+
         // deativate spi with cs high
         self.cs.set_high();
 
@@ -125,7 +127,7 @@ 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) {
-        // TODO: removal of delay. TEST! 
+        // 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()) {
diff --git a/src/lib.rs b/src/lib.rs
index 36a4a04..0a120af 100644
--- a/src/lib.rs
+++ b/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};
 
diff --git a/src/traits.rs b/src/traits.rs
index 86dc1c2..7ea2857 100644
--- a/src/traits.rs
+++ b/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)
@@ -17,8 +16,8 @@ pub enum RefreshLUT {
     /// The "normal" full Lookuptable for the Refresh-Sequence
     FULL,
     /// The quick LUT where not the full refresh sequence is followed.
-    /// This might lead to some 
-    QUICK
+    /// This might lead to some
+    QUICK,
 }
 
 impl Default for RefreshLUT {
@@ -37,20 +36,23 @@ where
 {
     /// This initialises the EPD and powers it up
     ///
-    /// This function is already called from 
+    /// This function is already called from
     ///  - [new()](WaveshareInterface::new())
     ///  - [`wake_up`]
-    /// 
+    ///
     ///
     /// 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
 pub trait WaveshareDisplay<SPI, CS, BUSY, DC, RST>
 where
@@ -64,10 +66,15 @@ 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;  
+        Self: Sized;
 
     /// Let the device enter deep-sleep mode to save power.
     ///
@@ -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);
@@ -98,7 +109,7 @@ where
     /// Transmits partial data to the SRAM of the EPD
     ///
     /// (x,y) is the top left corner
-    /// 
+    ///
     /// BUFFER needs to be of size: width / 8 * height !
     fn update_partial_frame(
         &mut self,
@@ -119,11 +130,15 @@ where
 
     /// Trait for using various Waveforms from different LUTs
     /// E.g. for partial refreshes
-    /// 
-    /// A full refresh is needed after a certain amount of quick refreshes! 
-    /// 
+    ///
+    /// A full refresh is needed after a certain amount of quick refreshes!
+    ///
     /// 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>;
 }
diff --git a/src/type_a/constants.rs b/src/type_a/constants.rs
index 63de296..c4bb9c1 100644
--- a/src/type_a/constants.rs
+++ b/src/type_a/constants.rs
@@ -11,4 +11,4 @@ pub(crate) const LUT_PARTIAL_UPDATE: [u8; 30] =[
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
     0x00, 0x00, 0x00, 0x00, 0x13, 0x14, 0x44, 0x12, 
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00      
-];
\ No newline at end of file
+];
diff --git a/src/type_a/mod.rs b/src/type_a/mod.rs
index 11b59c7..84c4f1c 100644
--- a/src/type_a/mod.rs
+++ b/src/type_a/mod.rs
@@ -1,2 +1,2 @@
 pub(crate) mod command;
-pub(crate) mod constants;
\ No newline at end of file
+pub(crate) mod constants;