diff --git a/core/include/esp/spi.h b/core/include/esp/spi.h
index ca11720..ff77c79 100644
--- a/core/include/esp/spi.h
+++ b/core/include/esp/spi.h
@@ -186,7 +186,7 @@ void spi_set_frequency_div(uint8_t bus, uint32_t divider);
 inline uint32_t spi_get_frequency_div(uint8_t bus)
 {
     return (FIELD2VAL(SPI_CLOCK_DIV_PRE, SPI(bus).CLOCK) + 1) |
-            (FIELD2VAL(SPI_CLOCK_COUNT_NUM, SPI(bus).CLOCK) + 1);
+           (FIELD2VAL(SPI_CLOCK_COUNT_NUM, SPI(bus).CLOCK) + 1);
 }
 /**
  * \brief Get SPI bus frequency in Hz
@@ -196,8 +196,8 @@ inline uint32_t spi_get_frequency_div(uint8_t bus)
 inline uint32_t spi_get_frequency_hz(uint8_t bus)
 {
     return APB_CLK_FREQ /
-            (FIELD2VAL(SPI_CLOCK_DIV_PRE, SPI(bus).CLOCK) + 1) /
-            (FIELD2VAL(SPI_CLOCK_COUNT_NUM, SPI(bus).CLOCK) + 1);
+           (FIELD2VAL(SPI_CLOCK_DIV_PRE, SPI(bus).CLOCK) + 1) /
+           (FIELD2VAL(SPI_CLOCK_COUNT_NUM, SPI(bus).CLOCK) + 1);
 }
 
 /**
@@ -231,7 +231,7 @@ inline spi_endianness_t spi_get_endianness(uint8_t bus)
 {
     return SPI(bus).USER0 & (SPI_USER0_WR_BYTE_ORDER | SPI_USER0_RD_BYTE_ORDER)
             ? SPI_BIG_ENDIAN
-                    : SPI_LITTLE_ENDIAN;
+            : SPI_LITTLE_ENDIAN;
 }
 
 /**
@@ -278,25 +278,26 @@ size_t spi_transfer(uint8_t bus, const void *out_data, void *in_data, size_t len
  * \brief Add permanent command bits when transfert data over SPI
  * Example:
  *
- *    spi_set_command(1,1,0x01); // Set one command bit to 1
- *    for (uint8_t i = 0 ; i < x ; i++ ) {
- *    	spi_transfer_8(1,0x55);  // Send 1 bit command + 8 bits data x times
+ *    spi_set_command(1, 1, 0x01); // Set one command bit to 1
+ *    for (uint8_t i = 0; i < x; i++ ) {
+ *    	spi_transfer_8(1, 0x55);  // Send 1 bit command + 8 bits data x times
  *    }
  *    spi_clear_command(1); // Clear command
- *    spi_transfer_8(1,0x55);  // Send 8 bits data
+ *    spi_transfer_8(1, 0x55);  // Send 8 bits data
  *
  * \param bus Bus ID: 0 - system, 1 - user
  * \param bits Number of bits (max: 16).
  * \param data Command to send for each transfert.
  */
-static inline void spi_set_command(uint8_t bus,uint8_t bits, uint16_t data)
+static inline void spi_set_command(uint8_t bus, uint8_t bits, uint16_t data)
 {
-    if(!bits) return ;
-    SPI(bus).USER0 |= SPI_USER0_COMMAND ; //enable COMMAND function in SPI module
-    uint16_t command = data << (16-bits); //align command data to high bits
-    command = ((command>>8)&0xff) | ((command<<8)&0xff00); //swap byte order
-    SPI(bus).USER2 =  SET_FIELD(SPI(bus).USER2, SPI_USER2_COMMAND_BITLEN, --bits);
-    SPI(bus).USER2 =  SET_FIELD(SPI(bus).USER2, SPI_USER2_COMMAND_VALUE, command);
+    if (!bits) return;
+
+    SPI(bus).USER0 |= SPI_USER0_COMMAND;                           //enable COMMAND function in SPI module
+    uint16_t command = data << (16 - bits);                        //align command data to high bits
+    command = ((command >> 8) & 0xff) | ((command << 8) & 0xff00); //swap byte order
+    SPI(bus).USER2 = SET_FIELD(SPI(bus).USER2, SPI_USER2_COMMAND_BITLEN, --bits);
+    SPI(bus).USER2 = SET_FIELD(SPI(bus).USER2, SPI_USER2_COMMAND_VALUE, command);
 }
 
 /**
@@ -314,11 +315,12 @@ static inline void spi_set_command(uint8_t bus,uint8_t bits, uint16_t data)
  * \param bits Number of bits (max: 32).
  * \param data Address to send for each transfert.
  */
-static inline void spi_set_address(uint8_t bus,uint8_t bits, uint32_t data)
+static inline void spi_set_address(uint8_t bus, uint8_t bits, uint32_t data)
 {
-    if(!bits) return ;
-    SPI(bus).USER0 |= SPI_USER0_ADDR ; //enable ADDRess function in SPI module
-    SPI(bus).ADDR = data<<(32-bits) ; //align address data to high bits
+    if (!bits) return;
+
+    SPI(bus).USER0 |= SPI_USER0_ADDR; //enable ADDRess function in SPI module
+    SPI(bus).ADDR = data << (32 - bits); //align address data to high bits
     SPI(bus).USER1 = SET_FIELD(SPI(bus).USER1, SPI_USER1_ADDR_BITLEN, --bits);
 }
 
@@ -326,12 +328,12 @@ static inline void spi_set_address(uint8_t bus,uint8_t bits, uint32_t data)
  * \brief Add permanent dummy bits when transfert data over SPI
  * Example:
  *
- *    spi_set_dummy_bits(1,4,false); // Set 4 dummy bit before Dout
- *    for (uint8_t i = 0 ; i < x ; i++ ) {
- *    	spi_transfer_16(1,0xC584);  // Send 4 bits dummy + 16 bits Dout x times
+ *    spi_set_dummy_bits(1, 4, false); // Set 4 dummy bit before Dout
+ *    for (uint8_t i = 0; i < x; i++ ) {
+ *    	spi_transfer_16(1, 0xC584);  // Send 4 bits dummy + 16 bits Dout x times
  *    }
- *    spi_set_dummy_bits(1,4,true); // Set 4 dummy bit between Dout and Din
- *    spi_transfer_8(1,0x55);  // Send 8 bits Dout + 4 bits dummy + 8 bits Din
+ *    spi_set_dummy_bits(1, 4, true); // Set 4 dummy bit between Dout and Din
+ *    spi_transfer_8(1, 0x55);  // Send 8 bits Dout + 4 bits dummy + 8 bits Din
  *
  * \param bus Bus ID: 0 - system, 1 - user
  * \param bits Number of bits
@@ -339,8 +341,9 @@ static inline void spi_set_address(uint8_t bus,uint8_t bits, uint32_t data)
  */
 static inline void spi_set_dummy_bits(uint8_t bus, uint8_t bits, bool pos)
 {
-    if(!bits) return ;
-    if(pos) { SPI(bus).USER0 |= SPI_USER0_MISO; } // Dummy bit will be between Dout and Din data if set
+    if (!bits) return;
+    if (pos)
+        SPI(bus).USER0 |= SPI_USER0_MISO; // Dummy bit will be between Dout and Din data if set
     SPI(bus).USER0 |= SPI_USER0_DUMMY; //enable dummy bits
     SPI(bus).USER1 = SET_FIELD(SPI(bus).USER1, SPI_USER1_DUMMY_CYCLELEN, --bits);
 }
@@ -351,7 +354,7 @@ static inline void spi_set_dummy_bits(uint8_t bus, uint8_t bits, bool pos)
  */
 static inline void spi_clear_address(uint8_t bus)
 {
-    SPI(bus).USER0 &= ~(SPI_USER0_ADDR) ;
+    SPI(bus).USER0 &= ~(SPI_USER0_ADDR);
 }
 
 /**
@@ -361,7 +364,7 @@ static inline void spi_clear_address(uint8_t bus)
 
 static inline void spi_clear_command(uint8_t bus)
 {
-    SPI(bus).USER0 &= ~(SPI_USER0_COMMAND) ;
+    SPI(bus).USER0 &= ~(SPI_USER0_COMMAND);
 }
 
 /**
diff --git a/examples/mcp4725_test/main.c b/examples/mcp4725_test/main.c
index b7d42af..bcb839b 100644
--- a/examples/mcp4725_test/main.c
+++ b/examples/mcp4725_test/main.c
@@ -20,7 +20,7 @@
 #define ADDR MCP4725A0_ADDR0
 #define VDD 3.3
 
-inline static void wait_for_eeprom(i2c_dev_t* dev)
+inline static void wait_for_eeprom(i2c_dev_t *dev)
 {
     while (mcp4725_eeprom_busy(dev))
     {
diff --git a/extras/ads111x/ads111x.c b/extras/ads111x/ads111x.c
index 8e68ee4..f2724bb 100644
--- a/extras/ads111x/ads111x.c
+++ b/extras/ads111x/ads111x.c
@@ -51,7 +51,7 @@ const float ads111x_gain_values[] = {
     [ADS111X_GAIN_0V256_3] = 0.256
 };
 
-static uint16_t read_reg(i2c_dev_t* dev, uint8_t reg)
+static uint16_t read_reg(i2c_dev_t *dev, uint8_t reg)
 {
     uint16_t res = 0;
     if (i2c_slave_read(dev->bus, dev->addr, &reg, (uint8_t *)&res, 2))
@@ -60,7 +60,7 @@ static uint16_t read_reg(i2c_dev_t* dev, uint8_t reg)
     return res;
 }
 
-static void write_reg(i2c_dev_t* dev, uint8_t reg, uint16_t val)
+static void write_reg(i2c_dev_t *dev, uint8_t reg, uint16_t val)
 {
     //debug("Write %d: 0x%04x", reg, val);
     uint8_t buf[2] = { val >> 8, val};
@@ -68,127 +68,127 @@ static void write_reg(i2c_dev_t* dev, uint8_t reg, uint16_t val)
         debug("Could not write 0x%04x to register %d", val, reg);
 }
 
-static uint16_t read_conf_bits(i2c_dev_t* dev, uint8_t offs, uint16_t mask)
+static uint16_t read_conf_bits(i2c_dev_t *dev, uint8_t offs, uint16_t mask)
 {
     return (read_reg(dev, REG_CONFIG) >> offs) & mask;
 }
 
-static void write_conf_bits(i2c_dev_t* dev, uint16_t val, uint8_t offs, uint16_t mask)
+static void write_conf_bits(i2c_dev_t *dev, uint16_t val, uint8_t offs, uint16_t mask)
 {
     write_reg(dev, REG_CONFIG, (read_reg(dev, REG_CONFIG) & ~(mask << offs)) | (val << offs));
 }
 
-bool ads111x_busy(i2c_dev_t* dev)
+bool ads111x_busy(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, OS_OFFSET, OS_MASK);
 }
 
-void ads111x_start_conversion(i2c_dev_t* dev)
+void ads111x_start_conversion(i2c_dev_t *dev)
 {
     write_conf_bits(dev, 1, OS_OFFSET, OS_MASK);
 }
 
-int16_t ads111x_get_value(i2c_dev_t* dev)
+int16_t ads111x_get_value(i2c_dev_t *dev)
 {
     return read_reg(dev, REG_CONVERSION);
 }
 
-ads111x_gain_t ads111x_get_gain(i2c_dev_t* dev)
+ads111x_gain_t ads111x_get_gain(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, PGA_OFFSET, PGA_MASK);
 }
 
-void ads111x_set_gain(i2c_dev_t* dev, ads111x_gain_t gain)
+void ads111x_set_gain(i2c_dev_t *dev, ads111x_gain_t gain)
 {
     write_conf_bits(dev, gain, PGA_OFFSET, PGA_MASK);
 }
 
-ads111x_mux_t ads111x_get_input_mux(i2c_dev_t* dev)
+ads111x_mux_t ads111x_get_input_mux(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, MUX_OFFSET, MUX_MASK);
 }
 
-void ads111x_set_input_mux(i2c_dev_t* dev, ads111x_mux_t mux)
+void ads111x_set_input_mux(i2c_dev_t *dev, ads111x_mux_t mux)
 {
     write_conf_bits(dev, mux, MUX_OFFSET, MUX_MASK);
 }
 
-ads111x_mode_t ads111x_get_mode(i2c_dev_t* dev)
+ads111x_mode_t ads111x_get_mode(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, MODE_OFFSET, MODE_MASK);
 }
 
-void ads111x_set_mode(i2c_dev_t* dev, ads111x_mode_t mode)
+void ads111x_set_mode(i2c_dev_t *dev, ads111x_mode_t mode)
 {
     write_conf_bits(dev, mode, MODE_OFFSET, MODE_MASK);
 }
 
-ads111x_data_rate_t ads111x_get_data_rate(i2c_dev_t* dev)
+ads111x_data_rate_t ads111x_get_data_rate(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, DR_OFFSET, DR_MASK);
 }
 
-void ads111x_set_data_rate(i2c_dev_t* dev, ads111x_data_rate_t rate)
+void ads111x_set_data_rate(i2c_dev_t *dev, ads111x_data_rate_t rate)
 {
     write_conf_bits(dev, rate, DR_OFFSET, DR_MASK);
 }
 
-ads111x_comp_mode_t ads111x_get_comp_mode(i2c_dev_t* dev)
+ads111x_comp_mode_t ads111x_get_comp_mode(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, COMP_MODE_OFFSET, COMP_MODE_MASK);
 }
 
-void ads111x_set_comp_mode(i2c_dev_t* dev, ads111x_comp_mode_t mode)
+void ads111x_set_comp_mode(i2c_dev_t *dev, ads111x_comp_mode_t mode)
 {
     write_conf_bits(dev, mode, COMP_MODE_OFFSET, COMP_MODE_MASK);
 }
 
-ads111x_comp_polarity_t ads111x_get_comp_polarity(i2c_dev_t* dev)
+ads111x_comp_polarity_t ads111x_get_comp_polarity(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, COMP_POL_OFFSET, COMP_POL_MASK);
 }
 
-void ads111x_set_comp_polarity(i2c_dev_t* dev, ads111x_comp_polarity_t polarity)
+void ads111x_set_comp_polarity(i2c_dev_t *dev, ads111x_comp_polarity_t polarity)
 {
     write_conf_bits(dev, polarity, COMP_POL_OFFSET, COMP_POL_MASK);
 }
 
-ads111x_comp_latch_t ads111x_get_comp_latch(i2c_dev_t* dev)
+ads111x_comp_latch_t ads111x_get_comp_latch(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, COMP_LAT_OFFSET, COMP_LAT_MASK);
 }
 
-void ads111x_set_comp_latch(i2c_dev_t* dev, ads111x_comp_latch_t latch)
+void ads111x_set_comp_latch(i2c_dev_t *dev, ads111x_comp_latch_t latch)
 {
     write_conf_bits(dev, latch, COMP_LAT_OFFSET, COMP_LAT_MASK);
 }
 
-ads111x_comp_queue_t ads111x_get_comp_queue(i2c_dev_t* dev)
+ads111x_comp_queue_t ads111x_get_comp_queue(i2c_dev_t *dev)
 {
     return read_conf_bits(dev, COMP_QUE_OFFSET, COMP_QUE_MASK);
 }
 
-void ads111x_set_comp_queue(i2c_dev_t* dev, ads111x_comp_queue_t queue)
+void ads111x_set_comp_queue(i2c_dev_t *dev, ads111x_comp_queue_t queue)
 {
     write_conf_bits(dev, queue, COMP_QUE_OFFSET, COMP_QUE_MASK);
 }
 
-int16_t ads111x_get_comp_low_thresh(i2c_dev_t* dev)
+int16_t ads111x_get_comp_low_thresh(i2c_dev_t *dev)
 {
     return read_reg(dev, REG_THRESH_L);
 }
 
-void ads111x_set_comp_low_thresh(i2c_dev_t* dev, int16_t thresh)
+void ads111x_set_comp_low_thresh(i2c_dev_t *dev, int16_t thresh)
 {
     write_reg(dev, REG_THRESH_L, thresh);
 }
 
-int16_t ads111x_get_comp_high_thresh(i2c_dev_t* dev)
+int16_t ads111x_get_comp_high_thresh(i2c_dev_t *dev)
 {
     return read_reg(dev, REG_THRESH_H);
 }
 
-void ads111x_set_comp_high_thresh(i2c_dev_t* dev, int16_t thresh)
+void ads111x_set_comp_high_thresh(i2c_dev_t *dev, int16_t thresh)
 {
     write_reg(dev, REG_THRESH_H, thresh);
 }
diff --git a/extras/ads111x/ads111x.h b/extras/ads111x/ads111x.h
index af93d4e..b9eb673 100644
--- a/extras/ads111x/ads111x.h
+++ b/extras/ads111x/ads111x.h
@@ -125,20 +125,20 @@ typedef enum
  * @param addr Deivce address
  * @return true when device performing conversion
  */
-bool ads111x_busy(i2c_dev_t* dev);
+bool ads111x_busy(i2c_dev_t *dev);
 
 /**
  * Begin a single conversion (when in single-shot mode)
  * @param addr Deivce address
  */
-void ads111x_start_conversion(i2c_dev_t* dev);
+void ads111x_start_conversion(i2c_dev_t *dev);
 
 /**
  * Read last conversion result
  * @param addr
  * @return Last conversion result
  */
-int16_t ads111x_get_value(i2c_dev_t* dev);
+int16_t ads111x_get_value(i2c_dev_t *dev);
 
 /**
  * Read the programmable gain amplifier configuration
@@ -146,70 +146,70 @@ int16_t ads111x_get_value(i2c_dev_t* dev);
  * @param addr Deivce address
  * @return Gain value
  */
-ads111x_gain_t ads111x_get_gain(i2c_dev_t* dev);
+ads111x_gain_t ads111x_get_gain(i2c_dev_t *dev);
 
 /**
  * Configure the programmable gain amplifier (ADS1114 and ADS1115 only)
  * @param addr Deivce address
  * @param gain Gain value
  */
-void ads111x_set_gain(i2c_dev_t* dev, ads111x_gain_t gain);
+void ads111x_set_gain(i2c_dev_t *dev, ads111x_gain_t gain);
 
 /**
  * Read the input multiplexer configuration (ADS1115 only)
  * @param addr Deivce address
  * @return Input multiplexer configuration
  */
-ads111x_mux_t ads111x_get_input_mux(i2c_dev_t* dev);
+ads111x_mux_t ads111x_get_input_mux(i2c_dev_t *dev);
 
 /**
  * Configure the input multiplexer configuration (ADS1115 only)
  * @param addr Deivce address
  * @param mux Input multiplexer configuration
  */
-void ads111x_set_input_mux(i2c_dev_t* dev, ads111x_mux_t mux);
+void ads111x_set_input_mux(i2c_dev_t *dev, ads111x_mux_t mux);
 
 /**
  * Read the device operating mode
  * @param addr Deivce address
  * @return Device operating mode
  */
-ads111x_mode_t ads111x_get_mode(i2c_dev_t* dev);
+ads111x_mode_t ads111x_get_mode(i2c_dev_t *dev);
 
 /**
  * Set the device operating mode
  * @param addr Deivce address
  * @param mode Device operating mode
  */
-void ads111x_set_mode(i2c_dev_t* dev, ads111x_mode_t mode);
+void ads111x_set_mode(i2c_dev_t *dev, ads111x_mode_t mode);
 
 /**
  * Read the data rate
  * @param addr Deivce address
  * @return Data rate
  */
-ads111x_data_rate_t ads111x_get_data_rate(i2c_dev_t* dev);
+ads111x_data_rate_t ads111x_get_data_rate(i2c_dev_t *dev);
 
 /**
  * Configure the data rate
  * @param addr Deivce address
  * @param rate Data rate
  */
-void ads111x_set_data_rate(i2c_dev_t* dev, ads111x_data_rate_t rate);
+void ads111x_set_data_rate(i2c_dev_t *dev, ads111x_data_rate_t rate);
 
 /**
  * Get comparator mode (ADS1114 and ADS1115 only)
  * @param addr Deivce address
  * @return Comparator mode
  */
-ads111x_comp_mode_t ads111x_get_comp_mode(i2c_dev_t* dev);
+ads111x_comp_mode_t ads111x_get_comp_mode(i2c_dev_t *dev);
 
 /**
  * Set comparator mode (ADS1114 and ADS1115 only)
  * @param addr Deivce address
  * @param mode Comparator mode
  */
-void ads111x_set_comp_mode(i2c_dev_t* dev, ads111x_comp_mode_t mode);
+void ads111x_set_comp_mode(i2c_dev_t *dev, ads111x_comp_mode_t mode);
 
 /**
  * Get polarity of the comparator output pin ALERT/RDY
@@ -217,7 +217,7 @@ void ads111x_set_comp_mode(i2c_dev_t* dev, ads111x_comp_mode_t mode);
  * @param addr Deivce address
  * @return Comparator output pin polarity
  */
-ads111x_comp_polarity_t ads111x_get_comp_polarity(i2c_dev_t* dev);
+ads111x_comp_polarity_t ads111x_get_comp_polarity(i2c_dev_t *dev);
 
 /**
  * Set polarity of the comparator output pin ALERT/RDY
@@ -225,7 +225,7 @@ ads111x_comp_polarity_t ads111x_get_comp_polarity(i2c_dev_t* dev);
  * @param addr Deivce address
  * @param polarity Comparator output pin polarity
  */
-void ads111x_set_comp_polarity(i2c_dev_t* dev, ads111x_comp_polarity_t polarity);
+void ads111x_set_comp_polarity(i2c_dev_t *dev, ads111x_comp_polarity_t polarity);
 
 /**
  * Get comparator output latch mode, see datasheet.
@@ -233,14 +233,14 @@ void ads111x_set_comp_polarity(i2c_dev_t* dev, ads111x_comp_polarity_t polarity)
  * @param addr Deivce address
  * @return Comparator output latch mode
  */
-ads111x_comp_latch_t ads111x_get_comp_latch(i2c_dev_t* dev);
+ads111x_comp_latch_t ads111x_get_comp_latch(i2c_dev_t *dev);
 
 /**
  * Set comparator output latch mode (ADS1114 and ADS1115 only)
  * @param addr Deivce address
  * @param latch Comparator output latch mode
  */
-void ads111x_set_comp_latch(i2c_dev_t* dev, ads111x_comp_latch_t latch);
+void ads111x_set_comp_latch(i2c_dev_t *dev, ads111x_comp_latch_t latch);
 
 /**
  * Set number of the comparator conversions before pin ALERT/RDY
@@ -248,7 +248,7 @@ void ads111x_set_comp_latch(i2c_dev_t* dev, ads111x_comp_latch_t latch);
  * @param addr Deivce address
  * @return Number of the comparator conversions
  */
-ads111x_comp_queue_t ads111x_get_comp_queue(i2c_dev_t* dev);
+ads111x_comp_queue_t ads111x_get_comp_queue(i2c_dev_t *dev);
 
 /**
  * Get number of the comparator conversions before pin ALERT/RDY
@@ -256,35 +256,35 @@ ads111x_comp_queue_t ads111x_get_comp_queue(i2c_dev_t* dev);
  * @param addr Deivce address
  * @param queue Number of the comparator conversions
  */
-void ads111x_set_comp_queue(i2c_dev_t* dev, ads111x_comp_queue_t queue);
+void ads111x_set_comp_queue(i2c_dev_t *dev, ads111x_comp_queue_t queue);
 
 /**
  * Get the lower threshold value used by comparator
  * @param addr Deivce address
  * @return Lower threshold value
  */
-int16_t ads111x_get_comp_low_thresh(i2c_dev_t* dev);
+int16_t ads111x_get_comp_low_thresh(i2c_dev_t *dev);
 
 /**
  * Set the lower threshold value used by comparator
  * @param addr Deivce address
  * @param thresh Lower threshold value
  */
-void ads111x_set_comp_low_thresh(i2c_dev_t* dev, int16_t thresh);
+void ads111x_set_comp_low_thresh(i2c_dev_t *dev, int16_t thresh);
 
 /**
  * Get the upper threshold value used by comparator
  * @param addr Deivce address
  * @return Upper threshold value
  */
-int16_t ads111x_get_comp_high_thresh(i2c_dev_t* dev);
+int16_t ads111x_get_comp_high_thresh(i2c_dev_t *dev);
 
 /**
  * Set the upper threshold value used by comparator
  * @param addr Deivce address
  * @param thresh Upper threshold value
  */
-void ads111x_set_comp_high_thresh(i2c_dev_t* dev, int16_t thresh);
+void ads111x_set_comp_high_thresh(i2c_dev_t *dev, int16_t thresh);
 
 #ifdef __cplusplus
 }
diff --git a/extras/bmp180/bmp180.c b/extras/bmp180/bmp180.c
index d7d4330..947772b 100644
--- a/extras/bmp180/bmp180.c
+++ b/extras/bmp180/bmp180.c
@@ -38,7 +38,7 @@
 static int bmp180_readRegister16(i2c_dev_t *dev, uint8_t reg, int16_t *r)
 {
     uint8_t d[] = { 0, 0 };
-    int error ;
+    int error;
 
     if ((error = i2c_slave_read(dev->bus, dev->addr, &reg, d, 2)))
         return error;
@@ -49,7 +49,7 @@ static int bmp180_readRegister16(i2c_dev_t *dev, uint8_t reg, int16_t *r)
 
 static int bmp180_start_Messurement(i2c_dev_t *dev, uint8_t cmd)
 {
-    uint8_t reg = BMP180_CONTROL_REG ;
+    uint8_t reg = BMP180_CONTROL_REG;
 
     return i2c_slave_write(dev->bus, dev->addr, &reg, &cmd, 1);
 }
diff --git a/extras/bmp280/bmp280.c b/extras/bmp280/bmp280.c
index abff6fd..d2f3795 100644
--- a/extras/bmp280/bmp280.c
+++ b/extras/bmp280/bmp280.c
@@ -60,12 +60,12 @@ void bmp280_init_default_params(bmp280_params_t *params)
     params->mode = BMP280_MODE_NORMAL;
     params->filter = BMP280_FILTER_OFF;
     params->oversampling_pressure = BMP280_STANDARD;
-    params->oversampling_temperature = BMP280_STANDARD ;
+    params->oversampling_temperature = BMP280_STANDARD;
     params->oversampling_humidity = BMP280_STANDARD;
     params->standby = BMP280_STANDBY_250;
 }
 
-static bool read_register16(i2c_dev_t* dev, uint8_t addr, uint16_t *value)
+static bool read_register16(i2c_dev_t *dev, uint8_t addr, uint16_t *value)
 {
     uint8_t d[] = {0, 0};
     if (!i2c_slave_read(dev->bus, dev->addr, &addr, d, sizeof(d))) {
@@ -75,7 +75,7 @@ static bool read_register16(i2c_dev_t* dev, uint8_t addr, uint16_t *value)
     return false;
 }
 
-static inline int read_data(i2c_dev_t* dev, uint8_t addr, uint8_t *value, uint8_t len)
+static inline int read_data(i2c_dev_t *dev, uint8_t addr, uint8_t *value, uint8_t len)
 {
     return i2c_slave_read(dev->bus, dev->addr, &addr, value, len);
 }
@@ -141,7 +141,7 @@ static bool read_hum_calibration_data(bmp280_t *dev)
     return false;
 }
 
-static int write_register8(i2c_dev_t* dev, uint8_t addr, uint8_t value)
+static int write_register8(i2c_dev_t *dev, uint8_t addr, uint8_t value)
 {
     return i2c_slave_write(dev->bus, dev->addr, &addr, &value, 1);
 }
diff --git a/extras/ds1302/ds1302.h b/extras/ds1302/ds1302.h
index 4b3c1ba..ce49a72 100644
--- a/extras/ds1302/ds1302.h
+++ b/extras/ds1302/ds1302.h
@@ -3,7 +3,7 @@
  *
  * Part of esp-open-rtos
  * Copyright (C) 2016 Ruslan V. Uss <unclerus@gmail.com>,
- *                    Pavel Merlyakov <merzlyakovpavel@gmail.com>
+ *                    Pavel Merzlyakov <merzlyakovpavel@gmail.com>
  * BSD Licensed as described in the file LICENSE
  */
 #ifndef EXTRAS_DS1302_H_
diff --git a/extras/ds1307/ds1307.c b/extras/ds1307/ds1307.c
index 7cee34a..7b29563 100644
--- a/extras/ds1307/ds1307.c
+++ b/extras/ds1307/ds1307.c
@@ -38,36 +38,36 @@ static uint8_t dec2bcd(uint8_t val)
     return ((val / 10) << 4) + (val % 10);
 }
 
-static uint8_t read_register(i2c_dev_t* dev, uint8_t reg)
+static uint8_t read_register(i2c_dev_t *dev, uint8_t reg)
 {
     uint8_t val;
     i2c_slave_read(dev->bus, dev->addr, &reg, &val, 1);
     return val;
 }
 
-static void update_register(i2c_dev_t* dev, uint8_t reg, uint8_t mask, uint8_t val)
+static void update_register(i2c_dev_t *dev, uint8_t reg, uint8_t mask, uint8_t val)
 {
-    uint8_t buf = (read_register(dev,reg) & mask) | val;
+    uint8_t buf = (read_register(dev, reg) & mask) | val;
 
     i2c_slave_write(dev->bus, dev->addr, &reg, &buf, 1);
 }
 
-void ds1307_start(i2c_dev_t* dev, bool start)
+void ds1307_start(i2c_dev_t *dev, bool start)
 {
     update_register(dev, TIME_REG, CH_MASK, start ? 0 : CH_BIT);
 }
 
-bool ds1307_is_running(i2c_dev_t* dev)
+bool ds1307_is_running(i2c_dev_t *dev)
 {
     return !(read_register(dev, TIME_REG) & CH_BIT);
 }
 
-void ds1307_get_time(i2c_dev_t* dev, struct tm *time)
+void ds1307_get_time(i2c_dev_t *dev, struct tm *time)
 {
     uint8_t buf[7];
-    uint8_t reg = TIME_REG ;
+    uint8_t reg = TIME_REG;
 
-    i2c_slave_read(dev->bus, dev->addr, &reg , buf, 7);
+    i2c_slave_read(dev->bus, dev->addr, &reg, buf, 7);
 
     time->tm_sec = bcd2dec(buf[0] & SECONDS_MASK);
     time->tm_min = bcd2dec(buf[1]);
@@ -78,14 +78,15 @@ void ds1307_get_time(i2c_dev_t* dev, struct tm *time)
         if (buf[2] & PM_BIT)
             time->tm_hour += 12;
     }
-    else time->tm_hour = bcd2dec(buf[2] & HOUR24_MASK);
+    else
+        time->tm_hour = bcd2dec(buf[2] & HOUR24_MASK);
     time->tm_wday = bcd2dec(buf[3]) - 1;
     time->tm_mday = bcd2dec(buf[4]);
-    time->tm_mon  = bcd2dec(buf[5]) - 1;
+    time->tm_mon = bcd2dec(buf[5]) - 1;
     time->tm_year = bcd2dec(buf[6]) + 2000;
 }
 
-void ds1307_set_time(i2c_dev_t* dev, const struct tm *time)
+void ds1307_set_time(i2c_dev_t *dev, const struct tm *time)
 {
     uint8_t buf[8];
     buf[0] = TIME_REG;
@@ -97,51 +98,55 @@ void ds1307_set_time(i2c_dev_t* dev, const struct tm *time)
     buf[6] = dec2bcd(time->tm_mon + 1);
     buf[7] = dec2bcd(time->tm_year - 2000);
 
-    i2c_slave_write(dev->bus, dev->addr, &buf[0], &buf[1] , 7);
+    i2c_slave_write(dev->bus, dev->addr, &buf[0], &buf[1], 7);
 }
 
-void ds1307_enable_squarewave(i2c_dev_t* dev, bool enable)
+void ds1307_enable_squarewave(i2c_dev_t *dev, bool enable)
 {
     update_register(dev, CONTROL_REG, SQWE_MASK, enable ? SQWE_BIT : 0);
 }
 
-bool ds1307_is_squarewave_enabled(i2c_dev_t* dev)
+bool ds1307_is_squarewave_enabled(i2c_dev_t *dev)
 {
     return read_register(dev, CONTROL_REG) & SQWE_BIT;
 }
 
-void ds1307_set_squarewave_freq(i2c_dev_t* dev, ds1307_squarewave_freq_t freq)
+void ds1307_set_squarewave_freq(i2c_dev_t *dev, ds1307_squarewave_freq_t freq)
 {
     update_register(dev, CONTROL_REG, SQWEF_MASK, (uint8_t)freq);
 }
 
-ds1307_squarewave_freq_t ds1307_get_squarewave_freq(i2c_dev_t* dev)
+ds1307_squarewave_freq_t ds1307_get_squarewave_freq(i2c_dev_t *dev)
 {
     return (ds1307_squarewave_freq_t)(read_register(dev, CONTROL_REG) & SQWEF_MASK);
 }
 
-bool ds1307_get_output(i2c_dev_t* dev)
+bool ds1307_get_output(i2c_dev_t *dev)
 {
     return read_register(dev, CONTROL_REG) & OUT_BIT;
 }
 
-void ds1307_set_output(i2c_dev_t* dev, bool value)
+void ds1307_set_output(i2c_dev_t *dev, bool value)
 {
     update_register(dev, CONTROL_REG, OUT_MASK, value ? OUT_BIT : 0);
 }
 
-int ds1307_read_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len)
+int ds1307_read_ram(i2c_dev_t *dev, uint8_t offset, uint8_t *buf, uint8_t len)
 {
-    if (offset + len > RAM_SIZE) return false;
-    uint8_t reg = RAM_REG + offset ;
+    if (offset + len > RAM_SIZE)
+        return -EINVAL;
+
+    uint8_t reg = RAM_REG + offset;
 
     return i2c_slave_read(dev->bus, dev->addr, &reg, buf, len);
 }
 
-int ds1307_write_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len)
+int ds1307_write_ram(i2c_dev_t *dev, uint8_t offset, uint8_t *buf, uint8_t len)
 {
-    if (offset + len > RAM_SIZE) return false;
-    uint8_t reg = RAM_REG + offset ;
+    if (offset + len > RAM_SIZE)
+        return -EINVAL;
+
+    uint8_t reg = RAM_REG + offset;
 
     return i2c_slave_write(dev->bus, dev->addr, &reg, buf, len);
 }
diff --git a/extras/ds1307/ds1307.h b/extras/ds1307/ds1307.h
index 9baa904..aff8e34 100644
--- a/extras/ds1307/ds1307.h
+++ b/extras/ds1307/ds1307.h
@@ -17,11 +17,12 @@
 extern "C" {
 #endif
 
-#define DS1307_ADDR            0x68
+#define DS1307_ADDR 0x68
+
 /**
  * Squarewave frequency
  */
-typedef enum _ds1307_squarewave_freq_t
+typedef enum
 {
     DS1307_1HZ = 0, //!< 1 Hz
     DS1307_4096HZ,  //!< 4096 Hz
@@ -33,62 +34,62 @@ typedef enum _ds1307_squarewave_freq_t
  * \brief Start/stop clock
  * \param start Start clock if true
  */
-void ds1307_start(i2c_dev_t* dev, bool start);
+void ds1307_start(i2c_dev_t *dev, bool start);
 
 /**
  * \brief Get current clock state
  * \return true if clock running
  */
-bool ds1307_is_running(i2c_dev_t* dev);
+bool ds1307_is_running(i2c_dev_t *dev);
 
 /**
  * \brief Get current time
  * \param time Pointer to the time struct to fill
  */
-void ds1307_get_time(i2c_dev_t* dev, struct tm *time);
+void ds1307_get_time(i2c_dev_t *dev, struct tm *time);
 
 /**
  * \brief Set time to RTC
  * \param time Pointer to the time struct
  */
-void ds1307_set_time(i2c_dev_t* dev, const struct tm *time);
+void ds1307_set_time(i2c_dev_t *dev, const struct tm *time);
 
 /**
  * \brief Enable or disable square-wave oscillator output
  * \param enable Enable oscillator if true
  */
-void ds1307_enable_squarewave(i2c_dev_t* dev, bool enable);
+void ds1307_enable_squarewave(i2c_dev_t *dev, bool enable);
 
 /**
  * \brief Get square-wave oscillator output
  * \return true if square-wave oscillator enabled
  */
-bool ds1307_is_squarewave_enabled(i2c_dev_t* dev);
+bool ds1307_is_squarewave_enabled(i2c_dev_t *dev);
 
 /**
  * \brief Set square-wave oscillator frequency
  * \param freq Frequency
  */
-void ds1307_set_squarewave_freq(i2c_dev_t* dev, ds1307_squarewave_freq_t freq);
+void ds1307_set_squarewave_freq(i2c_dev_t *dev, ds1307_squarewave_freq_t freq);
 
 /**
  * \brief Get current square-wave oscillator frequency
  * \return Frequency
  */
-ds1307_squarewave_freq_t ds1307_get_squarewave_freq(i2c_dev_t* dev);
+ds1307_squarewave_freq_t ds1307_get_squarewave_freq(i2c_dev_t *dev);
 
 /**
  * \brief Get current output level of the SQW/OUT pin
  * \return true if high
  */
-bool ds1307_get_output(i2c_dev_t* dev);
+bool ds1307_get_output(i2c_dev_t *dev);
 
 /**
  * \brief Set output level of the SQW/OUT pin
  * Set output level if square-wave output is disabled
  * \param value High level if true
  */
-void ds1307_set_output(i2c_dev_t* dev, bool value);
+void ds1307_set_output(i2c_dev_t *dev, bool value);
 
 /**
  * \brief Read RAM contents into the buffer
@@ -97,7 +98,7 @@ void ds1307_set_output(i2c_dev_t* dev, bool value);
  * \param len Bytes to read, 1..56
  * \return Non-zero if error occured
  */
-int ds1307_read_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len);
+int ds1307_read_ram(i2c_dev_t *dev, uint8_t offset, uint8_t *buf, uint8_t len);
 
 /**
  * \brief Write buffer to RTC RAM
@@ -106,7 +107,7 @@ int ds1307_read_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len);
  * \param len Bytes to write, 1..56
  * \return Non-zero if error occured
  */
-int ds1307_write_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len);
+int ds1307_write_ram(i2c_dev_t *dev, uint8_t offset, uint8_t *buf, uint8_t len);
 
 
 #ifdef __cplusplus
diff --git a/extras/hd44780/README.md b/extras/hd44780/README.md
index 519bc92..c8f6b22 100644
--- a/extras/hd44780/README.md
+++ b/extras/hd44780/README.md
@@ -104,7 +104,7 @@ hd44780_t lcd = {
 hd44780_t lcd = {
     .addr = ADDR,
     .font = HD44780_FONT_5X8,
-    .lines = 2,
+    .lines = 4,
     .pins = {
         .rs = 0,
         .e  = 2,
diff --git a/extras/hmc5883l/hmc5883l.c b/extras/hmc5883l/hmc5883l.c
index e970fa2..2a95407 100644
--- a/extras/hmc5883l/hmc5883l.c
+++ b/extras/hmc5883l/hmc5883l.c
@@ -52,24 +52,24 @@ static const float gain_values [] = {
 static float current_gain;
 static hmc5883l_operating_mode_t current_mode;
 
-static inline void write_register(i2c_dev_t* dev, uint8_t reg, uint8_t val)
+static inline void write_register(i2c_dev_t *dev, uint8_t reg, uint8_t val)
 {
     i2c_slave_write(dev->bus, dev->addr, &reg, &val, 1);
 }
 
-static inline uint8_t read_register(i2c_dev_t* dev, uint8_t reg)
+static inline uint8_t read_register(i2c_dev_t *dev, uint8_t reg)
 {
     uint8_t res;
     i2c_slave_read(dev->bus, dev->addr, &reg, &res, 1);
     return res;
 }
 
-static inline void update_register(i2c_dev_t* dev, uint8_t reg, uint8_t mask, uint8_t val)
+static inline void update_register(i2c_dev_t *dev, uint8_t reg, uint8_t mask, uint8_t val)
 {
     write_register(dev, reg, (read_register(dev, reg) & mask) | val);
 }
 
-bool hmc5883l_init(i2c_dev_t* dev)
+bool hmc5883l_init(i2c_dev_t *dev)
 {
     if (hmc5883l_get_id(dev) != HMC5883L_ID)
         return false;
@@ -78,7 +78,7 @@ bool hmc5883l_init(i2c_dev_t* dev)
     return true;
 }
 
-uint32_t hmc5883l_get_id(i2c_dev_t* dev)
+uint32_t hmc5883l_get_id(i2c_dev_t *dev)
 {
     uint32_t res = 0;
     uint8_t reg = REG_ID_A;
@@ -86,70 +86,70 @@ uint32_t hmc5883l_get_id(i2c_dev_t* dev)
     return res;
 }
 
-hmc5883l_operating_mode_t hmc5883l_get_operating_mode(i2c_dev_t* dev)
+hmc5883l_operating_mode_t hmc5883l_get_operating_mode(i2c_dev_t *dev)
 {
     uint8_t res = read_register(dev, REG_MODE) & MASK_MD;
     return res == 0 ? HMC5883L_MODE_CONTINUOUS : HMC5883L_MODE_SINGLE;
 }
 
-void hmc5883l_set_operating_mode(i2c_dev_t* dev, hmc5883l_operating_mode_t mode)
+void hmc5883l_set_operating_mode(i2c_dev_t *dev, hmc5883l_operating_mode_t mode)
 {
     write_register(dev, REG_MODE, mode);
     current_mode = mode;
 }
 
-hmc5883l_samples_averaged_t hmc5883l_get_samples_averaged(i2c_dev_t* dev)
+hmc5883l_samples_averaged_t hmc5883l_get_samples_averaged(i2c_dev_t *dev)
 {
     return (read_register(dev, REG_CR_A) & MASK_MA) >> BIT_MA;
 }
 
-void hmc5883l_set_samples_averaged(i2c_dev_t* dev, hmc5883l_samples_averaged_t samples)
+void hmc5883l_set_samples_averaged(i2c_dev_t *dev, hmc5883l_samples_averaged_t samples)
 {
     update_register(dev, REG_CR_A, MASK_MA, samples << BIT_MA);
 }
 
-hmc5883l_data_rate_t hmc5883l_get_data_rate(i2c_dev_t* dev)
+hmc5883l_data_rate_t hmc5883l_get_data_rate(i2c_dev_t *dev)
 {
     return (read_register(dev, REG_CR_A) & MASK_DO) >> BIT_DO;
 }
 
-void hmc5883l_set_data_rate(i2c_dev_t* dev, hmc5883l_data_rate_t rate)
+void hmc5883l_set_data_rate(i2c_dev_t *dev, hmc5883l_data_rate_t rate)
 {
     update_register(dev, REG_CR_A, MASK_DO, rate << BIT_DO);
 }
 
-hmc5883l_bias_t hmc5883l_get_bias(i2c_dev_t* dev)
+hmc5883l_bias_t hmc5883l_get_bias(i2c_dev_t *dev)
 {
     return read_register(dev, REG_CR_A) & MASK_MS;
 }
 
-void hmc5883l_set_bias(i2c_dev_t* dev, hmc5883l_bias_t bias)
+void hmc5883l_set_bias(i2c_dev_t *dev, hmc5883l_bias_t bias)
 {
     update_register(dev, REG_CR_A, MASK_MS, bias);
 }
 
-hmc5883l_gain_t hmc5883l_get_gain(i2c_dev_t* dev)
+hmc5883l_gain_t hmc5883l_get_gain(i2c_dev_t *dev)
 {
     return read_register(dev, REG_CR_B) >> BIT_GN;
 }
 
-void hmc5883l_set_gain(i2c_dev_t* dev, hmc5883l_gain_t gain)
+void hmc5883l_set_gain(i2c_dev_t *dev, hmc5883l_gain_t gain)
 {
     write_register(dev, REG_CR_B, gain << BIT_GN);
     current_gain = gain_values[gain];
 }
 
-bool hmc5883l_data_is_locked(i2c_dev_t* dev)
+bool hmc5883l_data_is_locked(i2c_dev_t *dev)
 {
     return read_register(dev, REG_STAT) & MASK_DL;
 }
 
-bool hmc5883l_data_is_ready(i2c_dev_t* dev)
+bool hmc5883l_data_is_ready(i2c_dev_t *dev)
 {
     return read_register(dev, REG_STAT) & MASK_DR;
 }
 
-bool hmc5883l_get_raw_data(i2c_dev_t* dev, hmc5883l_raw_data_t *data)
+bool hmc5883l_get_raw_data(i2c_dev_t *dev, hmc5883l_raw_data_t *data)
 {
     if (current_mode == HMC5883L_MODE_SINGLE)
     {
@@ -179,7 +179,7 @@ void hmc5883l_raw_to_mg(const hmc5883l_raw_data_t *raw, hmc5883l_data_t *mg)
     mg->z = raw->z * current_gain;
 }
 
-bool hmc5883l_get_data(i2c_dev_t* dev, hmc5883l_data_t *data)
+bool hmc5883l_get_data(i2c_dev_t *dev, hmc5883l_data_t *data)
 {
     hmc5883l_raw_data_t raw;
 
diff --git a/extras/hmc5883l/hmc5883l.h b/extras/hmc5883l/hmc5883l.h
index 5958e61..041e818 100644
--- a/extras/hmc5883l/hmc5883l.h
+++ b/extras/hmc5883l/hmc5883l.h
@@ -104,82 +104,82 @@ typedef struct
  * \brief Init device
  * \return false if error occured
  */
-bool hmc5883l_init(i2c_dev_t* dev);
+bool hmc5883l_init(i2c_dev_t *dev);
 
 /**
  * \brief Get device ID
  * Always returns 0x00333448 if IC functioning properly.
  * \return Device ID
  */
-uint32_t hmc5883l_get_id(i2c_dev_t* dev);
+uint32_t hmc5883l_get_id(i2c_dev_t *dev);
 
 /**
  * \brief Get operating mode
  * \return Measurement mode
  */
-hmc5883l_operating_mode_t hmc5883l_get_operating_mode(i2c_dev_t* dev);
+hmc5883l_operating_mode_t hmc5883l_get_operating_mode(i2c_dev_t *dev);
 
 /**
  * \brief Set operating mode
  * \param mode Measurement mode
  */
-void hmc5883l_set_operating_mode(i2c_dev_t* dev, hmc5883l_operating_mode_t mode);
+void hmc5883l_set_operating_mode(i2c_dev_t *dev, hmc5883l_operating_mode_t mode);
 
 /**
  * \brief Get number of samples averaged per measurement output
  * \return Number of samples
  */
-hmc5883l_samples_averaged_t hmc5883l_get_samples_averaged(i2c_dev_t* dev);
+hmc5883l_samples_averaged_t hmc5883l_get_samples_averaged(i2c_dev_t *dev);
 
 /**
  * \brief Set number of samples averaged per measurement output
  * \param samples Number of samples
  */
-void hmc5883l_set_samples_averaged(i2c_dev_t* dev, hmc5883l_samples_averaged_t samples);
+void hmc5883l_set_samples_averaged(i2c_dev_t *dev, hmc5883l_samples_averaged_t samples);
 
 /**
  * \brief Get data output rate in continuous measurement mode
  * \return Data output rate
  */
-hmc5883l_data_rate_t hmc5883l_get_data_rate(i2c_dev_t* dev);
+hmc5883l_data_rate_t hmc5883l_get_data_rate(i2c_dev_t *dev);
 
 /**
  * \brief Set data output rate in continuous measurement mode
  * \param rate Data output rate
  */
-void hmc5883l_set_data_rate(i2c_dev_t* dev, hmc5883l_data_rate_t rate);
+void hmc5883l_set_data_rate(i2c_dev_t *dev, hmc5883l_data_rate_t rate);
 
 /**
  * \brief Get measurement mode (bias of the axes)
  * See datasheet for self test description
  * \return Bias
  */
-hmc5883l_bias_t hmc5883l_get_bias(i2c_dev_t* dev);
+hmc5883l_bias_t hmc5883l_get_bias(i2c_dev_t *dev);
 
 /**
  * \brief Set measurement mode (bias of the axes)
  * See datasheet for self test description
  * \param bias Bias
  */
-void hmc5883l_set_bias(i2c_dev_t* dev, hmc5883l_bias_t bias);
+void hmc5883l_set_bias(i2c_dev_t *dev, hmc5883l_bias_t bias);
 
 /**
  * \brief Get device gain
  * \return Current gain
  */
-hmc5883l_gain_t hmc5883l_get_gain(i2c_dev_t* dev);
+hmc5883l_gain_t hmc5883l_get_gain(i2c_dev_t *dev);
 
 /**
  * \brief Set device gain
  * \param gain Gain
  */
-void hmc5883l_set_gain(i2c_dev_t* dev, hmc5883l_gain_t gain);
+void hmc5883l_set_gain(i2c_dev_t *dev, hmc5883l_gain_t gain);
 
 /**
  * \brief Get data state
  * \return true when data is written to all six data registers
  */
-bool hmc5883l_data_is_ready(i2c_dev_t* dev);
+bool hmc5883l_data_is_ready(i2c_dev_t *dev);
 
 /**
  * \brief Get lock state.
@@ -191,14 +191,14 @@ bool hmc5883l_data_is_ready(i2c_dev_t* dev);
  * 4. power is reset.
  * \return true when data registers is locked
  */
-bool hmc5883l_data_is_locked(i2c_dev_t* dev);
+bool hmc5883l_data_is_locked(i2c_dev_t *dev);
 
 /**
  * \brief Get raw magnetic data
  * \param data Pointer to the struct to write raw data
  * \return false if error occured in single measurement mode, always true in continuous mode
  */
-bool hmc5883l_get_raw_data(i2c_dev_t* dev, hmc5883l_raw_data_t *data);
+bool hmc5883l_get_raw_data(i2c_dev_t *dev, hmc5883l_raw_data_t *data);
 
 /**
  * \brief Convert raw magnetic data to milligausses
@@ -212,7 +212,7 @@ void hmc5883l_raw_to_mg(const hmc5883l_raw_data_t *raw, hmc5883l_data_t *mg);
  * \param data Pointer to the struct to write data
  * \return false if error occured in single measurement mode, always true in continuous mode
  */
-bool hmc5883l_get_data(i2c_dev_t* dev, hmc5883l_data_t *data);
+bool hmc5883l_get_data(i2c_dev_t *dev, hmc5883l_data_t *data);
 
 #ifdef __cplusplus
 }
diff --git a/extras/ina3221/ina3221.c b/extras/ina3221/ina3221.c
index dc79735..1c6c51a 100644
--- a/extras/ina3221/ina3221.c
+++ b/extras/ina3221/ina3221.c
@@ -18,20 +18,20 @@
 #define debug(fmt, ...)
 #endif
 
-static int _wireWriteRegister (const i2c_dev_t* dev, uint8_t reg, uint16_t value)
+static int _wireWriteRegister(const i2c_dev_t *dev, uint8_t reg, uint16_t value)
 {
-    uint8_t d[2] = { 0 , 0 };
-    d[1] = value  & 0x00FF;
+    uint8_t d[2] = { 0, 0 };
+    d[1] = value & 0x00FF;
     d[0] = (value >> 8) & 0x00FF;
-    debug("Data write to bus %u at %02X : %02X+%04X\n",dev->bus, dev->addr, reg, value);
+    debug("Data write to bus %u at %02X : %02X+%04X\n", dev->bus, dev->addr, reg, value);
     return i2c_slave_write(dev->bus, dev->addr, &reg, d, sizeof(d));
 }
 
-static int _wireReadRegister(const i2c_dev_t* dev, uint8_t reg, uint16_t *value)
+static int _wireReadRegister(const i2c_dev_t *dev, uint8_t reg, uint16_t *value)
 {
-    uint8_t d[] = {0, 0};
-    int error = i2c_slave_read(dev->bus, dev->addr, &reg, d, sizeof(d))
-    debug("Data read from bus %u at %02X: %02X+%04X\n",dev->bus, dev->addr, reg, *value);
+    uint8_t d[] = { 0, 0 };
+    int error = i2c_slave_read(dev->bus, dev->addr, &reg, d, sizeof(d));
+    debug("Data read from bus %u at %02X: %02X+%04X\n", dev->bus, dev->addr, reg, *value);
     *value = d[1] | (d[0] << 8);
     return error;
 }
@@ -53,21 +53,23 @@ int ina3221_sync(ina3221_t *dev)
     //////////////////////// Sync config register
     if ((err = _wireReadRegister(&dev->i2c_dev, INA3221_REG_CONFIG, &ptr_data))) // Read config
         return err;
-    if( ptr_data != dev->config.config_register) {
+    if (ptr_data != dev->config.config_register)
+    {
         if ((err = _wireWriteRegister(&dev->i2c_dev, INA3221_REG_CONFIG, dev->config.config_register))) // Update config
             return err;
     }
     //////////////////////// Sync mask register config
     if ((err = _wireReadRegister(&dev->i2c_dev, INA3221_REG_MASK, &ptr_data))) // Read mask
         return err;
-    if( (ptr_data & INA3221_MASK_CONFIG) != (dev->mask.mask_register & INA3221_MASK_CONFIG)) {
+    if ((ptr_data & INA3221_MASK_CONFIG) != (dev->mask.mask_register & INA3221_MASK_CONFIG))
+    {
         if ((err = _wireWriteRegister(&dev->i2c_dev, INA3221_REG_MASK, dev->mask.mask_register & INA3221_MASK_CONFIG))) // Update config
             return err;
     }
     return 0;
 }
 
-int ina3221_setting(ina3221_t *dev ,bool mode, bool bus, bool shunt)
+int ina3221_setting(ina3221_t *dev, bool mode, bool bus, bool shunt)
 {
     dev->config.mode = mode;
     dev->config.ebus = bus;
@@ -75,7 +77,7 @@ int ina3221_setting(ina3221_t *dev ,bool mode, bool bus, bool shunt)
     return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_CONFIG, dev->config.config_register);
 }
 
-int ina3221_enableChannel(ina3221_t *dev ,bool ch1, bool ch2, bool ch3)
+int ina3221_enableChannel(ina3221_t *dev, bool ch1, bool ch2, bool ch3)
 {
     dev->config.ch1 = ch1;
     dev->config.ch2 = ch2;
@@ -83,7 +85,7 @@ int ina3221_enableChannel(ina3221_t *dev ,bool ch1, bool ch2, bool ch3)
     return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_CONFIG, dev->config.config_register);
 }
 
-int ina3221_enableChannelSum(ina3221_t *dev ,bool ch1, bool ch2, bool ch3)
+int ina3221_enableChannelSum(ina3221_t *dev, bool ch1, bool ch2, bool ch3)
 {
     dev->mask.scc1 = ch1;
     dev->mask.scc2 = ch2;
@@ -91,7 +93,7 @@ int ina3221_enableChannelSum(ina3221_t *dev ,bool ch1, bool ch2, bool ch3)
     return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_MASK, dev->mask.mask_register & INA3221_MASK_CONFIG);
 }
 
-int ina3221_enableLatchPin(ina3221_t *dev ,bool warning, bool critical)
+int ina3221_enableLatchPin(ina3221_t *dev, bool warning, bool critical)
 {
     dev->mask.wen = warning;
     dev->mask.cen = critical;
@@ -104,13 +106,13 @@ int ina3221_setAverage(ina3221_t *dev, ina3221_avg_t avg)
     return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_CONFIG, dev->config.config_register);
 }
 
-int ina3221_setBusConversionTime(ina3221_t *dev,ina3221_ct_t ct)
+int ina3221_setBusConversionTime(ina3221_t *dev, ina3221_ct_t ct)
 {
     dev->config.vbus = ct;
     return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_CONFIG, dev->config.config_register);
 }
 
-int ina3221_setShuntConversionTime(ina3221_t *dev,ina3221_ct_t ct)
+int ina3221_setShuntConversionTime(ina3221_t *dev, ina3221_ct_t ct)
 {
     dev->config.vsht = ct;
     return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_CONFIG, dev->config.config_register);
@@ -118,9 +120,9 @@ int ina3221_setShuntConversionTime(ina3221_t *dev,ina3221_ct_t ct)
 
 int ina3221_reset(ina3221_t *dev)
 {
-    dev->config.config_register = INA3221_DEFAULT_CONFIG ; //dev reset
-    dev->mask.mask_register = INA3221_DEFAULT_CONFIG ; //dev reset
-    dev->config.rst = 1 ;
+    dev->config.config_register = INA3221_DEFAULT_CONFIG; //dev reset
+    dev->mask.mask_register = INA3221_DEFAULT_CONFIG; //dev reset
+    dev->config.rst = 1;
     return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_CONFIG, dev->config.config_register); // send reset to device
 }
 
@@ -128,74 +130,74 @@ int ina3221_getBusVoltage(ina3221_t *dev, ina3221_channel_t channel, float *volt
 {
     int16_t raw_value;
     int err = 0;
-    if ((err = _wireReadRegister(&dev->i2c_dev,INA3221_REG_BUSVOLTAGE_1+channel*2, (uint16_t*)&raw_value)))
+    if ((err = _wireReadRegister(&dev->i2c_dev, INA3221_REG_BUSVOLTAGE_1 + channel * 2, (uint16_t*)&raw_value)))
         return err;
-    *voltage = raw_value*0.001 ; //V    8mV step
-	return 0;
+    *voltage = raw_value * 0.001; //V    8mV step
+    return 0;
 }
 
 int ina3221_getShuntValue(ina3221_t *dev, ina3221_channel_t channel, float *voltage, float *current)
 {
     int16_t raw_value;
-	int err = 0;
-    if ((err = _wireReadRegister(&dev->i2c_dev,INA3221_REG_SHUNTVOLTAGE_1+channel*2, (uint16_t*)&raw_value)))
+    int err = 0;
+    if ((err = _wireReadRegister(&dev->i2c_dev, INA3221_REG_SHUNTVOLTAGE_1 + channel * 2, (uint16_t*)&raw_value)))
         return err;
-    *voltage = raw_value*0.005; //mV   40uV step
-    if(!dev->shunt[channel])
+    *voltage = raw_value * 0.005; //mV   40uV step
+    if (!dev->shunt[channel])
     {
-        debug("No shunt configured for channel %u. Dev:%u:%X\n",channel+1, dev->bus, dev->addr);
+        debug("No shunt configured for channel %u. Dev:%u:%X\n", channel+1, dev->bus, dev->addr);
         return -EINVAL;
     }
-    *current = (*voltage*1000.0)/dev->shunt[channel] ;  //mA
-	return 0;
+    *current = (*voltage * 1000.0) / dev->shunt[channel];  //mA
+    return 0;
 }
 
 int ina3221_getSumShuntValue(ina3221_t *dev, float *voltage)
 {
     int16_t raw_value;
     int err = 0;
-    if ((err = _wireReadRegister(&dev->i2c_dev,INA3221_REG_SHUNT_VOLTAGE_SUM, (uint16_t*)&raw_value)))
+    if ((err = _wireReadRegister(&dev->i2c_dev, INA3221_REG_SHUNT_VOLTAGE_SUM, (uint16_t*)&raw_value)))
         return err;
-    *voltage = raw_value*0.02; //uV   40uV step
+    *voltage = raw_value * 0.02; //uV   40uV step
     return 0;
 }
 
 int ina3221_setCriticalAlert(ina3221_t *dev, ina3221_channel_t channel, float current)
 {
-    int16_t raw_value = current*dev->shunt[channel]*0.2; // format
-    return _wireWriteRegister(&dev->i2c_dev,INA3221_REG_CRITICAL_ALERT_1+channel*2, *(uint16_t*)&raw_value);
+    int16_t raw_value = current * dev->shunt[channel] * 0.2; // format
+    return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_CRITICAL_ALERT_1 + channel * 2, *(uint16_t*)&raw_value);
 }
 
 int ina3221_setWarningAlert(ina3221_t *dev, ina3221_channel_t channel, float current)
 {
-    int16_t raw_value = current*dev->shunt[channel]*0.2  ; // format
-    return _wireWriteRegister(&dev->i2c_dev,INA3221_REG_WARNING_ALERT_1+channel*2, *(uint16_t*)&raw_value);
+    int16_t raw_value = current * dev->shunt[channel] * 0.2; // format
+    return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_WARNING_ALERT_1 + channel * 2, *(uint16_t*)&raw_value);
 }
 
 int ina3221_setSumWarningAlert(ina3221_t *dev, float voltage)
 {
-    int16_t raw_value = voltage*50.0 ; // format
-    return _wireWriteRegister(&dev->i2c_dev,INA3221_REG_SHUNT_VOLTAGE_SUM_LIMIT, *(uint16_t*)&raw_value);
+    int16_t raw_value = voltage * 50.0; // format
+    return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_SHUNT_VOLTAGE_SUM_LIMIT, *(uint16_t*)&raw_value);
 }
 
 int ina3221_setPowerValidUpperLimit(ina3221_t *dev, float voltage)
 {
-    if(!dev->config.ebus)
+    if (!dev->config.ebus)
     {
         debug("Bus not enable. Dev:%u:%X\n", dev->bus, dev->addr);
         return -ENOTSUP;
     }
-    int16_t raw_value = voltage*1000.0; //format
-    return _wireWriteRegister(&dev->i2c_dev,INA3221_REG_VALID_POWER_UPPER_LIMIT, *(uint16_t*)&raw_value);
+    int16_t raw_value = voltage * 1000.0; //format
+    return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_VALID_POWER_UPPER_LIMIT, *(uint16_t*)&raw_value);
 }
 
 int ina3221_setPowerValidLowerLimit(ina3221_t *dev, float voltage)
 {
-    if(!dev->config.ebus)
+    if (!dev->config.ebus)
     {
         debug("Bus not enable. Dev:%u:%X\n", dev->bus, dev->addr);
         return -ENOTSUP;
     }
-    int16_t raw_value = voltage*1000.0; // round and format
-    return _wireWriteRegister(&dev->i2c_dev,INA3221_REG_VALID_POWER_LOWER_LIMIT, *(uint16_t*)&raw_value);
+    int16_t raw_value = voltage * 1000.0; // round and format
+    return _wireWriteRegister(&dev->i2c_dev, INA3221_REG_VALID_POWER_LOWER_LIMIT, *(uint16_t*)&raw_value);
 }
diff --git a/extras/ina3221/ina3221.h b/extras/ina3221/ina3221.h
index 627f3aa..c16206e 100644
--- a/extras/ina3221/ina3221.h
+++ b/extras/ina3221/ina3221.h
@@ -19,14 +19,14 @@
 extern "C" {
 #endif
 
-#include "i2c/i2c.h"
+#include <i2c/i2c.h>
 
-#define INA3221_ADDR_0  (0x40)      // A0 to GND
-#define INA3221_ADDR_1  (0x41)      // A0 to Vs+
-#define INA3221_ADDR_2  (0x42)      // A0 to SDA
-#define INA3221_ADDR_3  (0x43)      // A0 to SCL
+#define INA3221_ADDR_0  (0x40)      ///< A0 to GND
+#define INA3221_ADDR_1  (0x41)      ///< A0 to Vs+
+#define INA3221_ADDR_2  (0x42)      ///< A0 to SDA
+#define INA3221_ADDR_3  (0x43)      ///< A0 to SCL
 
-#define BUS_NUMBER 3  //Number of shunt available
+#define BUS_NUMBER 3  ///< Number of shunt available
 
 #define INA3221_REG_CONFIG                      (0x00)
 #define INA3221_REG_SHUNTVOLTAGE_1              (0x01)
@@ -39,7 +39,7 @@ extern "C" {
 #define INA3221_REG_VALID_POWER_UPPER_LIMIT     (0x10)
 #define INA3221_REG_VALID_POWER_LOWER_LIMIT     (0x11)
 
-/*
+/**
  *  Default register after reset
  */
 #define INA3221_DEFAULT_CONFIG                   (0x7127)
@@ -48,11 +48,12 @@ extern "C" {
 #define INA3221_DEFAULT_POWER_LOWER_LIMIT        (0x2328) //9V
 
 #define INA3221_MASK_CONFIG (0x7C00)
-/*
- * Numbrer of samples
+
+/**
+ * Number of samples
  */
 typedef enum {
-	INA3221_AVG_1 = 0,  //Default
+	INA3221_AVG_1 = 0,  ///< Default
 	INA3221_AVG_4,
 	INA3221_AVG_16,
 	INA3221_AVG_64,
@@ -62,7 +63,7 @@ typedef enum {
 	INA3221_AVG_1024,
 } ina3221_avg_t;
 
-/*
+/**
  * Channel selection list
  */
 typedef enum {
@@ -71,7 +72,7 @@ typedef enum {
     CHANNEL_3,
 } ina3221_channel_t;
 
-/*
+/**
  * Conversion time in us
  */
 typedef enum {
@@ -79,63 +80,63 @@ typedef enum {
 	INA3221_CT_204,
 	INA3221_CT_332,
 	INA3221_CT_588,
-	INA3221_CT_1100,  //Default
+	INA3221_CT_1100,  ///< Default
 	INA3221_CT_2116,
 	INA3221_CT_4156,
 	INA3221_CT_8244,
-} ina3221_ct_t ;
+} ina3221_ct_t;
 
-/*
+/**
  * Config description register
  */
 typedef union
 {
     struct {
-        uint16_t esht : 1; // Enable/Disable shunt measure    // LSB
-        uint16_t ebus : 1; // Enable/Disable bus measure
-        uint16_t mode : 1; // Single shot measure or continious mode
-        uint16_t vsht : 3; // Shunt voltage conversion time
-        uint16_t vbus : 3; // Bus voltage conversion time
-        uint16_t avg : 3; // number of sample collected and averaged together
-        uint16_t ch3 : 1; // Enable/Disable channel 3
-        uint16_t ch2 : 1; // Enable/Disable channel 2
-        uint16_t ch1 : 1; // Enable/Disable channel 1
-        uint16_t rst : 1; //Set this bit to 1 to reset device  // MSB
+        uint16_t esht : 1; ///< Enable/Disable shunt measure    // LSB
+        uint16_t ebus : 1; ///< Enable/Disable bus measure
+        uint16_t mode : 1; ///< Single shot measure or continious mode
+        uint16_t vsht : 3; ///< Shunt voltage conversion time
+        uint16_t vbus : 3; ///< Bus voltage conversion time
+        uint16_t avg  : 3; ///< number of sample collected and averaged together
+        uint16_t ch3  : 1; ///< Enable/Disable channel 3
+        uint16_t ch2  : 1; ///< Enable/Disable channel 2
+        uint16_t ch1  : 1; ///< Enable/Disable channel 1
+        uint16_t rst  : 1; ///< Set this bit to 1 to reset device  // MSB
     };
     uint16_t config_register;
 } ina3221_config_t;
 
 
-/*
+/**
  * Mask/enable description register
  */
 typedef union
 {
     struct {
-        uint16_t cvrf : 1 ; // Conversion ready flag (1: ready)   // LSB
-        uint16_t tcf : 1 ; // Timing control flag
-        uint16_t pvf : 1 ; // Power valid flag
-        uint16_t wf : 3 ; // Warning alert flag (Read mask to clear) (order : Channel1:channel2:channel3)
-        uint16_t sf : 1 ; // Sum alert flag (Read mask to clear)
-        uint16_t cf : 3 ; // Critical alert flag (Read mask to clear) (order : Channel1:channel2:channel3)
-        uint16_t cen : 1 ; // Critical alert latch (1:enable)
-        uint16_t wen : 1 ; // Warning alert latch (1:enable)
-        uint16_t scc3 : 1 ; // channel 3 sum (1:enable)
-        uint16_t scc2 : 1 ; // channel 2 sum (1:enable)
-        uint16_t scc1 : 1 ; // channel 1 sum (1:enable)
-        uint16_t  : 1 ; //Reserved         //MSB
+        uint16_t cvrf : 1; ///< Conversion ready flag (1: ready)   // LSB
+        uint16_t tcf  : 1; ///< Timing control flag
+        uint16_t pvf  : 1; ///< Power valid flag
+        uint16_t wf   : 3; ///< Warning alert flag (Read mask to clear) (order : Channel1:channel2:channel3)
+        uint16_t sf   : 1; ///< Sum alert flag (Read mask to clear)
+        uint16_t cf   : 3; ///< Critical alert flag (Read mask to clear) (order : Channel1:channel2:channel3)
+        uint16_t cen  : 1; ///< Critical alert latch (1:enable)
+        uint16_t wen  : 1; ///< Warning alert latch (1:enable)
+        uint16_t scc3 : 1; ///< channel 3 sum (1:enable)
+        uint16_t scc2 : 1; ///< channel 2 sum (1:enable)
+        uint16_t scc1 : 1; ///< channel 1 sum (1:enable)
+        uint16_t      : 1; ///< Reserved         //MSB
     };
     uint16_t mask_register;
 } ina3221_mask_t;
 
-/*
+/**
  *  Device description
  */
 typedef struct {
-    const i2c_dev_t i2c_dev; // ina3221 I2C address
-    const uint16_t shunt[BUS_NUMBER]; //Memory of shunt value  (mOhm)
-    ina3221_config_t config; //Memory of ina3221 config
-    ina3221_mask_t mask; //Memory of mask_config
+    const i2c_dev_t i2c_dev;          ///< ina3221 I2C address
+    const uint16_t shunt[BUS_NUMBER]; ///< Memory of shunt value (mOhm)
+    ina3221_config_t config;          ///< Memory of ina3221 config
+    ina3221_mask_t mask;              ///< Memory of mask_config
 } ina3221_t;
 
 /**
diff --git a/extras/mcp4725/mcp4725.c b/extras/mcp4725/mcp4725.c
index a478e67..edf2dbb 100644
--- a/extras/mcp4725/mcp4725.c
+++ b/extras/mcp4725/mcp4725.c
@@ -11,12 +11,12 @@
 #define CMD_EEPROM 0x60
 #define BIT_READY  0x80
 
-static void read_data(i2c_dev_t* dev, uint8_t *buf, uint8_t size)
+static void read_data(i2c_dev_t *dev, uint8_t *buf, uint8_t size)
 {
-    i2c_slave_read(dev->bus, dev->addr , NULL, buf, size);
+    i2c_slave_read(dev->bus, dev->addr, NULL, buf, size);
 }
 
-bool mcp4725_eeprom_busy(i2c_dev_t* dev)
+bool mcp4725_eeprom_busy(i2c_dev_t *dev)
 {
     uint8_t res;
     read_data(dev, &res, 1);
@@ -24,7 +24,7 @@ bool mcp4725_eeprom_busy(i2c_dev_t* dev)
     return !(res & BIT_READY);
 }
 
-mcp4725_power_mode_t mcp4725_get_power_mode(i2c_dev_t* dev, bool eeprom)
+mcp4725_power_mode_t mcp4725_get_power_mode(i2c_dev_t *dev, bool eeprom)
 {
     uint8_t buf[4];
     read_data(dev, buf, eeprom ? 4 : 1);
@@ -32,7 +32,7 @@ mcp4725_power_mode_t mcp4725_get_power_mode(i2c_dev_t* dev, bool eeprom)
     return (eeprom ? buf[3] >> 5 : buf[0] >> 1) & 0x03;
 }
 
-void mcp4725_set_power_mode(i2c_dev_t* dev, mcp4725_power_mode_t mode, bool eeprom)
+void mcp4725_set_power_mode(i2c_dev_t *dev, mcp4725_power_mode_t mode, bool eeprom)
 {
     uint16_t value = mcp4725_get_raw_output(dev, eeprom);
     uint8_t data[] = {
@@ -43,7 +43,7 @@ void mcp4725_set_power_mode(i2c_dev_t* dev, mcp4725_power_mode_t mode, bool eepr
     i2c_slave_write(dev->bus, dev->addr, &data[0], &data[1], 2);
 }
 
-uint16_t mcp4725_get_raw_output(i2c_dev_t* dev, bool eeprom)
+uint16_t mcp4725_get_raw_output(i2c_dev_t *dev, bool eeprom)
 {
     uint8_t buf[5];
     read_data(dev, buf, eeprom ? 5 : 3);
@@ -53,7 +53,7 @@ uint16_t mcp4725_get_raw_output(i2c_dev_t* dev, bool eeprom)
         : ((uint16_t)buf[0] << 4) | (buf[1] >> 4);
 }
 
-void mcp4725_set_raw_output(i2c_dev_t* dev, uint16_t value, bool eeprom)
+void mcp4725_set_raw_output(i2c_dev_t *dev, uint16_t value, bool eeprom)
 {
     uint8_t data[] = {
         (eeprom ? CMD_EEPROM : CMD_DAC),
diff --git a/extras/mcp4725/mcp4725.h b/extras/mcp4725/mcp4725.h
index edb29de..6e69601 100644
--- a/extras/mcp4725/mcp4725.h
+++ b/extras/mcp4725/mcp4725.h
@@ -42,7 +42,7 @@ typedef enum
  * @param addr Device address
  * @return true when EEPROM is busy
  */
-bool mcp4725_eeprom_busy(i2c_dev_t* dev);
+bool mcp4725_eeprom_busy(i2c_dev_t *dev);
 
 /**
  * Get power mode
@@ -50,7 +50,7 @@ bool mcp4725_eeprom_busy(i2c_dev_t* dev);
  * @param eeprom Read power mode from EEPROM if true
  * @return Power mode
  */
-mcp4725_power_mode_t mcp4725_get_power_mode(i2c_dev_t* dev, bool eeprom);
+mcp4725_power_mode_t mcp4725_get_power_mode(i2c_dev_t *dev, bool eeprom);
 
 /**
  * Set power mode
@@ -58,7 +58,7 @@ mcp4725_power_mode_t mcp4725_get_power_mode(i2c_dev_t* dev, bool eeprom);
  * @param mode Power mode
  * @param eeprom Store mode to device EEPROM if true
  */
-void mcp4725_set_power_mode(i2c_dev_t* dev, mcp4725_power_mode_t mode, bool eeprom);
+void mcp4725_set_power_mode(i2c_dev_t *dev, mcp4725_power_mode_t mode, bool eeprom);
 
 /**
  * Get current DAC value
@@ -66,7 +66,7 @@ void mcp4725_set_power_mode(i2c_dev_t* dev, mcp4725_power_mode_t mode, bool eepr
  * @param eeprom Read value from device EEPROM if true
  * @return Raw output value, 0..4095
  */
-uint16_t mcp4725_get_raw_output(i2c_dev_t* dev, bool eeprom);
+uint16_t mcp4725_get_raw_output(i2c_dev_t *dev, bool eeprom);
 
 /**
  * Set DAC output value
@@ -74,7 +74,7 @@ uint16_t mcp4725_get_raw_output(i2c_dev_t* dev, bool eeprom);
  * @param value Raw output value, 0..4095
  * @param eeprom Store value to device EEPROM if true
  */
-void mcp4725_set_raw_output(i2c_dev_t* dev, uint16_t value, bool eeprom);
+void mcp4725_set_raw_output(i2c_dev_t *dev, uint16_t value, bool eeprom);
 
 /**
  * Get current DAC output voltage
@@ -83,7 +83,7 @@ void mcp4725_set_raw_output(i2c_dev_t* dev, uint16_t value, bool eeprom);
  * @param eeprom Read voltage from device EEPROM if true
  * @return Current output voltage, volts
  */
-inline float mcp4725_get_voltage(i2c_dev_t* dev, float vdd, bool eeprom)
+inline float mcp4725_get_voltage(i2c_dev_t *dev, float vdd, bool eeprom)
 {
     return vdd / MCP4725_MAX_VALUE * mcp4725_get_raw_output(dev, eeprom);
 }
@@ -95,7 +95,7 @@ inline float mcp4725_get_voltage(i2c_dev_t* dev, float vdd, bool eeprom)
  * @param value Output value, volts
  * @param eeprom Store value to device EEPROM if true
  */
-inline void mcp4725_set_voltage(i2c_dev_t* dev, float vdd, float value, bool eeprom)
+inline void mcp4725_set_voltage(i2c_dev_t *dev, float vdd, float value, bool eeprom)
 {
     mcp4725_set_raw_output(dev, MCP4725_MAX_VALUE / vdd * value, eeprom);
 }
diff --git a/extras/ms561101ba03/ms561101ba03.c b/extras/ms561101ba03/ms561101ba03.c
index d88f488..a6f350e 100644
--- a/extras/ms561101ba03/ms561101ba03.c
+++ b/extras/ms561101ba03/ms561101ba03.c
@@ -25,7 +25,7 @@
  */
 #define CONVERSION_TIME     20 / portTICK_PERIOD_MS // milliseconds
 
-static inline int reset(i2c_dev_t* i2c_dev)
+static inline int reset(i2c_dev_t *i2c_dev)
 {
     uint8_t buf[1] = { RESET };
     return i2c_slave_write(i2c_dev->bus, i2c_dev->addr, NULL, buf, 1);
@@ -34,33 +34,33 @@ static inline int reset(i2c_dev_t* i2c_dev)
 static inline bool read_prom(ms561101ba03_t *dev)
 {
     uint8_t tmp[2] = { 0, 0 };
-    uint8_t reg = 0xA2 ;
+    uint8_t reg = 0xA2;
 
     if (i2c_slave_read(dev->i2c_dev.bus, dev->i2c_dev.addr, &reg, tmp, 2))
         return false;
     dev->config_data.sens = tmp[0] << 8 | tmp[1];
 
-    reg = 0xA4 ;
+    reg = 0xA4;
     if (i2c_slave_read(dev->i2c_dev.bus, dev->i2c_dev.addr, &reg, tmp, 2))
         return false;
     dev->config_data.off = tmp[0] << 8 | tmp[1];
 
-    reg = 0xA6 ;
+    reg = 0xA6;
     if (i2c_slave_read(dev->i2c_dev.bus, dev->i2c_dev.addr, &reg, tmp, 2))
         return false;
     dev->config_data.tcs = tmp[0] << 8 | tmp[1];
 
-    reg = 0xA8 ;
+    reg = 0xA8;
     if (i2c_slave_read(dev->i2c_dev.bus, dev->i2c_dev.addr, &reg, tmp, 2))
         return false;
     dev->config_data.tco = tmp[0] << 8 | tmp[1];
 
-    reg = 0xAA ;
+    reg = 0xAA;
     if (i2c_slave_read(dev->i2c_dev.bus, dev->i2c_dev.addr, &reg, tmp, 2))
         return false;
     dev->config_data.t_ref = tmp[0] << 8 | tmp[1];
 
-    reg = 0xAC ;
+    reg = 0xAC;
     if (i2c_slave_read(dev->i2c_dev.bus, dev->i2c_dev.addr, &reg, tmp, 2))
         return false;
     dev->config_data.tempsens = tmp[0] << 8 | tmp[1];
@@ -80,11 +80,11 @@ static inline int start_temperature_conversion(ms561101ba03_t *dev) //D2
     return i2c_slave_write(dev->i2c_dev.bus, dev->i2c_dev.addr, NULL, &buf, 1);
 }
 
-static inline bool read_adc(i2c_dev_t* i2c_dev, uint32_t *result)
+static inline bool read_adc(i2c_dev_t *i2c_dev, uint32_t *result)
 {
     *result = 0;
     uint8_t tmp[3];
-    uint8_t reg = 0x00 ;
+    uint8_t reg = 0x00;
     if (i2c_slave_read(i2c_dev->bus, i2c_dev->addr, &reg, tmp, 3))
         return false;
 
diff --git a/extras/ms561101ba03/ms561101ba03.h b/extras/ms561101ba03/ms561101ba03.h
index fb357e7..091f5f6 100644
--- a/extras/ms561101ba03/ms561101ba03.h
+++ b/extras/ms561101ba03/ms561101ba03.h
@@ -61,7 +61,7 @@ typedef struct
  */
 typedef struct
 {
-    i2c_dev_t i2c_dev;                           //!< I2C device settings
+    i2c_dev_t i2c_dev;                      //!< I2C device settings
     ms561101ba03_osr_t osr;                 //!< Oversampling setting
     ms561101ba03_config_data_t config_data; //!< Device configuration, filled upon initalize
     ms561101ba03_result_t result;           //!< Result, filled upon co
diff --git a/extras/onewire/onewire.c b/extras/onewire/onewire.c
index 159360b..5508684 100644
--- a/extras/onewire/onewire.c
+++ b/extras/onewire/onewire.c
@@ -108,7 +108,7 @@ bool onewire_write(int pin, uint8_t v) {
 bool onewire_write_bytes(int pin, const uint8_t *buf, size_t count) {
     size_t i;
 
-    for (i = 0 ; i < count ; i++) {
+    for (i = 0; i < count; i++) {
         if (!onewire_write(pin, buf[i])) {
             return false;
         }
@@ -138,7 +138,7 @@ bool onewire_read_bytes(int pin, uint8_t *buf, size_t count) {
     size_t i;
     int b;
 
-    for (i = 0 ; i < count ; i++) {
+    for (i = 0; i < count; i++) {
         b = onewire_read(pin);
         if (b < 0) return false;
         buf[i] = b;
@@ -434,7 +434,7 @@ uint16_t onewire_crc16(const uint8_t* input, size_t len, uint16_t crc_iv) {
         { 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 };
 
     uint16_t i;
-    for (i = 0 ; i < len ; i++) {
+    for (i = 0; i < len; i++) {
       // Even though we're just copying a byte from the input,
       // we'll be doing 16-bit computation with it.
       uint16_t cdata = input[i];
diff --git a/extras/pca9685/pca9685.c b/extras/pca9685/pca9685.c
index 6b04c31..b115170 100644
--- a/extras/pca9685/pca9685.c
+++ b/extras/pca9685/pca9685.c
@@ -58,13 +58,13 @@ inline static uint32_t round_div(uint32_t x, uint32_t y)
     return (x + y / 2) / y;
 }
 
-inline static void write_reg(i2c_dev_t* dev, uint8_t reg, uint8_t val)
+inline static void write_reg(i2c_dev_t *dev, uint8_t reg, uint8_t val)
 {
     if (i2c_slave_write(dev->bus, dev->addr, &reg, &val, 1))
         debug("Could not write 0x%02x to 0x%02x, bus %u, addr = 0x%02x", reg, val, dev->bus, dev->addr);
 }
 
-inline static uint8_t read_reg(i2c_dev_t* dev, uint8_t reg)
+inline static uint8_t read_reg(i2c_dev_t *dev, uint8_t reg)
 {
     uint8_t res = 0;
     if (i2c_slave_read(dev->bus, dev->addr, &reg, &res, 1))
@@ -72,18 +72,18 @@ inline static uint8_t read_reg(i2c_dev_t* dev, uint8_t reg)
     return res;
 }
 
-inline static void update_reg(i2c_dev_t* dev, uint8_t reg, uint8_t mask, uint8_t val)
+inline static void update_reg(i2c_dev_t *dev, uint8_t reg, uint8_t mask, uint8_t val)
 {
     write_reg(dev, reg, (read_reg(dev, reg) & ~mask) | val);
 }
 
-void pca9685_init(i2c_dev_t* dev)
+void pca9685_init(i2c_dev_t *dev)
 {
     // Enable autoincrement
     update_reg(dev, REG_MODE1, MODE1_AI, MODE1_AI);
 }
 
-bool pca9685_set_subaddr(i2c_dev_t* dev, uint8_t num, uint8_t subaddr, bool enable)
+bool pca9685_set_subaddr(i2c_dev_t *dev, uint8_t num, uint8_t subaddr, bool enable)
 {
     if (num > MAX_SUBADDR)
     {
@@ -99,19 +99,19 @@ bool pca9685_set_subaddr(i2c_dev_t* dev, uint8_t num, uint8_t subaddr, bool enab
     return true;
 }
 
-bool pca9685_is_sleeping(i2c_dev_t* dev)
+bool pca9685_is_sleeping(i2c_dev_t *dev)
 {
     return (read_reg(dev, REG_MODE1) & MODE1_SLEEP) != 0;
 }
 
-void pca9685_sleep(i2c_dev_t* dev, bool sleep)
+void pca9685_sleep(i2c_dev_t *dev, bool sleep)
 {
     update_reg(dev, REG_MODE1, MODE1_SLEEP, sleep ? MODE1_SLEEP : 0);
     if (!sleep)
         sdk_os_delay_us(WAKEUP_DELAY_US);
 }
 
-void pca9685_restart(i2c_dev_t* dev)
+void pca9685_restart(i2c_dev_t *dev)
 {
     uint8_t mode = read_reg(dev, REG_MODE1);
     if (mode & MODE1_RESTART)
@@ -122,32 +122,32 @@ void pca9685_restart(i2c_dev_t* dev)
     write_reg(dev, REG_MODE1, (mode & ~MODE1_SLEEP) | MODE1_RESTART);
 }
 
-bool pca9685_is_output_inverted(i2c_dev_t* dev)
+bool pca9685_is_output_inverted(i2c_dev_t *dev)
 {
     return (read_reg(dev, REG_MODE2) & MODE2_INVRT) != 0;
 }
 
-void pca9685_set_output_inverted(i2c_dev_t* dev, bool inverted)
+void pca9685_set_output_inverted(i2c_dev_t *dev, bool inverted)
 {
     update_reg(dev, REG_MODE2, MODE2_INVRT, inverted ? MODE2_INVRT : 0);
 }
 
-bool pca9685_get_output_open_drain(i2c_dev_t* dev)
+bool pca9685_get_output_open_drain(i2c_dev_t *dev)
 {
     return (read_reg(dev, REG_MODE2) & MODE2_OUTDRV) == 0;
 }
 
-void pca9685_set_output_open_drain(i2c_dev_t* dev, bool open_drain)
+void pca9685_set_output_open_drain(i2c_dev_t *dev, bool open_drain)
 {
     update_reg(dev, REG_MODE2, MODE2_OUTDRV, open_drain ? 0 : MODE2_OUTDRV);
 }
 
-uint8_t pca9685_get_prescaler(i2c_dev_t* dev)
+uint8_t pca9685_get_prescaler(i2c_dev_t *dev)
 {
     return read_reg(dev, REG_PRE_SCALE);
 }
 
-bool pca9685_set_prescaler(i2c_dev_t* dev, uint8_t prescaler)
+bool pca9685_set_prescaler(i2c_dev_t *dev, uint8_t prescaler)
 {
     if (prescaler < MIN_PRESCALER)
     {
@@ -161,12 +161,12 @@ bool pca9685_set_prescaler(i2c_dev_t* dev, uint8_t prescaler)
     return true;
 }
 
-uint16_t pca9685_get_pwm_frequency(i2c_dev_t* dev)
+uint16_t pca9685_get_pwm_frequency(i2c_dev_t *dev)
 {
     return INTERNAL_FREQ / ((uint32_t)4096 * (read_reg(dev, REG_PRE_SCALE) + 1));
 }
 
-bool pca9685_set_pwm_frequency(i2c_dev_t* dev, uint16_t freq)
+bool pca9685_set_pwm_frequency(i2c_dev_t *dev, uint16_t freq)
 {
     uint16_t prescaler = round_div(INTERNAL_FREQ, (uint32_t)4096 * freq) - 1;
     if (prescaler < MIN_PRESCALER || prescaler > MAX_PRESCALER)
@@ -178,7 +178,7 @@ bool pca9685_set_pwm_frequency(i2c_dev_t* dev, uint16_t freq)
     return pca9685_set_prescaler(dev, prescaler);
 }
 
-void pca9685_set_pwm_value(i2c_dev_t* dev, uint8_t channel, uint16_t val)
+void pca9685_set_pwm_value(i2c_dev_t *dev, uint8_t channel, uint16_t val)
 {
     uint8_t reg = channel > MAX_CHANNEL ? REG_ALL_LED : REG_LED_N(channel);
 
@@ -200,7 +200,7 @@ void pca9685_set_pwm_value(i2c_dev_t* dev, uint8_t channel, uint16_t val)
     }
 }
 
-bool pca9685_set_pwm_values(i2c_dev_t* dev, uint8_t first_ch, uint8_t channels, const uint16_t *values)
+bool pca9685_set_pwm_values(i2c_dev_t *dev, uint8_t first_ch, uint8_t channels, const uint16_t *values)
 {
     if (channels == 0 || first_ch + channels - 1 > MAX_CHANNEL)
     {
diff --git a/extras/pca9685/pca9685.h b/extras/pca9685/pca9685.h
index a92b964..94b877f 100644
--- a/extras/pca9685/pca9685.h
+++ b/extras/pca9685/pca9685.h
@@ -23,7 +23,7 @@ extern "C"
  * Init device
  * @param addr Device address
  */
-void pca9685_init(i2c_dev_t* dev);
+void pca9685_init(i2c_dev_t *dev);
 
 /**
  * Setup device subaddress (see section 7.3.6 if the datasheet)
@@ -33,62 +33,62 @@ void pca9685_init(i2c_dev_t* dev);
  * @param enable True to enable subaddress, false to disable
  * @return False if error occured
  */
-bool pca9685_set_subaddr(i2c_dev_t* dev, uint8_t num, uint8_t subaddr, bool enable);
+bool pca9685_set_subaddr(i2c_dev_t *dev, uint8_t num, uint8_t subaddr, bool enable);
 
 /**
  * Restart device (see section 7.3.1.1 of the datasheet)
  * @param addr Device address
  */
-void pca9685_restart(i2c_dev_t* dev);
+void pca9685_restart(i2c_dev_t *dev);
 
 /**
  * Check if device is in sleep mode
  * @param addr Device address
  * @return True if device is sleeping
  */
-bool pca9685_is_sleeping(i2c_dev_t* dev);
+bool pca9685_is_sleeping(i2c_dev_t *dev);
 
 /**
  * Switch device to low-power mode or wake it up.
  * @param addr Device address
  * @param sleep True for sleep mode, false for wake up
  */
-void pca9685_sleep(i2c_dev_t* dev, bool sleep);
+void pca9685_sleep(i2c_dev_t *dev, bool sleep);
 
 /**
  * Get logic inversion of the outputs
  * @param addr Device address
  * @return True if outputs are inverted, false otherwise
  */
-bool pca9685_is_output_inverted(i2c_dev_t* dev);
+bool pca9685_is_output_inverted(i2c_dev_t *dev);
 
 /**
  * Logically invert outputs (see section 7.7 of the datasheet)
  * @param addr Device address
  * @param inverted True for inverted outputs
  */
-void pca9685_set_output_inverted(i2c_dev_t* dev, bool inverted);
+void pca9685_set_output_inverted(i2c_dev_t *dev, bool inverted);
 
 /**
  * Get outputs mode
  * @param addr Device address
  * @return True if outputs are in open drain mode
  */
-bool pca9685_get_output_open_drain(i2c_dev_t* dev);
+bool pca9685_get_output_open_drain(i2c_dev_t *dev);
 
 /**
  * Set outputs mode
  * @param addr Device address
  * @param open_drain True to set open drain mode, false to normal mode
  */
-void pca9685_set_output_open_drain(i2c_dev_t* dev, bool open_drain);
+void pca9685_set_output_open_drain(i2c_dev_t *dev, bool open_drain);
 
 /**
  * Get current PWM frequency prescaler.
  * @param addr Device address
  * @return Frequency prescaler
  */
-uint8_t pca9685_get_prescaler(i2c_dev_t* dev);
+uint8_t pca9685_get_prescaler(i2c_dev_t *dev);
 
 /**
  * Set PWM frequency prescaler.
@@ -96,14 +96,14 @@ uint8_t pca9685_get_prescaler(i2c_dev_t* dev);
  * @param prescaler Prescaler value
  * @return False if error occured
  */
-bool pca9685_set_prescaler(i2c_dev_t* dev, uint8_t prescaler);
+bool pca9685_set_prescaler(i2c_dev_t *dev, uint8_t prescaler);
 
 /**
  * Get current PWM frequency
  * @param addr Device address
  * @return PWM frequency, Hz
  */
-uint16_t pca9685_get_pwm_frequency(i2c_dev_t* dev);
+uint16_t pca9685_get_pwm_frequency(i2c_dev_t *dev);
 
 /**
  * Set PWM frequency
@@ -111,7 +111,7 @@ uint16_t pca9685_get_pwm_frequency(i2c_dev_t* dev);
  * @param freq PWM frequency, Hz
  * @return False if error occured
  */
-bool pca9685_set_pwm_frequency(i2c_dev_t* dev, uint16_t freq);
+bool pca9685_set_pwm_frequency(i2c_dev_t *dev, uint16_t freq);
 
 /**
  * Set PWM value on output channel
@@ -119,7 +119,7 @@ bool pca9685_set_pwm_frequency(i2c_dev_t* dev, uint16_t freq);
  * @param channel Channel number, 0..15 or >15 for all channels
  * @param val PWM value, 0..4096
  */
-void pca9685_set_pwm_value(i2c_dev_t* dev, uint8_t channel, uint16_t val);
+void pca9685_set_pwm_value(i2c_dev_t *dev, uint8_t channel, uint16_t val);
 
 /**
  * Set PWM values on output channels
@@ -129,7 +129,7 @@ void pca9685_set_pwm_value(i2c_dev_t* dev, uint8_t channel, uint16_t val);
  * @param values Array of the channel values, each 0..4096
  * @return False if error occured
  */
-bool pca9685_set_pwm_values(i2c_dev_t* dev, uint8_t first_ch, uint8_t channels, const uint16_t *values);
+bool pca9685_set_pwm_values(i2c_dev_t *dev, uint8_t first_ch, uint8_t channels, const uint16_t *values);
 
 #ifdef __cplusplus
 }
diff --git a/extras/pcf8574/pcf8574.c b/extras/pcf8574/pcf8574.c
index ff9a92c..f3e1c84 100644
--- a/extras/pcf8574/pcf8574.c
+++ b/extras/pcf8574/pcf8574.c
@@ -1,14 +1,14 @@
 #include "pcf8574.h"
 
-uint8_t pcf8574_port_read(i2c_dev_t* dev)
+uint8_t pcf8574_port_read(i2c_dev_t *dev)
 {
     uint8_t res;
     if (i2c_slave_read(dev->bus, dev->addr, NULL, &res, 1))
-            return 0;
+        return 0;
     return res;
 }
 
-size_t pcf8574_port_read_buf(i2c_dev_t* dev, void *buf, size_t len)
+size_t pcf8574_port_read_buf(i2c_dev_t *dev, void *buf, size_t len)
 {
     if (!len || !buf) return 0;
     uint8_t *_buf = (uint8_t *)buf;
@@ -18,7 +18,7 @@ size_t pcf8574_port_read_buf(i2c_dev_t* dev, void *buf, size_t len)
     return len;
 }
 
-size_t pcf8574_port_write_buf(const i2c_dev_t* dev, void *buf, size_t len)
+size_t pcf8574_port_write_buf(const i2c_dev_t *dev, void *buf, size_t len)
 {
     if (!len || !buf) return 0;
     uint8_t *_buf = (uint8_t *)buf;
@@ -28,19 +28,19 @@ size_t pcf8574_port_write_buf(const i2c_dev_t* dev, void *buf, size_t len)
     return len;
 }
 
-void pcf8574_port_write(const i2c_dev_t* dev, uint8_t value)
+void pcf8574_port_write(const i2c_dev_t *dev, uint8_t value)
 {
     i2c_slave_write(dev->bus, dev->addr, NULL, &value, 1);
 }
 
-bool pcf8574_gpio_read(i2c_dev_t* dev, uint8_t num)
+bool pcf8574_gpio_read(i2c_dev_t *dev, uint8_t num)
 {
     return (bool)((pcf8574_port_read(dev) >> num) & 1);
 }
 
-void pcf8574_gpio_write(i2c_dev_t* dev, uint8_t num, bool value)
+void pcf8574_gpio_write(i2c_dev_t *dev, uint8_t num, bool value)
 {
     uint8_t bit = (uint8_t)value << num;
     uint8_t mask = ~(1 << num);
-    pcf8574_port_write (dev, (pcf8574_port_read(dev) & mask) | bit);
+    pcf8574_port_write(dev, (pcf8574_port_read(dev) & mask) | bit);
 }
diff --git a/extras/pcf8574/pcf8574.h b/extras/pcf8574/pcf8574.h
index 84b6ce0..4e2fed0 100644
--- a/extras/pcf8574/pcf8574.h
+++ b/extras/pcf8574/pcf8574.h
@@ -20,7 +20,7 @@ extern "C"
  * \param addr I2C register address (0b0100<A2><A1><A0> for PCF8574)
  * \return 8-bit GPIO port value
  */
-uint8_t pcf8574_port_read(i2c_dev_t* dev);
+uint8_t pcf8574_port_read(i2c_dev_t *dev);
 
 /**
  * \brief Continiously read GPIO port values to buffer
@@ -29,14 +29,14 @@ uint8_t pcf8574_port_read(i2c_dev_t* dev);
  * @param len Buffer length
  * @return Number of bytes read
  */
-size_t pcf8574_port_read_buf(i2c_dev_t* dev, void *buf, size_t len);
+size_t pcf8574_port_read_buf(i2c_dev_t *dev, void *buf, size_t len);
 
 /**
  * \brief Write value to GPIO port
  * \param addr I2C register address (0b0100<A2><A1><A0> for PCF8574)
  * \param value GPIO port value
  */
-void pcf8574_port_write(const i2c_dev_t* dev, uint8_t value);
+void pcf8574_port_write(const i2c_dev_t *dev, uint8_t value);
 
 /**
  * \brief Continiously write GPIO values to GPIO port
@@ -45,7 +45,7 @@ void pcf8574_port_write(const i2c_dev_t* dev, uint8_t value);
  * @param len Buffer length
  * @return Number of bytes written
  */
-size_t pcf8574_port_write_buf(const i2c_dev_t* dev, void *buf, size_t len);
+size_t pcf8574_port_write_buf(const i2c_dev_t *dev, void *buf, size_t len);
 
 /**
  * \brief Read input value of a GPIO pin
@@ -53,7 +53,7 @@ size_t pcf8574_port_write_buf(const i2c_dev_t* dev, void *buf, size_t len);
  * \param num pin number (0..7)
  * \return GPIO pin value
  */
-bool pcf8574_gpio_read(i2c_dev_t* dev, uint8_t num);
+bool pcf8574_gpio_read(i2c_dev_t *dev, uint8_t num);
 
 /**
  * \brief Set GPIO pin output
@@ -63,7 +63,7 @@ bool pcf8574_gpio_read(i2c_dev_t* dev, uint8_t num);
  * \param num pin number (0..7)
  * \param value true for high level
  */
-void pcf8574_gpio_write(i2c_dev_t* dev, uint8_t num, bool value);
+void pcf8574_gpio_write(i2c_dev_t *dev, uint8_t num, bool value);
 
 #ifdef __cplusplus
 }
diff --git a/extras/ssd1306/README.md b/extras/ssd1306/README.md
index f3a06e9..50d29fc 100644
--- a/extras/ssd1306/README.md
+++ b/extras/ssd1306/README.md
@@ -1,4 +1,4 @@
-# Driver for SSD1306 OLED LCD
+# Driver for SSD1306/SH1106 OLED LCD
 
 This driver is written for usage with the ESP8266 and FreeRTOS ([esp-open-rtos](https://github.com/SuperHouse/esp-open-rtos)).
 
@@ -11,34 +11,38 @@ This driver is written for usage with the ESP8266 and FreeRTOS ([esp-open-rtos](
 
 ## Supported connection interfaces
 
-Currently supported two of them: I2C and SPI4.
+I2C, SPI3 and SPI4.
 
 ## Usage
 
 If Reset pin is accesible in your display module, connect it to the RESET pin of ESP8266.
-If you don't do this, display RAM may be glitchy after the power lost/restore.
+If you don't, display RAM could be glitchy after the power cycle.
 
 ### I2C protocol
 
-Before using the SSD1306 LCD module the function `i2c_init(SCL_PIN, SDA_PIN)` needs to be
-called to setup the I2C interface and then you must call `ssd1306_init()`.
+Before using the OLED module you need to call the function `i2c_init(BUS, SCL_PIN, SDA_PIN, I2C_FREQ_400K)`
+to configure the I2C interface and then you should call `ssd1306_init()`.
 
 #### Example 
 
 ```C
 #define SCL_PIN 5
 #define SDA_PIN 4
+#define I2C_BUS 0
 ...
 
 static const ssd1306_t device = {
-	.protocol = SSD1306_PROTO_I2C,
-	.width = 128,
-	.height = 64
+	.protocol     = SSD1306_PROTO_I2C,
+	.screen       = SSD1306_SCREEN, // or SH1106_SCREEN
+	.i2c_dev.bus  = I2C_BUS,
+	.i2c_dev.addr = SSD1306_I2C_ADDR_0,
+	.width        = 128,
+	.height       = 64
 };
 
 ...
 
-i2c_init(SCL_PIN, SDA_PIN);
+i2c_init(I2C_BUS, SCL_PIN, SDA_PIN, I2C_FREQ_400K);
 
 if (ssd1306_init(&device)) {
 // An error occured, while performing SSD1306 init (E.g device not found etc.)
@@ -47,14 +51,15 @@ if (ssd1306_init(&device)) {
 // rest of the code
 ```
 
-### SPI4 protocol
+### SPI3 and SPI4 protocols
 
-This protocol MUCH faster than I2C but uses 2 additional GPIO pins (beside of HSPI CLK
-and HSPI MOSI): Data/Command pin and Chip Select pin.
+These protocols are MUCH faster than I2C, but use 2 additional GPIO pins
+(besides the **HSPI CLK** and **HSPI MOSI**): **Chip Select** and **Data/Command** (in case of SPI4).
 
 No additional function calls are required before `ssd1306_init()`.
 
-#### Example 
+
+#### SPI4 Example 
 
 ```C
 #define CS_PIN 5
@@ -64,10 +69,35 @@ No additional function calls are required before `ssd1306_init()`.
 
 static const ssd1306_t device = {
 	.protocol = SSD1306_PROTO_SPI4,
-	.cs_pin = CS_PIN,
-	.dc_pin = DC_PIN,
-	.width = 128,
-	.height = 64
+	.screen   = SSD1306_SCREEN,
+	.cs_pin   = CS_PIN,
+	.dc_pin   = DC_PIN,
+	.width    = 128,
+	.height   = 64
+};
+
+...
+
+if (ssd1306_init(&device)) {
+// An error occured, while performing SSD1306 init
+}
+
+// rest of the code
+```
+
+#### SPI3 example
+```C
+
+#define CS_PIN 5
+
+...
+
+static const ssd1306_t device = {
+	.protocol = SSD1306_PROTO_SPI3,
+	.screen   = SSD1306_SCREEN,
+	.cs_pin   = CS_PIN,
+	.width    = 128,
+	.height   = 64
 };
 
 ...
diff --git a/extras/ssd1306/ssd1306.c b/extras/ssd1306/ssd1306.c
index 372e867..6ce2c74 100644
--- a/extras/ssd1306/ssd1306.c
+++ b/extras/ssd1306/ssd1306.c
@@ -85,11 +85,10 @@
 #define abs(x) ((x)<0 ? -(x) : (x))
 #define swap(x, y) do { typeof(x) temp##x##y = x; x = y; y = temp##x##y; } while (0)
 
-
 #if (SSD1306_I2C_SUPPORT)
 static int inline i2c_send(const ssd1306_t *dev, uint8_t reg, uint8_t* data, uint8_t len)
 {
-    return i2c_slave_write(dev->i2c_dev.bus, dev->i2c_dev.addr , &reg, data, len);
+    return i2c_slave_write(dev->i2c_dev.bus, dev->i2c_dev.addr, &reg, data, len);
 }
 #endif
 
@@ -120,7 +119,7 @@ int ssd1306_command(const ssd1306_t *dev, uint8_t cmd)
 #if (SSD1306_SPI3_SUPPORT)
         case SSD1306_PROTO_SPI3:
             gpio_write(dev->cs_pin, false);
-            spi_set_command(SPI_BUS,1,0); // command mode
+            spi_set_command(SPI_BUS, 1, 0); // command mode
             spi_transfer_8(SPI_BUS, cmd);
             spi_clear_command(SPI_BUS);
             gpio_write(dev->cs_pin, true);
@@ -135,7 +134,7 @@ int ssd1306_command(const ssd1306_t *dev, uint8_t cmd)
 }
 
 /* Perform default init routine according
-* to SSD1306 datasheet from adafruit.com */
+ * to SSD1306 datasheet from adafruit.com */
 int ssd1306_init(const ssd1306_t *dev)
 {
     uint8_t pin_cfg;
@@ -221,10 +220,12 @@ int ssd1306_init(const ssd1306_t *dev)
     return -EIO;
 }
 
-static int sh1106_go_coordinate(const ssd1306_t *dev, uint8_t x, uint8_t y) {
-    if (x >= dev->width || y >= (dev->height/8)) return -EINVAL;
+static int sh1106_go_coordinate(const ssd1306_t *dev, uint8_t x, uint8_t y)
+{
+    if (x >= dev->width || y >= (dev->height / 8))
+        return -EINVAL;
     int err = 0;
-    x+=2 ; //offset : panel is 128 ; RAM is 132 for sh1106
+    x += 2; //offset : panel is 128 ; RAM is 132 for sh1106
     if ((err = ssd1306_command(dev, SH1106_SET_PAGE_ADDRESS + y))) // Set row
         return err;
     if ((err = ssd1306_command(dev, SH1106_SET_LOW_COL_ADDR | (x & 0xf))))  // Set lower column address
@@ -237,11 +238,10 @@ int ssd1306_load_frame_buffer(const ssd1306_t *dev, uint8_t buf[])
     uint16_t i;
     uint8_t j;
 #if (SSD1306_I2C_SUPPORT)
-    uint8_t tab[16] = { 0 } ;
+    uint8_t tab[16] = { 0 };
 #endif
     size_t len = dev->width * dev->height / 8;
-    if(dev->screen == SSD1306_SCREEN)
-    {
+    if (dev->screen == SSD1306_SCREEN) {
         ssd1306_set_column_addr(dev, 0, dev->width - 1);
         ssd1306_set_page_addr(dev, 0, dev->height / 8 - 1);
     }
@@ -249,35 +249,33 @@ int ssd1306_load_frame_buffer(const ssd1306_t *dev, uint8_t buf[])
     switch (dev->protocol) {
 #if (SSD1306_I2C_SUPPORT)
         case SSD1306_PROTO_I2C:
-            for (i = 0; i < len; i++)
-            {
-                if(dev->screen == SH1106_SCREEN && i%dev->width == 0) sh1106_go_coordinate(dev,0,i/dev->width);
+            for (i = 0; i < len; i++) {
+                if (dev->screen == SH1106_SCREEN && i % dev->width == 0)
+                    sh1106_go_coordinate(dev, 0, i / dev->width);
                 i2c_send(dev, 0x40, buf ? &buf[i] : tab, 16);
-                i+=15 ;
+                i += 15;
             }
             break;
 #endif
 #if (SSD1306_SPI4_SUPPORT)
         case SSD1306_PROTO_SPI4:
             gpio_write(dev->cs_pin, false);
-            if(dev->screen == SSD1306_SCREEN)
-            {
+            if (dev->screen == SSD1306_SCREEN) {
                 gpio_write(dev->dc_pin, true); // data mode
                 if (buf)
                     spi_transfer(SPI_BUS, buf, NULL, len, SPI_8BIT);
                 else
-                    spi_repeat_send_8(SPI_BUS,0,len);
+                    spi_repeat_send_8(SPI_BUS, 0, len);
             }
-            else
-            {
-                for (i = 0 ; i < (dev->height/8) ; i++) {
-                    sh1106_go_coordinate(dev,0,i);
+            else {
+                for (i = 0; i < (dev->height / 8); i++) {
+                    sh1106_go_coordinate(dev, 0, i);
                     gpio_write(dev->dc_pin, true); // data mode
                     gpio_write(dev->cs_pin, false);
                     if (buf)
-                        spi_transfer(SPI_BUS, &buf[dev->width*i], NULL, dev->width, SPI_8BIT);
+                        spi_transfer(SPI_BUS, &buf[dev->width * i], NULL, dev->width, SPI_8BIT);
                     else
-                        spi_repeat_send_8(SPI_BUS,0,dev->width);
+                        spi_repeat_send_8(SPI_BUS, 0, dev->width);
                 }
             }
             gpio_write(dev->cs_pin, true);
@@ -286,36 +284,30 @@ int ssd1306_load_frame_buffer(const ssd1306_t *dev, uint8_t buf[])
 #if (SSD1306_SPI3_SUPPORT)
         case SSD1306_PROTO_SPI3:
             gpio_write(dev->cs_pin, false);
-            if(dev->screen == SSD1306_SCREEN)
-            {
-                spi_set_command(SPI_BUS,1,1); // data mode
-                if (buf)
-                {
-                    for (i = 0; i < len; i++)
-                    {
+            if (dev->screen == SSD1306_SCREEN) {
+                spi_set_command(SPI_BUS, 1, 1); // data mode
+                if (buf) {
+                    for (i = 0; i < len; i++) {
                         spi_transfer(SPI_BUS, &buf[i], NULL, 1, SPI_8BIT);
                     }
                 }
-                else
-                {
-                    for (i = 0; i < len; i++)
-                    {
+                else {
+                    for (i = 0; i < len; i++) {
                         spi_transfer_8(SPI_BUS, 0);
                     }
                 }
             }
-            else
-            {
-                for (i = 0 ; i < (dev->height/8) ; i++) {
-                    sh1106_go_coordinate(dev,0,i);
-                    spi_set_command(SPI_BUS,1,1); // data mode
+            else {
+                for (i = 0; i < (dev->height / 8); i++) {
+                    sh1106_go_coordinate(dev, 0, i);
+                    spi_set_command(SPI_BUS, 1, 1); // data mode
                     gpio_write(dev->cs_pin, false);
                     if (buf)
-                        for (j = 0 ; j < dev->width ; j++)
-                            spi_transfer_8(SPI_BUS, buf[dev->width*i+j]);
+                        for (j = 0; j < dev->width; j++)
+                            spi_transfer_8(SPI_BUS, buf[dev->width * i + j]);
                     else
-                        for (j = 0 ; j < dev->width ; j++)
-                            spi_transfer_8(SPI_BUS, buf[dev->width*i+j]);
+                        for (j = 0; j < dev->width; j++)
+                            spi_transfer_8(SPI_BUS, buf[dev->width * i + j]);
                 }
             }
             spi_clear_command(SPI_BUS);
@@ -357,41 +349,38 @@ int ssd1306_set_display_offset(const ssd1306_t *dev, uint8_t offset)
 
 int sh1106_set_charge_pump_voltage(const ssd1306_t *dev, sh1106_voltage_t select)
 {
-    if (dev->screen == SSD1306_SCREEN)
-    {
+    if (dev->screen == SSD1306_SCREEN) {
         debug("Unsupported screen type");
-        return -ENOTSUP ;
+        return -ENOTSUP;
     }
     return ssd1306_command(dev, select | SH1106_CHARGE_PUMP_VALUE);
 }
 
-
 int ssd1306_set_charge_pump_enabled(const ssd1306_t *dev, bool enabled)
 {
     int err = 0;
     switch (dev->screen) {
-    case SH1106_SCREEN:
-        if ((err = ssd1306_command(dev, SH1106_SET_CHARGE_PUMP)))
-            return err;
-        return ssd1306_command(dev, enabled ? SH1106_CHARGE_PUMP_EN : SH1106_CHARGE_PUMP_DIS);
-        break;
-    case SSD1306_SCREEN:
-        if ((err = ssd1306_command(dev, SSD1306_SET_CHARGE_PUMP)))
-            return err;
-        return ssd1306_command(dev, enabled ? SSD1306_CHARGE_PUMP_EN : SSD1306_CHARGE_PUMP_DIS);
-        break;
-    default:
-        debug("Unsupported screen type");
-        return -ENOTSUP;
+        case SH1106_SCREEN:
+            if ((err = ssd1306_command(dev, SH1106_SET_CHARGE_PUMP)))
+                return err;
+            return ssd1306_command(dev, enabled ? SH1106_CHARGE_PUMP_EN : SH1106_CHARGE_PUMP_DIS);
+            break;
+        case SSD1306_SCREEN:
+            if ((err = ssd1306_command(dev, SSD1306_SET_CHARGE_PUMP)))
+                return err;
+            return ssd1306_command(dev, enabled ? SSD1306_CHARGE_PUMP_EN : SSD1306_CHARGE_PUMP_DIS);
+            break;
+        default:
+            debug("Unsupported screen type");
+            return -ENOTSUP;
     }
 }
 
 int ssd1306_set_mem_addr_mode(const ssd1306_t *dev, ssd1306_mem_addr_mode_t mode)
 {
-    if (dev->screen == SH1106_SCREEN)
-    {
+    if (dev->screen == SH1106_SCREEN) {
         debug("Unsupported screen type");
-        return -ENOTSUP ;
+        return -ENOTSUP;
     }
     int err = 0;
     if ((err = ssd1306_command(dev, SSD1306_SET_MEM_ADDR_MODE)))
@@ -498,7 +487,7 @@ int ssd1306_set_deseltct_lvl(const ssd1306_t *dev, uint8_t lvl)
 
 int ssd1306_set_whole_display_lighting(const ssd1306_t *dev, bool light)
 {
-    return ssd1306_command(dev, light ? SSD1306_SET_ENTIRE_DISP_ON :  SSD1306_SET_ENTIRE_DISP_OFF);
+    return ssd1306_command(dev, light ? SSD1306_SET_ENTIRE_DISP_ON : SSD1306_SET_ENTIRE_DISP_OFF);
 }
 
 /* one byte of xbm - 8 dots in line of picture source
@@ -510,9 +499,9 @@ int ssd1306_load_xbm(const ssd1306_t *dev, uint8_t *xbm, uint8_t *fb)
 
     int row = 0;
     int column = 0;
-    for (row = 0; row < dev->height; row ++) {
+    for (row = 0; row < dev->height; row++) {
         for (column = 0; column < dev->width / 8; column++) {
-            uint16_t xbm_offset = row * 16  + column;
+            uint16_t xbm_offset = row * 16 + column;
             for (bit = 0; bit < 8; bit++) {
                 if (*(xbm + xbm_offset) & 1 << bit) {
                     *(fb + dev->width * (row / 8) + column * 8 + bit) |= 1 << row % 8;
@@ -532,19 +521,18 @@ int ssd1306_draw_pixel(const ssd1306_t *dev, uint8_t *fb, int8_t x, int8_t y, ss
         return -EINVAL;
 
     index = x + (y / 8) * dev->width;
-    switch (color)
-    {
-    case OLED_COLOR_WHITE:
-        fb[index] |= (1 << (y & 7));
-        break;
-    case OLED_COLOR_BLACK:
-        fb[index] &= ~(1 << (y & 7));
-        break;
-    case OLED_COLOR_INVERT:
-        fb[index] ^= (1 << (y & 7));
-        break;
-    default:
-        break;
+    switch (color) {
+        case OLED_COLOR_WHITE:
+            fb[index] |= (1 << (y & 7));
+            break;
+        case OLED_COLOR_BLACK:
+            fb[index] &= ~(1 << (y & 7));
+            break;
+        case OLED_COLOR_INVERT:
+            fb[index] ^= (1 << (y & 7));
+            break;
+        default:
+            break;
     }
     return 0;
 }
@@ -565,32 +553,28 @@ int ssd1306_draw_hline(const ssd1306_t *dev, uint8_t *fb, int8_t x, int8_t y, ui
     t = w;
     index = x + (y / 8) * dev->width;
     mask = 1 << (y & 7);
-    switch (color)
-    {
-    case OLED_COLOR_WHITE:
-        while (t--)
-        {
-            fb[index] |= mask;
-            ++index;
-        }
-        break;
-    case OLED_COLOR_BLACK:
-        mask = ~mask;
-        while (t--)
-        {
-            fb[index] &= mask;
-            ++index;
-        }
-        break;
-    case OLED_COLOR_INVERT:
-        while (t--)
-        {
-            fb[index] ^= mask;
-            ++index;
-        }
-        break;
-    default:
-        break;
+    switch (color) {
+        case OLED_COLOR_WHITE:
+            while (t--) {
+                fb[index] |= mask;
+                ++index;
+            }
+            break;
+        case OLED_COLOR_BLACK:
+            mask = ~mask;
+            while (t--) {
+                fb[index] &= mask;
+                ++index;
+            }
+            break;
+        case OLED_COLOR_INVERT:
+            while (t--) {
+                fb[index] ^= mask;
+                ++index;
+            }
+            break;
+        default:
+            break;
     }
     return 0;
 }
@@ -619,19 +603,18 @@ int ssd1306_draw_vline(const ssd1306_t *dev, uint8_t *fb, int8_t x, int8_t y, ui
         mask = premask[mod];
         if (t < mod)
             mask &= (0xFF >> (mod - t));
-        switch (color)
-        {
-        case OLED_COLOR_WHITE:
-            fb[index] |= mask;
-            break;
-        case OLED_COLOR_BLACK:
-            fb[index] &= ~mask;
-            break;
-        case OLED_COLOR_INVERT:
-            fb[index] ^= mask;
-            break;
-        default:
-            break;
+        switch (color) {
+            case OLED_COLOR_WHITE:
+                fb[index] |= mask;
+                break;
+            case OLED_COLOR_BLACK:
+                fb[index] &= ~mask;
+                break;
+            case OLED_COLOR_INVERT:
+                fb[index] ^= mask;
+                break;
+            default:
+                break;
         }
 
         if (t < mod)
@@ -640,35 +623,31 @@ int ssd1306_draw_vline(const ssd1306_t *dev, uint8_t *fb, int8_t x, int8_t y, ui
         index += dev->width;
     }
     if (t >= 8) // byte aligned line at middle
-    {
-        switch (color)
-        {
-        case OLED_COLOR_WHITE:
-            do
             {
-               fb[index] = 0xff;
-               index += dev->width;
-               t -= 8;
-            } while (t >= 8);
-            break;
-        case OLED_COLOR_BLACK:
-            do
-            {
-               fb[index] = 0x00;
-               index += dev->width;
-               t -= 8;
-            } while (t >= 8);
-            break;
-        case OLED_COLOR_INVERT:
-            do
-            {
-                fb[index] = ~fb[index];
-                index += dev->width;
-                t -= 8;
-            } while (t >= 8);
-            break;
-        default:
-            break;
+        switch (color) {
+            case OLED_COLOR_WHITE:
+                do {
+                    fb[index] = 0xff;
+                    index += dev->width;
+                    t -= 8;
+                } while (t >= 8);
+                break;
+            case OLED_COLOR_BLACK:
+                do {
+                    fb[index] = 0x00;
+                    index += dev->width;
+                    t -= 8;
+                } while (t >= 8);
+                break;
+            case OLED_COLOR_INVERT:
+                do {
+                    fb[index] = ~fb[index];
+                    index += dev->width;
+                    t -= 8;
+                } while (t >= 8);
+                break;
+            default:
+                break;
         }
     }
     if (t) // partial line at bottom
@@ -676,19 +655,18 @@ int ssd1306_draw_vline(const ssd1306_t *dev, uint8_t *fb, int8_t x, int8_t y, ui
         mod = t & 7;
         static const uint8_t postmask[8] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F };
         mask = postmask[mod];
-        switch (color)
-        {
-        case OLED_COLOR_WHITE:
-            fb[index] |= mask;
-            break;
-        case OLED_COLOR_BLACK:
-            fb[index] &= ~mask;
-            break;
-        case OLED_COLOR_INVERT:
-            fb[index] ^= mask;
-            break;
-        default:
-            break;
+        switch (color) {
+            case OLED_COLOR_WHITE:
+                fb[index] |= mask;
+                break;
+            case OLED_COLOR_BLACK:
+                fb[index] &= ~mask;
+                break;
+            case OLED_COLOR_INVERT:
+                fb[index] ^= mask;
+                break;
+            default:
+                break;
         }
     }
     return 0;
@@ -706,7 +684,6 @@ int ssd1306_draw_rectangle(const ssd1306_t *dev, uint8_t *fb, int8_t x, int8_t y
     return ssd1306_draw_vline(dev, fb, x + w - 1, y, h, color);
 }
 
-
 int ssd1306_fill_rectangle(const ssd1306_t *dev, uint8_t *fb, int8_t x, int8_t y, uint8_t w, uint8_t h, ssd1306_color_t color)
 {
     // Can be optimized?
@@ -738,8 +715,7 @@ int ssd1306_draw_circle(const ssd1306_t *dev, uint8_t *fb, int8_t x0, int8_t y0,
     if ((err = ssd1306_draw_pixel(dev, fb, x0,     y0 + r, color)))
         return err;
 
-    while (x >= y)
-    {
+    while (x >= y) {
         if ((err = ssd1306_draw_pixel(dev, fb, x0 + x, y0 + y, color)))
             return err;
         if ((err = ssd1306_draw_pixel(dev, fb, x0 - x, y0 + y, color)))
@@ -748,8 +724,7 @@ int ssd1306_draw_circle(const ssd1306_t *dev, uint8_t *fb, int8_t x0, int8_t y0,
             return err;
         if ((err = ssd1306_draw_pixel(dev, fb, x0 - x, y0 - y, color)))
             return err;
-        if (x != y)
-        {
+        if (x != y) {
             /* Otherwise the 4 drawings below are the same as above, causing
              * problem when color is INVERT
              */
@@ -788,14 +763,12 @@ int ssd1306_fill_circle(const ssd1306_t *dev, uint8_t *fb, int8_t x0, int8_t y0,
 
     if ((err = ssd1306_draw_vline(dev, fb, x0, y0 - r, 2 * r + 1, color))) // Center vertical line
         return err;
-    while (y >= x)
-    {
+    while (y >= x) {
         if ((err = ssd1306_draw_vline(dev, fb, x0 - x, y0 - y, 2 * y + 1, color)))
             return err;
         if ((err = ssd1306_draw_vline(dev, fb, x0 + x, y0 - y, 2 * y + 1, color)))
             return err;
-        if (color != OLED_COLOR_INVERT)
-        {
+        if (color != OLED_COLOR_INVERT) {
             if ((err = ssd1306_draw_vline(dev, fb, x0 - y, y0 - x, 2 * x + 1, color)))
                 return err;
             if ((err = ssd1306_draw_vline(dev, fb, x0 + y, y0 - x, 2 * x + 1, color)))
@@ -811,8 +784,7 @@ int ssd1306_fill_circle(const ssd1306_t *dev, uint8_t *fb, int8_t x0, int8_t y0,
         }
     }
 
-    if (color == OLED_COLOR_INVERT)
-    {
+    if (color == OLED_COLOR_INVERT) {
         x1 = x; // Save where we stopped
 
         y = 1;
@@ -822,15 +794,14 @@ int ssd1306_fill_circle(const ssd1306_t *dev, uint8_t *fb, int8_t x0, int8_t y0,
             return err;
         if ((err = ssd1306_draw_hline(dev, fb, x0 - r, y0, r - x1 + 1, color)))
             return err;
-        while (x >= y)
-        {
+        while (x >= y) {
             if ((err = ssd1306_draw_hline(dev, fb, x0 + x1, y0 - y, x - x1 + 1, color)))
                 return err;
             if ((err = ssd1306_draw_hline(dev, fb, x0 + x1, y0 + y, x - x1 + 1, color)))
                 return err;
-            if ((err = ssd1306_draw_hline(dev, fb, x0 - x,  y0 - y, x - x1 + 1, color)))
+            if ((err = ssd1306_draw_hline(dev, fb, x0 - x, y0 - y, x - x1 + 1, color)))
                 return err;
-            if ((err = ssd1306_draw_hline(dev, fb, x0 - x,  y0 + y, x - x1 + 1, color)))
+            if ((err = ssd1306_draw_hline(dev, fb, x0 - x, y0 + y, x - x1 + 1, color)))
                 return err;
             ++y;
             if (radius_err < 0) {
@@ -845,59 +816,59 @@ int ssd1306_fill_circle(const ssd1306_t *dev, uint8_t *fb, int8_t x0, int8_t y0,
     return 0;
 }
 
-int ssd1306_draw_line(const ssd1306_t *dev, uint8_t *fb, int16_t x0, int16_t y0,
-    int16_t x1, int16_t y1, ssd1306_color_t color)
+int ssd1306_draw_line(const ssd1306_t *dev, uint8_t *fb, int16_t x0, int16_t y0, int16_t x1, int16_t y1, ssd1306_color_t color)
 {
     if ((x0 >= dev->width) || (x0 < 0) || (y0 >= dev->height) || (y0 < 0))
         return -EINVAL;
     if ((x1 >= dev->width) || (x1 < 0) || (y1 >= dev->height) || (y1 < 0))
         return -EINVAL;
 
-   int err;
-   bool steep = abs(y1 - y0) > abs(x1 - x0);
-   if (steep) {
-       swap(x0, y0);
-       swap(x1, y1);
-   }
+    int err;
+    bool steep = abs(y1 - y0) > abs(x1 - x0);
+    if (steep) {
+        swap(x0, y0);
+        swap(x1, y1);
+    }
 
-   if (x0 > x1) {
-       swap(x0, x1);
-       swap(y0, y1);
-   }
+    if (x0 > x1) {
+        swap(x0, x1);
+        swap(y0, y1);
+    }
 
-   int16_t dx, dy;
-   dx = x1 - x0;
-   dy = abs(y1 - y0);
+    int16_t dx, dy;
+    dx = x1 - x0;
+    dy = abs(y1 - y0);
 
-   int16_t errx = dx / 2;
-   int16_t ystep;
+    int16_t errx = dx / 2;
+    int16_t ystep;
 
-   if (y0 < y1) {
-       ystep = 1;
-   } else {
-       ystep = -1;
-   }
+    if (y0 < y1) {
+        ystep = 1;
+    }
+    else {
+        ystep = -1;
+    }
 
     for (; x0 <= x1; x0++) {
-       if (steep) {
-           if ((err = ssd1306_draw_pixel(dev, fb, y0, x0, color)))
-               return err;
-       } else {
-           if ((err = ssd1306_draw_pixel(dev, fb, x0, y0, color)))
-               return err;
-       }
-       errx -= dy;
-       if (errx < 0) {
-           y0 += ystep;
-           errx += dx;
-       }
-   }
-   return 0;
+        if (steep) {
+            if ((err = ssd1306_draw_pixel(dev, fb, y0, x0, color)))
+                return err;
+        }
+        else {
+            if ((err = ssd1306_draw_pixel(dev, fb, x0, y0, color)))
+                return err;
+        }
+        errx -= dy;
+        if (errx < 0) {
+            y0 += ystep;
+            errx += dx;
+        }
+    }
+    return 0;
 }
 
-int ssd1306_draw_triangle(const ssd1306_t *dev, uint8_t *fb, int16_t x0,
-    int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2,
-    ssd1306_color_t color)
+int ssd1306_draw_triangle(const ssd1306_t *dev, uint8_t *fb, int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2,
+        ssd1306_color_t color)
 {
     int err;
     if ((err = ssd1306_draw_line(dev, fb, x0, y0, x1, y1, color)))
@@ -907,25 +878,24 @@ int ssd1306_draw_triangle(const ssd1306_t *dev, uint8_t *fb, int16_t x0,
     return ssd1306_draw_line(dev, fb, x2, y2, x0, y0, color);
 }
 
-int ssd1306_fill_triangle(const ssd1306_t *dev, uint8_t *fb, int16_t x0,
-    int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2,
-    ssd1306_color_t color)
+int ssd1306_fill_triangle(const ssd1306_t *dev, uint8_t *fb, int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2,
+        ssd1306_color_t color)
 {
     int16_t a, b, y, last;
     int err;
 
     // Sort coordinates by Y order (y2 >= y1 >= y0)
     if (y0 > y1) {
-        swap(y0, y1); swap(x0, x1);
+        swap(y0, y1);swap(x0, x1);
     }
     if (y1 > y2) {
-        swap(y2, y1); swap(x2, x1);
+        swap(y2, y1);swap(x2, x1);
     }
     if (y0 > y1) {
-        swap(y0, y1); swap(x0, x1);
+        swap(y0, y1);swap(x0, x1);
     }
 
-    if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing
+    if (y0 == y2) { // Handle awkward all-on-same-line case as its own thing
         a = b = x0;
         if (x1 < a)      a = x1;
         else if (x1 > b) b = x1;
@@ -984,14 +954,13 @@ int ssd1306_fill_triangle(const ssd1306_t *dev, uint8_t *fb, int16_t x0,
         */
         if (a > b) swap(a, b);
         if ((err = ssd1306_draw_hline(dev, fb, a, y, b - a + 1, color)))
-           return err;
+            return err;
     }
     return 0;
 }
 
-int ssd1306_draw_char(const ssd1306_t *dev, uint8_t *fb,
-    const font_info_t *font, uint8_t x, uint8_t y, char c,
-    ssd1306_color_t foreground, ssd1306_color_t background)
+int ssd1306_draw_char(const ssd1306_t *dev, uint8_t *fb, const font_info_t *font, uint8_t x, uint8_t y, char c, ssd1306_color_t foreground,
+        ssd1306_color_t background)
 {
     uint8_t i, j;
     const uint8_t *bitmap;
@@ -1015,30 +984,29 @@ int ssd1306_draw_char(const ssd1306_t *dev, uint8_t *fb,
                 err = ssd1306_draw_pixel(dev, fb, x + i, y + j, foreground);
             }
             else {
-                switch (background)
-                {
-                case OLED_COLOR_TRANSPARENT:
-                    // Not drawing for transparent background
-                    break;
-                case OLED_COLOR_WHITE:
-                case OLED_COLOR_BLACK:
-                    err = ssd1306_draw_pixel(dev, fb, x + i, y + j, background);
-                    break;
-                case OLED_COLOR_INVERT:
-                    // I don't know why I need invert background
-                    break;
+                switch (background) {
+                    case OLED_COLOR_TRANSPARENT:
+                        // Not drawing for transparent background
+                        break;
+                    case OLED_COLOR_WHITE:
+                    case OLED_COLOR_BLACK:
+                        err = ssd1306_draw_pixel(dev, fb, x + i, y + j, background);
+                        break;
+                    case OLED_COLOR_INVERT:
+                        // I don't know why I need invert background
+                        break;
                 }
             }
-            if (err) return -ERANGE ;
+            if (err)
+                return -ERANGE;
             line = line << 1;
         }
     }
     return d->width;
 }
 
-int ssd1306_draw_string(const ssd1306_t *dev, uint8_t *fb,
-    const font_info_t *font, uint8_t x, uint8_t y, char *str,
-    ssd1306_color_t foreground, ssd1306_color_t background)
+int ssd1306_draw_string(const ssd1306_t *dev, uint8_t *fb, const font_info_t *font, uint8_t x, uint8_t y, char *str,
+        ssd1306_color_t foreground, ssd1306_color_t background)
 {
     uint8_t t = x;
     int err;
@@ -1046,11 +1014,10 @@ int ssd1306_draw_string(const ssd1306_t *dev, uint8_t *fb,
     if (font == NULL || str == NULL)
         return 0;
 
-    while (*str)
-    {
-        if ((err = ssd1306_draw_char(dev, fb, font, x, y, *str, foreground, background)) < 0 )
+    while (*str) {
+        if ((err = ssd1306_draw_char(dev, fb, font, x, y, *str, foreground, background)) < 0)
             return err;
-        x +=  err;
+        x += err;
         ++str;
         if (*str)
             x += font->c;
@@ -1067,13 +1034,11 @@ int ssd1306_start_scroll_hori(const ssd1306_t *dev, bool way, uint8_t start, uin
 {
     int err;
 
-    if (way)
-    {
+    if (way) {
         if ((err = ssd1306_command(dev, SSD1306_SCROLL_HOR_LEFT)))
             return err;
     }
-    else
-    {
+    else {
         if ((err = ssd1306_command(dev, SSD1306_SCROLL_HOR_RIGHT)))
             return err;
     }
@@ -1089,7 +1054,7 @@ int ssd1306_start_scroll_hori(const ssd1306_t *dev, bool way, uint8_t start, uin
     return -EIO;
 }
 
-int ssd1306_start_scroll_hori_vert(const ssd1306_t *dev, bool way,  uint8_t start, uint8_t stop, uint8_t dy, ssd1306_scroll_t frame)
+int ssd1306_start_scroll_hori_vert(const ssd1306_t *dev, bool way, uint8_t start, uint8_t stop, uint8_t dy, ssd1306_scroll_t frame)
 {
     //this function dont work well if no vertical setting.
     if ((!dy) || (dy > 63))
@@ -1104,13 +1069,11 @@ int ssd1306_start_scroll_hori_vert(const ssd1306_t *dev, bool way,  uint8_t star
     if ((err = ssd1306_command(dev, dev->height)))
         return err;
 
-    if (way)
-    {
+    if (way) {
         if ((err = ssd1306_command(dev, SSD1306_SCROLL_HOR_VER_LEFT)))
             return err;
     }
-    else
-    {
+    else {
         if ((err = ssd1306_command(dev, SSD1306_SCROLL_HOR_VER_RIGHT)))
             return err;
     }
diff --git a/extras/ssd1306/ssd1306.h b/extras/ssd1306/ssd1306.h
index 639517b..f79ed66 100644
--- a/extras/ssd1306/ssd1306.h
+++ b/extras/ssd1306/ssd1306.h
@@ -65,13 +65,16 @@ typedef enum
 typedef struct
 {
     ssd1306_protocol_t protocol;
-    ssd1306_screen_t screen ;
-    union {
+    ssd1306_screen_t screen;
+    union
+    {
 #if (SSD1306_I2C_SUPPORT)
         i2c_dev_t i2c_dev;         //!< I2C devuce descriptor, used by SSD1306_PROTO_I2C
 #endif
-        uint8_t cs_pin ;        //!< Chip Select GPIO pin, used by SSD1306_PROTO_SPI3, SSD1306_PROTO_SPI4
-    } ;
+#if (SSD1306_SPI4_SUPPORT) || (SSD1306_SPI3_SUPPORT)
+        uint8_t cs_pin;            //!< Chip Select GPIO pin, used by SSD1306_PROTO_SPI3, SSD1306_PROTO_SPI4
+#endif
+    };
 #if (SSD1306_SPI4_SUPPORT)
     uint8_t dc_pin;               //!< Data/Command GPIO pin, used by SSD1306_PROTO_SPI4
 #endif
@@ -520,7 +523,7 @@ int ssd1306_start_scroll_hori(const ssd1306_t *dev, bool way, uint8_t start, uin
  * @param frame Time interval between each scroll
  * @return Non-zero if error occured
  */
-int ssd1306_start_scroll_hori_vert(const ssd1306_t *dev, bool way,  uint8_t start, uint8_t stop, uint8_t dy, ssd1306_scroll_t frame);
+int ssd1306_start_scroll_hori_vert(const ssd1306_t *dev, bool way, uint8_t start, uint8_t stop, uint8_t dy, ssd1306_scroll_t frame);
 
 #ifdef __cplusplus
 extern "C"
diff --git a/extras/tsl2561/tsl2561.c b/extras/tsl2561/tsl2561.c
index cc89021..d17c074 100644
--- a/extras/tsl2561/tsl2561.c
+++ b/extras/tsl2561/tsl2561.c
@@ -95,26 +95,33 @@
 #define B8C 0x0000 // 0.000 * 2^LUX_SCALE
 #define M8C 0x0000 // 0.000 * 2^LUX_SCALE
 
-static int write_register(i2c_dev_t* i2c_dev, uint8_t reg, uint8_t value)
+#ifdef TSL2561_DEBUG
+#include <stdio.h>
+#define debug(fmt, ...) printf("%s: " fmt "\n", "TSL2561", ## __VA_ARGS__)
+#else
+#define debug(fmt, ...)
+#endif
+
+static int write_register(i2c_dev_t *i2c_dev, uint8_t reg, uint8_t value)
 {
     reg = TSL2561_REG_COMMAND | reg;
     return i2c_slave_write(i2c_dev->bus, i2c_dev->addr, &reg, &value, 1);
 }
 
-static uint8_t read_register(i2c_dev_t* i2c_dev, uint8_t reg)
+static uint8_t read_register(i2c_dev_t *i2c_dev, uint8_t reg)
 {
     uint8_t data[1];
     reg = TSL2561_REG_COMMAND | reg;
 
     if (i2c_slave_read(i2c_dev->bus, i2c_dev->addr, &reg, data, 1))
     {
-        printf("Error in tsl2561 read_register\n");
+        debug("Error in tsl2561 read_register\n");
     }
 
     return data[0];
 }
 
-static uint16_t read_register_16(i2c_dev_t* i2c_dev, uint8_t low_register_addr)
+static uint16_t read_register_16(i2c_dev_t *i2c_dev, uint8_t low_register_addr)
 {
     uint16_t value = 0;
     uint8_t data[2];
@@ -122,7 +129,7 @@ static uint16_t read_register_16(i2c_dev_t* i2c_dev, uint8_t low_register_addr)
 
     if (i2c_slave_read(i2c_dev->bus, i2c_dev->addr, &low_register_addr, data, 2))
     {
-        printf("Error with i2c_slave_read in read_register_16\n");
+        debug("Error with i2c_slave_read in read_register_16\n");
     }
 
     value = ((uint16_t)data[1] << 8) | (data[0]);
@@ -130,12 +137,12 @@ static uint16_t read_register_16(i2c_dev_t* i2c_dev, uint8_t low_register_addr)
     return value;
 }
 
-static int enable(i2c_dev_t* i2c_dev)
+static int enable(i2c_dev_t *i2c_dev)
 {
     return write_register(i2c_dev, TSL2561_REG_CONTROL, TSL2561_ON);
 }
 
-static int disable(i2c_dev_t* i2c_dev)
+static int disable(i2c_dev_t *i2c_dev)
 {
     return write_register(i2c_dev, TSL2561_REG_CONTROL, TSL2561_OFF);
 }
@@ -144,14 +151,14 @@ void tsl2561_init(tsl2561_t *device)
 {
     if (enable(&device->i2c_dev))
     {
-        printf("Error initializing tsl2561\n");
+        debug("Error initializing tsl2561\n");
     }
 
     uint8_t control_reg = (read_register(&device->i2c_dev, TSL2561_REG_CONTROL) & TSL2561_ON);
 
     if (control_reg != TSL2561_ON)
     {
-        printf("Error initializing tsl2561, control register wasn't set to ON\n");
+        debug("Error initializing tsl2561, control register wasn't set to ON\n");
     }
 
     // Fetch the package type
@@ -348,7 +355,7 @@ bool tsl2561_read_lux(tsl2561_t *device, uint32_t *lux)
 
             break;
         default:
-            printf("Invalid package type in CalculateLux\n");
+            debug("Invalid package type in CalculateLux\n");
             b = 0;
             m = 0;
             success = false;
diff --git a/extras/tsl4531/tsl4531.c b/extras/tsl4531/tsl4531.c
index a15a0ee..cac7669 100644
--- a/extras/tsl4531/tsl4531.c
+++ b/extras/tsl4531/tsl4531.c
@@ -26,13 +26,13 @@
 #define TSL4531_INTEGRATION_TIME_200MS 240
 #define TSL4531_INTEGRATION_TIME_400MS 480 // Default
 
-static int write_register(i2c_dev_t* i2c_dev, uint8_t reg, uint8_t value)
+static int write_register(i2c_dev_t *i2c_dev, uint8_t reg, uint8_t value)
 {
     reg = TSL4531_REG_COMMAND | reg;
     return i2c_slave_write(i2c_dev->bus, i2c_dev->addr, &reg, &value, 1);
 }
 
-static uint8_t read_register(i2c_dev_t* i2c_dev, uint8_t reg)
+static uint8_t read_register(i2c_dev_t *i2c_dev, uint8_t reg)
 {
     uint8_t data[1];
     reg = TSL4531_REG_COMMAND | reg;
@@ -45,7 +45,7 @@ static uint8_t read_register(i2c_dev_t* i2c_dev, uint8_t reg)
     return data[0];
 }
 
-static uint16_t read_register_16(i2c_dev_t* i2c_dev, uint8_t low_register_addr)
+static uint16_t read_register_16(i2c_dev_t *i2c_dev, uint8_t low_register_addr)
 {
     uint16_t value = 0;
     uint8_t data[2];