From 61e8c4f946e33487f37c16973dcb69ceda732fe3 Mon Sep 17 00:00:00 2001
From: Luc <luc.lebosse@tech-hunters.com>
Date: Mon, 1 Jul 2019 18:00:06 +0200
Subject: [PATCH] update to esp8266-oled-ssd1306-4.0.0

---
 esp3d/configuration.h                         |   8 +-
 esp3d/src/modules/display/display.cpp         |  28 +-
 esp3d/src/modules/display/display.h           |   4 +-
 esp3d/src/modules/display/esp3d_logo.h        |   2 +-
 esp3d/src/modules/display/esp3d_logob.h       |   2 +-
 .../.travis.yml                               |   1 +
 .../README.md                                 |  34 +-
 .../UPGRADE-3.0.md                            |   0
 .../esp8266-oled-ssd1306-4.0.0/UPGRADE-4.0.md |  27 +
 .../SSD1306ClockDemo/SSD1306ClockDemo.ino     |  13 +-
 .../examples/SSD1306ClockDemo/images.h        |   4 +-
 .../SSD1306DrawingDemo/SSD1306DrawingDemo.ino | 233 +++++++
 .../SSD1306OTADemo/SSD1306OTADemo.ino         |  20 +-
 .../SSD1306SimpleDemo/SSD1306SimpleDemo.ino   |  13 +-
 .../examples/SSD1306SimpleDemo/images.h       |   2 +-
 .../SSD1306TwoScreenDemo.ino                  |  75 +++
 .../examples/SSD1306TwoScreenDemo/images.h    |  28 +
 .../examples/SSD1306UiDemo/SSD1306UiDemo.ino  |  22 +-
 .../examples/SSD1306UiDemo/images.h           |   6 +-
 .../library.json                              |   6 +-
 .../library.properties                        |   4 +-
 .../license                                   |   0
 .../resources/DemoFrame1.jpg                  | Bin
 .../resources/DemoFrame2.jpg                  | Bin
 .../resources/DemoFrame3.jpg                  | Bin
 .../resources/DemoFrame4.jpg                  | Bin
 .../resources/FontTool.png                    | Bin
 .../resources/SPI_version.jpg                 | Bin
 .../resources/glyphEditor.html                | 633 ++++++++++++++++++
 .../resources/glyphEditor.png                 | Bin 0 -> 68751 bytes
 .../resources/xbmPreview.png                  | Bin
 .../src}/OLEDDisplay.cpp                      | 223 ++++--
 .../src}/OLEDDisplay.h                        | 109 ++-
 .../src}/OLEDDisplayFonts.h                   |   8 +-
 .../src}/OLEDDisplayUi.cpp                    |  70 +-
 .../src}/OLEDDisplayUi.h                      |  20 +-
 .../src}/SH1106.h                             |   9 +-
 .../src}/SH1106Brzo.h                         |  33 +-
 .../src}/SH1106Spi.h                          |  38 +-
 .../src}/SH1106Wire.h                         |  31 +-
 .../src}/SSD1306.h                            |   9 +-
 .../src}/SSD1306Brzo.h                        |  42 +-
 .../src}/SSD1306Spi.h                         |  42 +-
 .../src}/SSD1306Wire.h                        |  64 +-
 .../SSD1306DrawingDemo/SSD1306DrawingDemo.ino | 229 -------
 45 files changed, 1560 insertions(+), 532 deletions(-)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/.travis.yml (91%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/README.md (90%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/UPGRADE-3.0.md (100%)
 create mode 100644 libraries/esp8266-oled-ssd1306-4.0.0/UPGRADE-4.0.md
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/examples/SSD1306ClockDemo/SSD1306ClockDemo.ino (94%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/examples/SSD1306ClockDemo/images.h (71%)
 create mode 100644 libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306DrawingDemo/SSD1306DrawingDemo.ino
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/examples/SSD1306OTADemo/SSD1306OTADemo.ino (81%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/examples/SSD1306SimpleDemo/SSD1306SimpleDemo.ino (92%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/examples/SSD1306SimpleDemo/images.h (97%)
 create mode 100644 libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306TwoScreenDemo/SSD1306TwoScreenDemo.ino
 create mode 100644 libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306TwoScreenDemo/images.h
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/examples/SSD1306UiDemo/SSD1306UiDemo.ino (91%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/examples/SSD1306UiDemo/images.h (94%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/library.json (83%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/library.properties (84%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/license (100%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/resources/DemoFrame1.jpg (100%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/resources/DemoFrame2.jpg (100%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/resources/DemoFrame3.jpg (100%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/resources/DemoFrame4.jpg (100%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/resources/FontTool.png (100%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/resources/SPI_version.jpg (100%)
 create mode 100644 libraries/esp8266-oled-ssd1306-4.0.0/resources/glyphEditor.html
 create mode 100644 libraries/esp8266-oled-ssd1306-4.0.0/resources/glyphEditor.png
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0}/resources/xbmPreview.png (100%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/OLEDDisplay.cpp (79%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/OLEDDisplay.h (70%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/OLEDDisplayFonts.h (99%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/OLEDDisplayUi.cpp (86%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/OLEDDisplayUi.h (92%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/SH1106.h (81%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/SH1106Brzo.h (81%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/SH1106Spi.h (77%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/SH1106Wire.h (84%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/SSD1306.h (81%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/SSD1306Brzo.h (79%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/SSD1306Spi.h (78%)
 rename libraries/{oled-ssd1306 => esp8266-oled-ssd1306-4.0.0/src}/SSD1306Wire.h (69%)
 delete mode 100644 libraries/oled-ssd1306/examples/SSD1306DrawingDemo/SSD1306DrawingDemo.ino

diff --git a/esp3d/configuration.h b/esp3d/configuration.h
index 040cc3af..7facf4d7 100644
--- a/esp3d/configuration.h
+++ b/esp3d/configuration.h
@@ -43,22 +43,26 @@
 #define TELNET_FEATURE
 
 //WS_DATA_FEATURE: allow to connect serial from Websocket
-//#define WS_DATA_FEATURE
+#define WS_DATA_FEATURE
 
 //DISPLAY_DEVICE: allow screen output
 //OLED_I2C_SSD1306    		1
 //OLED_I2C_SSDSH1106  		2
 //TFT_SPI_ILI9341_320X240 	3
-//#define DISPLAY_DEVICE TFT_SPI_ILI9341_320X240
+#define DISPLAY_DEVICE OLED_I2C_SSD1306
 
 #if defined (DISPLAY_DEVICE)
 //for ILI9143 edit User_Setup.h of TFT_eSPI library
+#if (DISPLAY_DEVICE == OLED_I2C_SSD1306) || (DISPLAY_DEVICE == OLED_I2C_SSDSH1106)
 #define DISPLAY_I2C_PIN_SDA         4
 #define DISPLAY_I2C_PIN_SCL         15
 #define DISPLAY_I2C_PIN_RST         16 //comment if not applicable
 #define DISPLAY_I2C_ADDR	        0x3c
+#endif //(DISPLAY_DEVICE == OLED_I2C_SSD1306) || (DISPLAY_DEVICE == OLED_I2C_SSDSH1106)
 #define DISPLAY_FLIP_VERTICALY      1 //comment to disable
+#if DISPLAY_DEVICE == TFT_SPI_ILI9341_320X240
 #define DISPLAY_TOUCH_DRIVER		XPT2046_SPI
+#endif //DISPLAY_DEVICE == TFT_SPI_ILI9341_320X240
 #endif //DISPLAY_DEVICE
 
 //INPUT_DEVICE: allow input
diff --git a/esp3d/src/modules/display/display.cpp b/esp3d/src/modules/display/display.cpp
index 88e11bb0..a1ac4ed8 100644
--- a/esp3d/src/modules/display/display.cpp
+++ b/esp3d/src/modules/display/display.cpp
@@ -28,13 +28,13 @@
 #include "Wire.h"
 #include "esp3d_logo.h"
 #if DISPLAY_DEVICE == OLED_I2C_SSD1306
-#include <SSD1306.h>
-SSD1306  esp3d_screen(DISPLAY_I2C_ADDR, DISPLAY_I2C_PIN_SDA, DISPLAY_I2C_PIN_SCL);
+#include <SSD1306Wire.h>
+SSD1306Wire  esp3d_screen(DISPLAY_I2C_ADDR, DISPLAY_I2C_PIN_SDA, DISPLAY_I2C_PIN_SCL);
 #include "OLED_SSD1306.h"
 #endif //DISPLAY_DEVICE == OLED_I2C_SSD1306
 #if DISPLAY_DEVICE == OLED_I2C_SSDSH1106
-#include <SH1106.h>
-SH1106  esp3d_screen(DISPLAY_I2C_ADDR, (DISPLAY_I2C_PIN_SDA==-1)?SDA:DISPLAY_I2C_PIN_SDA, (DISPLAY_I2C_PIN_SCL==-1)?SCL:DISPLAY_I2C_PIN_SCL);
+#include <SH1106Wire.h>
+SH1106Wire  esp3d_screen(DISPLAY_I2C_ADDR, (DISPLAY_I2C_PIN_SDA==-1)?SDA:DISPLAY_I2C_PIN_SDA, (DISPLAY_I2C_PIN_SCL==-1)?SCL:DISPLAY_I2C_PIN_SCL);
 #include "OLED_SSDSH1106.h"
 #endif //DISPLAY_DEVICE == OLED_I2C_SSDSH1106
 #endif //DISPLAY_DEVICE == OLED_I2C_SSD1306 || DISPLAY_DEVICE == OLED_I2C_SSDSH1106
@@ -127,9 +127,11 @@ bool Display::showStatus(bool force)
         refresh_status = true;
         status+=" ";
         //log_esp3d("current %s", status.c_str());
-        if (status_shift > status.length()) {
+        if (status_shift != -1){
+            if( (uint16_t)(status_shift)> status.length()) {
             status_shift = -1;
-        }
+            }
+         }
         //log_esp3d("shift %d", status_shift);
         if (status_shift > 0) {
             status.remove(0,status_shift);
@@ -202,8 +204,10 @@ bool Display::display_signal(bool force)
             static int label_shift = -1;
             label+=" ";
             //log_esp3d("current %s", label.c_str());
-            if (label_shift > label.length()) {
-                label_shift = -1;
+            if (label_shift != -1) {
+                if((uint16_t)(label_shift)> label.length()) {
+                    label_shift = -1;
+                }
             }
             //log_esp3d("shift %d", label_shift);
             if (label_shift > 0) {
@@ -665,21 +669,21 @@ void Display::drawString(const char *string, int32_t poX, int32_t poY, int16_t c
 }
 
 // Draw a XBM
-void Display::drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, int16_t color, const unsigned char *xbm)
+void Display::drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, int16_t color, const uint8_t *xbm)
 {
     if ( !ESP3DOutput::isOutput(ESP_SCREEN_CLIENT)) {
         return;
     }
 #if DISPLAY_DEVICE == OLED_I2C_SSD1306 || DISPLAY_DEVICE == OLED_I2C_SSDSH1106
     (void)color;
-    esp3d_screen.drawXbm(x, y, width, height, (const char *)xbm);
+    esp3d_screen.drawXbm(x, y, width, height, xbm);
 #endif //#if DISPLAY_DEVICE == OLED_I2C_SSD1306 || DISPLAY_DEVICE == OLED_I2C_SSDSH1106
 #if DISPLAY_DEVICE == TFT_SPI_ILI9341_320X240
     esp3d_screen.drawXBitmap(x, y, xbm, width, height,color);
 #endif //TFT_SPI_ILI9341_240X320
 }
 
-void Display::drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t fgcolor, uint16_t bgcolor, const unsigned char *xbm)
+void Display::drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t fgcolor, uint16_t bgcolor, const uint8_t *xbm)
 {
     if ( !ESP3DOutput::isOutput(ESP_SCREEN_CLIENT)) {
         return;
@@ -687,7 +691,7 @@ void Display::drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, uint1
 #if DISPLAY_DEVICE == OLED_I2C_SSD1306 || DISPLAY_DEVICE == OLED_I2C_SSDSH1106
     (void)fgcolor;
     (void)bgcolor;
-    esp3d_screen.drawXbm(x, y, width, height, (const char *)xbm);
+    esp3d_screen.drawXbm(x, y, width, height, xbm);
 #endif //#if DISPLAY_DEVICE == OLED_I2C_SSD1306 || DISPLAY_DEVICE == OLED_I2C_SSDSH1106
 #if DISPLAY_DEVICE == TFT_SPI_ILI9341_320X240
     esp3d_screen.drawXBitmap(x, y, xbm, width, height, fgcolor, bgcolor);
diff --git a/esp3d/src/modules/display/display.h b/esp3d/src/modules/display/display.h
index e0c9ec5d..74f09d21 100644
--- a/esp3d/src/modules/display/display.h
+++ b/esp3d/src/modules/display/display.h
@@ -57,8 +57,8 @@ private:
     void fillRect(int16_t x, int16_t y, int16_t width, int16_t height, int16_t color);
     void setTextFont(uint8_t font);
     void drawString(const char *string, int32_t poX, int32_t poY, int16_t color);
-    void drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, int16_t color, const unsigned char *xbm);
-    void drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t fgcolor, uint16_t bgcolor, const unsigned char *xbm);
+    void drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, int16_t color, const uint8_t *xbm);
+    void drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, uint16_t fgcolor, uint16_t bgcolor, const uint8_t *xbm);
     uint16_t getStringWidth(const char* text);
     String _status;
 };
diff --git a/esp3d/src/modules/display/esp3d_logo.h b/esp3d/src/modules/display/esp3d_logo.h
index 9c8ad36a..7677bb78 100644
--- a/esp3d/src/modules/display/esp3d_logo.h
+++ b/esp3d/src/modules/display/esp3d_logo.h
@@ -23,7 +23,7 @@
 
 #define ESP3D_Logo_width 62
 #define ESP3D_Logo_height 45
-const unsigned char  ESP3D_Logo[] PROGMEM = {
+const uint8_t  ESP3D_Logo[] PROGMEM = {
     0x00, 0x00, 0x00, 0xFE, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF,
     0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x01, 0x00, 0x00,
     0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF,
diff --git a/esp3d/src/modules/display/esp3d_logob.h b/esp3d/src/modules/display/esp3d_logob.h
index 2f62d47d..508a8245 100644
--- a/esp3d/src/modules/display/esp3d_logob.h
+++ b/esp3d/src/modules/display/esp3d_logob.h
@@ -23,7 +23,7 @@
 
 #define ESP3D_Logo_width 200
 #define ESP3D_Logo_height 150
-const unsigned char  ESP3D_Logo[] PROGMEM = {
+const uint8_t  ESP3D_Logo[] PROGMEM = {
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
diff --git a/libraries/oled-ssd1306/.travis.yml b/libraries/esp8266-oled-ssd1306-4.0.0/.travis.yml
similarity index 91%
rename from libraries/oled-ssd1306/.travis.yml
rename to libraries/esp8266-oled-ssd1306-4.0.0/.travis.yml
index 88a1e72b..1ade30e9 100644
--- a/libraries/oled-ssd1306/.travis.yml
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/.travis.yml
@@ -14,6 +14,7 @@ env:
     - PLATFORMIO_CI_SRC=examples/SSD1306DrawingDemo
     - PLATFORMIO_CI_SRC=examples/SSD1306OTADemo
     - PLATFORMIO_CI_SRC=examples/SSD1306ClockDemo
+    - PLATFORMIO_CI_SRC=examples/SSD1306TwoScreenDemo
 
 
 install:
diff --git a/libraries/oled-ssd1306/README.md b/libraries/esp8266-oled-ssd1306-4.0.0/README.md
similarity index 90%
rename from libraries/oled-ssd1306/README.md
rename to libraries/esp8266-oled-ssd1306-4.0.0/README.md
index 01c134c3..d7db5ef9 100644
--- a/libraries/oled-ssd1306/README.md
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/README.md
@@ -1,7 +1,8 @@
-esp8266-oled-ssd1306 [![Build Status](https://travis-ci.org/squix78/esp8266-oled-ssd1306.svg?branch=dev-branch-3.0.0)](https://travis-ci.org/squix78/esp8266-oled-ssd1306)
-============
+[![Build Status](https://travis-ci.org/ThingPulse/esp8266-oled-ssd1306.svg?branch=master)](https://travis-ci.org/ThingPulse/esp8266-oled-ssd1306)
 
-> We just released version 3.0.0. Please have a look at our [upgrade guide](UPGRADE-3.0.md)
+# ESP8266 OLED SSD1306
+
+> We just released version 4.0.0. Please have a look at our [upgrade guide](UPGRADE-4.0.md)
 
 This is a driver for the SSD1306 based 128x64 pixel OLED display running on the Arduino/ESP8266 platform.
 Can be used with either the I2C or SPI version of the display
@@ -14,17 +15,20 @@ platformio lib install 562
 ```
 
 ## Credits
+
 This library has initially been written by Daniel Eichhorn (@squix78). Many thanks go to Fabrice Weinberg (@FWeinb) for optimizing and refactoring many aspects of the library. Also many thanks to the many committers who helped to add new features and who fixed many bugs.
 The init sequence for the SSD1306 was inspired by Adafruit's library for the same display.
 
 ## Usage
 
-Check out the examples folder for a few comprehensive demonstrations how to use the library. Also check out the ESP8266 Weather Station library (https://github.com/squix78/esp8266-weather-station) which uses the OLED library to display beautiful weather information.
+Check out the examples folder for a few comprehensive demonstrations how to use the library. Also check out the [ESP8266 Weather Station](https://github.com/ThingPulse/esp8266-weather-station) library which uses the OLED library to display beautiful weather information.
 
 ## Upgrade
 
 The API changed a lot with the 3.0 release. If you were using this library with older versions please have a look at the [Upgrade Guide](UPGRADE-3.0.md).
 
+Going from 3.x version to 4.0 a lot of internals changed and compatibility for more displays was added. Please read the [Upgrade Guide](UPGRADE-4.0.md).
+
 ## Features
 
 * Draw pixels at given coordinates
@@ -57,16 +61,16 @@ The library supports different protocols to access the OLED display. Currently t
 
 ```C++
 #include <Wire.h>  
-#include "SSD1306.h"
+#include "SSD1306Wire.h"
 
-SSD1306  display(ADDRESS, SDA, SDC);
+SSD1306Wire display(ADDRESS, SDA, SDC);
 ```
 or for a SH1106:
 ```C++
 #include <Wire.h>  
-#include "SH1106.h"
+#include "SH1106Wire.h"
 
-SH1106  display(ADDRESS, SDA, SDC);
+SH1106Wire display(ADDRESS, SDA, SDC);
 ```
 
 ### I2C with brzo_i2c
@@ -137,10 +141,18 @@ void invertDisplay(void);
 void normalDisplay(void);
 
 // Set display contrast
-void setContrast(char contrast);
+// really low brightness & contrast: contrast = 10, precharge = 5, comdetect = 0
+// normal brightness & contrast:  contrast = 100
+void setContrast(uint8_t contrast, uint8_t precharge = 241, uint8_t comdetect = 64);
+
+// Convenience method to access
+void setBrightness(uint8_t);
 
 // Turn the display upside down
 void flipScreenVertically();
+
+// Draw the screen mirrored
+void mirrorScreen();
 ```
 
 ## Pixel drawing
@@ -180,7 +192,7 @@ void drawVerticalLine(int16_t x, int16_t y, int16_t length);
 void drawProgressBar(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint8_t progress);
 
 // Draw a bitmap in the internal image format
-void drawFastImage(int16_t x, int16_t y, int16_t width, int16_t height, const char *image);
+void drawFastImage(int16_t x, int16_t y, int16_t width, int16_t height, const uint8_t *image);
 
 // Draw a XBM
 void drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, const char* xbm);
@@ -211,7 +223,7 @@ void setTextAlignment(OLEDDISPLAY_TEXT_ALIGNMENT textAlignment);
 // Sets the current font. Available default fonts
 // ArialMT_Plain_10, ArialMT_Plain_16, ArialMT_Plain_24
 // Or create one with the font tool at http://oleddisplay.squix.ch
-void setFont(const char* fontData);
+void setFont(const uint8_t* fontData);
 ```
 
 ## Ui Library (OLEDDisplayUi)
diff --git a/libraries/oled-ssd1306/UPGRADE-3.0.md b/libraries/esp8266-oled-ssd1306-4.0.0/UPGRADE-3.0.md
similarity index 100%
rename from libraries/oled-ssd1306/UPGRADE-3.0.md
rename to libraries/esp8266-oled-ssd1306-4.0.0/UPGRADE-3.0.md
diff --git a/libraries/esp8266-oled-ssd1306-4.0.0/UPGRADE-4.0.md b/libraries/esp8266-oled-ssd1306-4.0.0/UPGRADE-4.0.md
new file mode 100644
index 00000000..4b17693f
--- /dev/null
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/UPGRADE-4.0.md
@@ -0,0 +1,27 @@
+# Upgrade from 3.x to 4.0
+
+There are changes that breaks compatibility with older versions.
+
+1. You'll have to change data type for all your binary resources such as images and fonts from
+    
+    ```c
+    const char MySymbol[] PROGMEM = {
+    ```
+    
+    to
+    
+    ```c
+    const uint8_t MySymbol[] PROGMEM = {
+    ```
+
+1. Arguments of `setContrast` from `char` to `uint8_t`
+    
+    ```c++
+    void OLEDDisplay::setContrast(char contrast, char precharge, char comdetect);
+    ```
+    
+    to
+    
+    ```c++
+    void OLEDDisplay::setContrast(uint8_t contrast, uint8_t precharge, uint8_t comdetect);
+    ```
diff --git a/libraries/oled-ssd1306/examples/SSD1306ClockDemo/SSD1306ClockDemo.ino b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306ClockDemo/SSD1306ClockDemo.ino
similarity index 94%
rename from libraries/oled-ssd1306/examples/SSD1306ClockDemo/SSD1306ClockDemo.ino
rename to libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306ClockDemo/SSD1306ClockDemo.ino
index e9db7d64..63102cf0 100644
--- a/libraries/oled-ssd1306/examples/SSD1306ClockDemo/SSD1306ClockDemo.ino
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306ClockDemo/SSD1306ClockDemo.ino
@@ -1,8 +1,7 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,6 +21,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #include <TimeLib.h>
@@ -29,8 +32,8 @@
 // Include the correct display library
 // For a connection via I2C using Wire include
 #include <Wire.h>  // Only needed for Arduino 1.6.5 and earlier
-#include "SSD1306.h" // alias for `#include "SSD1306Wire.h"`
-// or #include "SH1106.h" alis for `#include "SH1106Wire.h"`
+#include "SSD1306Wire.h" // legacy include: `#include "SSD1306.h"`
+// or #include "SH1106Wire.h", legacy include: `#include "SH1106.h"`
 // For a connection via I2C using brzo_i2c (must be installed) include
 // #include <brzo_i2c.h> // Only needed for Arduino 1.6.5 and earlier
 // #include "SSD1306Brzo.h"
@@ -66,7 +69,7 @@
 // SH1106Brzo  display(0x3c, D3, D5);
 
 // Initialize the OLED display using Wire library
-SSD1306  display(0x3c, D3, D5);
+SSD1306Wire  display(0x3c, D3, D5);
 // SH1106 display(0x3c, D3, D5);
 
 OLEDDisplayUi ui ( &display );
diff --git a/libraries/oled-ssd1306/examples/SSD1306ClockDemo/images.h b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306ClockDemo/images.h
similarity index 71%
rename from libraries/oled-ssd1306/examples/SSD1306ClockDemo/images.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306ClockDemo/images.h
index a220a27c..1889188f 100644
--- a/libraries/oled-ssd1306/examples/SSD1306ClockDemo/images.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306ClockDemo/images.h
@@ -1,4 +1,4 @@
-const char activeSymbol[] PROGMEM = {
+const unsigned char activeSymbol[] PROGMEM = {
     B00000000,
     B00000000,
     B00011000,
@@ -9,7 +9,7 @@ const char activeSymbol[] PROGMEM = {
     B00011000
 };
 
-const char inactiveSymbol[] PROGMEM = {
+const unsigned char inactiveSymbol[] PROGMEM = {
     B00000000,
     B00000000,
     B00000000,
diff --git a/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306DrawingDemo/SSD1306DrawingDemo.ino b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306DrawingDemo/SSD1306DrawingDemo.ino
new file mode 100644
index 00000000..43bd9747
--- /dev/null
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306DrawingDemo/SSD1306DrawingDemo.ino
@@ -0,0 +1,233 @@
+ /**
+  * The MIT License (MIT)
+  *
+  * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+  * Copyright (c) 2018 by Fabrice Weinberg
+  *
+  * Permission is hereby granted, free of charge, to any person obtaining a copy
+  * of this software and associated documentation files (the "Software"), to deal
+  * in the Software without restriction, including without limitation the rights
+  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  * copies of the Software, and to permit persons to whom the Software is
+  * furnished to do so, subject to the following conditions:
+  *
+  * The above copyright notice and this permission notice shall be included in all
+  * copies or substantial portions of the Software.
+  *
+  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  * SOFTWARE.
+  *
+  * ThingPulse invests considerable time and money to develop these open source libraries.
+  * Please support us by buying our products (and not the clones) from
+  * https://thingpulse.com
+  *
+  */
+
+ // Include the correct display library
+ // For a connection via I2C using Wire include
+ #include <Wire.h>  // Only needed for Arduino 1.6.5 and earlier
+#include "SSD1306Wire.h" // legacy include: `#include "SSD1306.h"`
+ // or #include "SH1106Wire.h", legacy include: `#include "SH1106.h"`
+ // For a connection via I2C using brzo_i2c (must be installed) include
+ // #include <brzo_i2c.h> // Only needed for Arduino 1.6.5 and earlier
+ // #include "SSD1306Brzo.h"
+ // #include "SH1106Brzo.h"
+ // For a connection via SPI include
+ // #include <SPI.h> // Only needed for Arduino 1.6.5 and earlier
+ // #include "SSD1306Spi.h"
+ // #include "SH1106SPi.h"
+
+ // Use the corresponding display class:
+
+ // Initialize the OLED display using SPI
+ // D5 -> CLK
+ // D7 -> MOSI (DOUT)
+ // D0 -> RES
+ // D2 -> DC
+ // D8 -> CS
+ // SSD1306Spi        display(D0, D2, D8);
+ // or
+ // SH1106Spi         display(D0, D2);
+
+ // Initialize the OLED display using brzo_i2c
+ // D3 -> SDA
+ // D5 -> SCL
+ // SSD1306Brzo display(0x3c, D3, D5);
+ // or
+ // SH1106Brzo  display(0x3c, D3, D5);
+
+ // Initialize the OLED display using Wire library
+ SSD1306Wire  display(0x3c, D3, D5);
+ // SH1106 display(0x3c, D3, D5);
+
+// Adapted from Adafruit_SSD1306
+void drawLines() {
+  for (int16_t i=0; i<display.getWidth(); i+=4) {
+    display.drawLine(0, 0, i, display.getHeight()-1);
+    display.display();
+    delay(10);
+  }
+  for (int16_t i=0; i<display.getHeight(); i+=4) {
+    display.drawLine(0, 0, display.getWidth()-1, i);
+    display.display();
+    delay(10);
+  }
+  delay(250);
+
+  display.clear();
+  for (int16_t i=0; i<display.getWidth(); i+=4) {
+    display.drawLine(0, display.getHeight()-1, i, 0);
+    display.display();
+    delay(10);
+  }
+  for (int16_t i=display.getHeight()-1; i>=0; i-=4) {
+    display.drawLine(0, display.getHeight()-1, display.getWidth()-1, i);
+    display.display();
+    delay(10);
+  }
+  delay(250);
+
+  display.clear();
+  for (int16_t i=display.getWidth()-1; i>=0; i-=4) {
+    display.drawLine(display.getWidth()-1, display.getHeight()-1, i, 0);
+    display.display();
+    delay(10);
+  }
+  for (int16_t i=display.getHeight()-1; i>=0; i-=4) {
+    display.drawLine(display.getWidth()-1, display.getHeight()-1, 0, i);
+    display.display();
+    delay(10);
+  }
+  delay(250);
+  display.clear();
+  for (int16_t i=0; i<display.getHeight(); i+=4) {
+    display.drawLine(display.getWidth()-1, 0, 0, i);
+    display.display();
+    delay(10);
+  }
+  for (int16_t i=0; i<display.getWidth(); i+=4) {
+    display.drawLine(display.getWidth()-1, 0, i, display.getHeight()-1);
+    display.display();
+    delay(10);
+  }
+  delay(250);
+}
+
+// Adapted from Adafruit_SSD1306
+void drawRect(void) {
+  for (int16_t i=0; i<display.getHeight()/2; i+=2) {
+    display.drawRect(i, i, display.getWidth()-2*i, display.getHeight()-2*i);
+    display.display();
+    delay(10);
+  }
+}
+
+// Adapted from Adafruit_SSD1306
+void fillRect(void) {
+  uint8_t color = 1;
+  for (int16_t i=0; i<display.getHeight()/2; i+=3) {
+    display.setColor((color % 2 == 0) ? BLACK : WHITE); // alternate colors
+    display.fillRect(i, i, display.getWidth() - i*2, display.getHeight() - i*2);
+    display.display();
+    delay(10);
+    color++;
+  }
+  // Reset back to WHITE
+  display.setColor(WHITE);
+}
+
+// Adapted from Adafruit_SSD1306
+void drawCircle(void) {
+  for (int16_t i=0; i<display.getHeight(); i+=2) {
+    display.drawCircle(display.getWidth()/2, display.getHeight()/2, i);
+    display.display();
+    delay(10);
+  }
+  delay(1000);
+  display.clear();
+
+  // This will draw the part of the circel in quadrant 1
+  // Quadrants are numberd like this:
+  //   0010 | 0001
+  //  ------|-----
+  //   0100 | 1000
+  //
+  display.drawCircleQuads(display.getWidth()/2, display.getHeight()/2, display.getHeight()/4, 0b00000001);
+  display.display();
+  delay(200);
+  display.drawCircleQuads(display.getWidth()/2, display.getHeight()/2, display.getHeight()/4, 0b00000011);
+  display.display();
+  delay(200);
+  display.drawCircleQuads(display.getWidth()/2, display.getHeight()/2, display.getHeight()/4, 0b00000111);
+  display.display();
+  delay(200);
+  display.drawCircleQuads(display.getWidth()/2, display.getHeight()/2, display.getHeight()/4, 0b00001111);
+  display.display();
+}
+
+void printBuffer(void) {
+  // Initialize the log buffer
+  // allocate memory to store 8 lines of text and 30 chars per line.
+  display.setLogBuffer(5, 30);
+
+  // Some test data
+  const char* test[] = {
+      "Hello",
+      "World" ,
+      "----",
+      "Show off",
+      "how",
+      "the log buffer",
+      "is",
+      "working.",
+      "Even",
+      "scrolling is",
+      "working"
+  };
+
+  for (uint8_t i = 0; i < 11; i++) {
+    display.clear();
+    // Print to the screen
+    display.println(test[i]);
+    // Draw it to the internal screen buffer
+    display.drawLogBuffer(0, 0);
+    // Display it on the screen
+    display.display();
+    delay(500);
+  }
+}
+
+void setup() {
+  display.init();
+
+  // display.flipScreenVertically();
+
+  display.setContrast(255);
+
+  drawLines();
+  delay(1000);
+  display.clear();
+
+  drawRect();
+  delay(1000);
+  display.clear();
+
+  fillRect();
+  delay(1000);
+  display.clear();
+
+  drawCircle();
+  delay(1000);
+  display.clear();
+
+  printBuffer();
+  delay(1000);
+  display.clear();
+}
+
+void loop() { }
diff --git a/libraries/oled-ssd1306/examples/SSD1306OTADemo/SSD1306OTADemo.ino b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306OTADemo/SSD1306OTADemo.ino
similarity index 81%
rename from libraries/oled-ssd1306/examples/SSD1306OTADemo/SSD1306OTADemo.ino
rename to libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306OTADemo/SSD1306OTADemo.ino
index 6460ff9e..e207d4a9 100644
--- a/libraries/oled-ssd1306/examples/SSD1306OTADemo/SSD1306OTADemo.ino
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306OTADemo/SSD1306OTADemo.ino
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,6 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 // WiFi includes
@@ -38,8 +42,8 @@
 // Include the correct display library
 // For a connection via I2C using Wire include
 #include <Wire.h>  // Only needed for Arduino 1.6.5 and earlier
-#include "SSD1306.h" // alias for `#include "SSD1306Wire.h"`
-// or #include "SH1106.h" alis for `#include "SH1106Wire.h"`
+#include "SSD1306Wire.h" // legacy include: `#include "SSD1306.h"`
+// or #include "SH1106Wire.h", legacy include: `#include "SH1106.h"`
 // For a connection via I2C using brzo_i2c (must be installed) include
 // #include <brzo_i2c.h> // Only needed for Arduino 1.6.5 and earlier
 // #include "SSD1306Brzo.h"
@@ -69,7 +73,7 @@
 // SH1106Brzo  display(0x3c, D3, D5);
 
 // Initialize the OLED display using Wire library
-SSD1306  display(0x3c, D3, D5);
+SSD1306Wire  display(0x3c, D3, D5);
 // SH1106 display(0x3c, D3, D5);
 
 
@@ -90,7 +94,7 @@ void setup() {
     display.clear();
     display.setFont(ArialMT_Plain_10);
     display.setTextAlignment(TEXT_ALIGN_CENTER_BOTH);
-    display.drawString(DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2 - 10, "OTA Update");
+    display.drawString(display.getWidth()/2, display.getHeight()/2 - 10, "OTA Update");
     display.display();
   });
 
@@ -103,14 +107,14 @@ void setup() {
     display.clear();
     display.setFont(ArialMT_Plain_10);
     display.setTextAlignment(TEXT_ALIGN_CENTER_BOTH);
-    display.drawString(DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2, "Restart");
+    display.drawString(display.getWidth()/2, display.getHeight()/2, "Restart");
     display.display();
   });
 
   // Align text vertical/horizontal center
   display.setTextAlignment(TEXT_ALIGN_CENTER_BOTH);
   display.setFont(ArialMT_Plain_10);
-  display.drawString(DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2, "Ready for OTA:\n" + WiFi.localIP().toString());
+  display.drawString(display.getWidth()/2, display.getHeight()/2, "Ready for OTA:\n" + WiFi.localIP().toString());
   display.display();
 }
 
diff --git a/libraries/oled-ssd1306/examples/SSD1306SimpleDemo/SSD1306SimpleDemo.ino b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306SimpleDemo/SSD1306SimpleDemo.ino
similarity index 92%
rename from libraries/oled-ssd1306/examples/SSD1306SimpleDemo/SSD1306SimpleDemo.ino
rename to libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306SimpleDemo/SSD1306SimpleDemo.ino
index 6d3854a5..e567d45b 100644
--- a/libraries/oled-ssd1306/examples/SSD1306SimpleDemo/SSD1306SimpleDemo.ino
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306SimpleDemo/SSD1306SimpleDemo.ino
@@ -1,7 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -21,13 +22,17 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 // Include the correct display library
 // For a connection via I2C using Wire include
 #include <Wire.h>  // Only needed for Arduino 1.6.5 and earlier
-#include "SSD1306.h" // alias for `#include "SSD1306Wire.h"`
-// or #include "SH1106.h" alis for `#include "SH1106Wire.h"`
+#include "SSD1306Wire.h" // legacy include: `#include "SSD1306.h"`
+// or #include "SH1106Wire.h", legacy include: `#include "SH1106.h"`
 // For a connection via I2C using brzo_i2c (must be installed) include
 // #include <brzo_i2c.h> // Only needed for Arduino 1.6.5 and earlier
 // #include "SSD1306Brzo.h"
@@ -58,7 +63,7 @@
 // SH1106Brzo  display(0x3c, D3, D5);
 
 // Initialize the OLED display using Wire library
-SSD1306  display(0x3c, 4, 15);
+SSD1306Wire  display(0x3c, D3, D5);
 // SH1106 display(0x3c, D3, D5);
 
 
diff --git a/libraries/oled-ssd1306/examples/SSD1306SimpleDemo/images.h b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306SimpleDemo/images.h
similarity index 97%
rename from libraries/oled-ssd1306/examples/SSD1306SimpleDemo/images.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306SimpleDemo/images.h
index 9daf8c1a..50417990 100644
--- a/libraries/oled-ssd1306/examples/SSD1306SimpleDemo/images.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306SimpleDemo/images.h
@@ -1,6 +1,6 @@
 #define WiFi_Logo_width 60
 #define WiFi_Logo_height 36
-const char WiFi_Logo_bits[] PROGMEM = {
+const uint8_t WiFi_Logo_bits[] PROGMEM = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
diff --git a/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306TwoScreenDemo/SSD1306TwoScreenDemo.ino b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306TwoScreenDemo/SSD1306TwoScreenDemo.ino
new file mode 100644
index 00000000..b9595d8d
--- /dev/null
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306TwoScreenDemo/SSD1306TwoScreenDemo.ino
@@ -0,0 +1,75 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
+ */
+
+// Include the correct display library
+// For a connection via I2C using Wire include
+#include <Wire.h>  // Only needed for Arduino 1.6.5 and earlier
+#include "SSD1306Wire.h" // legacy include: `#include "SSD1306.h"`
+#include "images.h"
+
+// Initialize the OLED display using Wire library
+SSD1306Wire  display(0x3c, D3, D5);
+SSD1306Wire  display2(0x3c, D1, D2);
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println();
+
+
+  // Initialising the UI will init the display too.
+  display.init();
+  display2.init();
+
+  // This will make sure that multiple instances of a display driver
+  // running on different ports will work together transparently
+  display.setI2cAutoInit(true);
+  display2.setI2cAutoInit(true);
+
+  display.flipScreenVertically();
+  display.setFont(ArialMT_Plain_10);
+  display.setTextAlignment(TEXT_ALIGN_LEFT);
+
+  display2.flipScreenVertically();
+  display2.setFont(ArialMT_Plain_10);
+  display2.setTextAlignment(TEXT_ALIGN_LEFT);
+
+}
+
+void loop() {
+  display.clear();
+  display.drawString(0, 0, "Hello world: " + String(millis()));
+  display.display();
+
+  display2.clear();
+  display2.drawString(0, 0, "Hello world: " + String(millis()));
+  display2.display();
+
+  delay(10);
+}
diff --git a/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306TwoScreenDemo/images.h b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306TwoScreenDemo/images.h
new file mode 100644
index 00000000..50417990
--- /dev/null
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306TwoScreenDemo/images.h
@@ -0,0 +1,28 @@
+#define WiFi_Logo_width 60
+#define WiFi_Logo_height 36
+const uint8_t WiFi_Logo_bits[] PROGMEM = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
+  0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+  0xFF, 0x03, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+  0x00, 0xFF, 0xFF, 0xFF, 0x07, 0xC0, 0x83, 0x01, 0x80, 0xFF, 0xFF, 0xFF,
+  0x01, 0x00, 0x07, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x0C, 0x00,
+  0xC0, 0xFF, 0xFF, 0x7C, 0x00, 0x60, 0x0C, 0x00, 0xC0, 0x31, 0x46, 0x7C,
+  0xFC, 0x77, 0x08, 0x00, 0xE0, 0x23, 0xC6, 0x3C, 0xFC, 0x67, 0x18, 0x00,
+  0xE0, 0x23, 0xE4, 0x3F, 0x1C, 0x00, 0x18, 0x00, 0xE0, 0x23, 0x60, 0x3C,
+  0x1C, 0x70, 0x18, 0x00, 0xE0, 0x03, 0x60, 0x3C, 0x1C, 0x70, 0x18, 0x00,
+  0xE0, 0x07, 0x60, 0x3C, 0xFC, 0x73, 0x18, 0x00, 0xE0, 0x87, 0x70, 0x3C,
+  0xFC, 0x73, 0x18, 0x00, 0xE0, 0x87, 0x70, 0x3C, 0x1C, 0x70, 0x18, 0x00,
+  0xE0, 0x87, 0x70, 0x3C, 0x1C, 0x70, 0x18, 0x00, 0xE0, 0x8F, 0x71, 0x3C,
+  0x1C, 0x70, 0x18, 0x00, 0xC0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x08, 0x00,
+  0xC0, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x0C, 0x00, 0x80, 0xFF, 0xFF, 0x1F,
+  0x00, 0x00, 0x06, 0x00, 0x80, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x07, 0x00,
+  0x00, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0xF8, 0xFF, 0xFF,
+  0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x01, 0x00, 0x00,
+  0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
+  0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  };
diff --git a/libraries/oled-ssd1306/examples/SSD1306UiDemo/SSD1306UiDemo.ino b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306UiDemo/SSD1306UiDemo.ino
similarity index 91%
rename from libraries/oled-ssd1306/examples/SSD1306UiDemo/SSD1306UiDemo.ino
rename to libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306UiDemo/SSD1306UiDemo.ino
index ada991ad..72c836bf 100644
--- a/libraries/oled-ssd1306/examples/SSD1306UiDemo/SSD1306UiDemo.ino
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306UiDemo/SSD1306UiDemo.ino
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,13 +22,17 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
  // Include the correct display library
  // For a connection via I2C using Wire include
  #include <Wire.h>  // Only needed for Arduino 1.6.5 and earlier
- #include "SSD1306.h" // alias for `#include "SSD1306Wire.h"`
- // or #include "SH1106.h" alis for `#include "SH1106Wire.h"`
+ #include "SSD1306Wire.h" // legacy include: `#include "SSD1306.h"`
+ // or #include "SH1106Wire.h", legacy include: `#include "SH1106.h"`
  // For a connection via I2C using brzo_i2c (must be installed) include
  // #include <brzo_i2c.h> // Only needed for Arduino 1.6.5 and earlier
  // #include "SSD1306Brzo.h"
@@ -42,6 +46,7 @@
 #include "OLEDDisplayUi.h"
 
 // Include custom images
+
 #include "images.h"
 
 // Use the corresponding display class:
@@ -64,8 +69,8 @@
 // SH1106Brzo  display(0x3c, D3, D5);
 
 // Initialize the OLED display using Wire library
-SSD1306  display(0x3c, 4, 15);
-// SH1106 display(0x3c, D3, D5);
+SSD1306Wire  display(0x3c, D3, D5);
+// SH1106Wire display(0x3c, D3, D5);
 
 OLEDDisplayUi ui     ( &display );
 
@@ -139,11 +144,6 @@ OverlayCallback overlays[] = { msOverlay };
 int overlaysCount = 1;
 
 void setup() {
-    //For Embeded OLED on Wifi kit 32
-   pinMode(16,OUTPUT);
-   digitalWrite(16, LOW);   // turn the LED on (HIGH is the voltage level)
-   delay(100);                       // wait for a second
-   digitalWrite(16, HIGH);    // turn the LED off by making the voltage LOW
   Serial.begin(115200);
   Serial.println();
   Serial.println();
diff --git a/libraries/oled-ssd1306/examples/SSD1306UiDemo/images.h b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306UiDemo/images.h
similarity index 94%
rename from libraries/oled-ssd1306/examples/SSD1306UiDemo/images.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306UiDemo/images.h
index 8b876a36..2489d1e5 100644
--- a/libraries/oled-ssd1306/examples/SSD1306UiDemo/images.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/examples/SSD1306UiDemo/images.h
@@ -1,6 +1,6 @@
 #define WiFi_Logo_width 60
 #define WiFi_Logo_height 36
-const char WiFi_Logo_bits[] PROGMEM = {
+const uint8_t WiFi_Logo_bits[] PROGMEM = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF,
@@ -27,7 +27,7 @@ const char WiFi_Logo_bits[] PROGMEM = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
 
-const char activeSymbol[] PROGMEM = {
+const uint8_t activeSymbol[] PROGMEM = {
     B00000000,
     B00000000,
     B00011000,
@@ -38,7 +38,7 @@ const char activeSymbol[] PROGMEM = {
     B00011000
 };
 
-const char inactiveSymbol[] PROGMEM = {
+const uint8_t inactiveSymbol[] PROGMEM = {
     B00000000,
     B00000000,
     B00000000,
diff --git a/libraries/oled-ssd1306/library.json b/libraries/esp8266-oled-ssd1306-4.0.0/library.json
similarity index 83%
rename from libraries/oled-ssd1306/library.json
rename to libraries/esp8266-oled-ssd1306-4.0.0/library.json
index 862d1716..bd56922e 100644
--- a/libraries/oled-ssd1306/library.json
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/library.json
@@ -1,6 +1,6 @@
 {
   "name": "ESP8266_SSD1306",
-  "version": "3.2.7",
+  "version": "4.0.0",
   "keywords": "ssd1306, oled, display, i2c",
   "description": "A I2C display driver for SSD1306 oled displays connected to an ESP8266 or ESP32",
   "repository":
@@ -11,9 +11,9 @@
   "authors":
   [
     {
-        "name": "Daniel Eichhorn",
+        "name": "Daniel Eichhorn, ThingPulse",
         "email": "squix78@gmail.com",
-        "url": "http://blog.squix.ch"
+        "url": "https://thingpulse.com"
     },
     {
         "name": "Fabrice Weinberg",
diff --git a/libraries/oled-ssd1306/library.properties b/libraries/esp8266-oled-ssd1306-4.0.0/library.properties
similarity index 84%
rename from libraries/oled-ssd1306/library.properties
rename to libraries/esp8266-oled-ssd1306-4.0.0/library.properties
index 4f8de4cf..5e32ef22 100644
--- a/libraries/oled-ssd1306/library.properties
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/library.properties
@@ -1,9 +1,9 @@
 name=ESP8266 and ESP32 Oled Driver for SSD1306 display
-version=3.2.7
+version=4.0.0
 author=Daniel Eichhorn, Fabrice Weinberg
 maintainer=Daniel Eichhorn <squix78@gmail.com>
 sentence=A I2C display driver for SSD1306 oled displays connected to an ESP8266 or ESP32
 paragraph=A I2C display driver for SSD1306 oled displays connected to an ESP8266 or ESP32
 category=Display
-url=https://github.com/squix78/esp8266-oled-ssd1306
+url=https://github.com/ThingPulse/esp8266-oled-ssd1306
 architectures=esp8266,esp32
diff --git a/libraries/oled-ssd1306/license b/libraries/esp8266-oled-ssd1306-4.0.0/license
similarity index 100%
rename from libraries/oled-ssd1306/license
rename to libraries/esp8266-oled-ssd1306-4.0.0/license
diff --git a/libraries/oled-ssd1306/resources/DemoFrame1.jpg b/libraries/esp8266-oled-ssd1306-4.0.0/resources/DemoFrame1.jpg
similarity index 100%
rename from libraries/oled-ssd1306/resources/DemoFrame1.jpg
rename to libraries/esp8266-oled-ssd1306-4.0.0/resources/DemoFrame1.jpg
diff --git a/libraries/oled-ssd1306/resources/DemoFrame2.jpg b/libraries/esp8266-oled-ssd1306-4.0.0/resources/DemoFrame2.jpg
similarity index 100%
rename from libraries/oled-ssd1306/resources/DemoFrame2.jpg
rename to libraries/esp8266-oled-ssd1306-4.0.0/resources/DemoFrame2.jpg
diff --git a/libraries/oled-ssd1306/resources/DemoFrame3.jpg b/libraries/esp8266-oled-ssd1306-4.0.0/resources/DemoFrame3.jpg
similarity index 100%
rename from libraries/oled-ssd1306/resources/DemoFrame3.jpg
rename to libraries/esp8266-oled-ssd1306-4.0.0/resources/DemoFrame3.jpg
diff --git a/libraries/oled-ssd1306/resources/DemoFrame4.jpg b/libraries/esp8266-oled-ssd1306-4.0.0/resources/DemoFrame4.jpg
similarity index 100%
rename from libraries/oled-ssd1306/resources/DemoFrame4.jpg
rename to libraries/esp8266-oled-ssd1306-4.0.0/resources/DemoFrame4.jpg
diff --git a/libraries/oled-ssd1306/resources/FontTool.png b/libraries/esp8266-oled-ssd1306-4.0.0/resources/FontTool.png
similarity index 100%
rename from libraries/oled-ssd1306/resources/FontTool.png
rename to libraries/esp8266-oled-ssd1306-4.0.0/resources/FontTool.png
diff --git a/libraries/oled-ssd1306/resources/SPI_version.jpg b/libraries/esp8266-oled-ssd1306-4.0.0/resources/SPI_version.jpg
similarity index 100%
rename from libraries/oled-ssd1306/resources/SPI_version.jpg
rename to libraries/esp8266-oled-ssd1306-4.0.0/resources/SPI_version.jpg
diff --git a/libraries/esp8266-oled-ssd1306-4.0.0/resources/glyphEditor.html b/libraries/esp8266-oled-ssd1306-4.0.0/resources/glyphEditor.html
new file mode 100644
index 00000000..f253a807
--- /dev/null
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/resources/glyphEditor.html
@@ -0,0 +1,633 @@
+<!--The MIT License (MIT)
+
+Copyright (c) 2017 by Xavier Grosjean
+
+Based on work 
+Copyright (c) 2016 by Daniel Eichhorn
+Copyright (c) 2016 by Fabrice Weinberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-->
+<!--
+ Standalone page to draw icons in matrix and generates the map definition with the format required by 
+ library for OLED SD1306 screen: https://github.com/squix78/esp8266-oled-ssd1306
+ 100% quick and dirty vanilla ECS6, no framework or library was injured for this project.
+
+-->
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <style>
+      #form, #chars table {
+        user-select: none; 
+        -moz-user-select: none; 
+        margin-top: 5px;
+      }
+      #chars table, tr, td, th {
+        border-collapse: collapse;
+      }
+      #chars td, th {
+        border: 1px solid #CCC;
+        width: 12px;
+        height: 15px;
+      }
+      #chars th[action] {
+        cursor:pointer;
+      }
+      #chars th[action="up"], #chars th[action="down"], #chars th[action="left"], #chars th[action="right"] {
+        font-size: 10px;
+      }
+      #chars td.on {
+        background-color: #00F;
+      }
+      
+      #addChar, #generate {
+        display: none;
+      }
+      body.started #addChar, body.started #generate {
+        display: inline;
+      }
+      body.started #create {
+        display: none;
+      }
+      #page {
+        position:relative;
+      }
+      #page>div {
+        position: relative;
+        float: left;
+      }
+
+      #output {
+        margin-left: 20px;
+        margin-top: 12px;
+        font-size:12px;
+        user-select: all;
+        -moz-user-select: all;
+        max-width:60%;
+      }
+      
+      #header {
+        margin-top: 10px;
+      }
+      #inputText {
+        width: 100%;
+        height:120px;
+      }
+      
+    </style>
+  </head>
+  <body>
+    <div id="form">
+      <table width="100%">
+        <tr>
+          <td>Font array name:</td><td><input placeholder="Font array name" type="text" id="name" value="My_Font"/></td>
+          <td width="75%" rowspan="5">
+            <textarea id="inputText" placeholder="Or paste a char array font definition here">
+const char My_Font[] PROGMEM = {
+  0x0A, // Width: 10
+  0x0D, // Height: 13
+  0x01, // First char: 1
+  0x02, // Number of chars: 2
+  // Jump Table:
+  0x00, 0x00, 0x13, 0x0A, // 1
+  0x00, 0x13, 0x14, 0x0A, // 2
+  // Font Data:
+  0xF0, 0x03, 0x10, 0x02, 0xF0, 0x03, 0x10, 0x02, 0xF0, 0x03, 0x10, 0x02, 0xF0, 0x03, 0x10, 0x02, 0xF0, 0x03, 0xC0, // 1
+  0x00, 0x0C, 0x80, 0x0B, 0x70, 0x08, 0x0C, 0x08, 0xF3, 0x0A, 0xF3, 0x0A, 0x0C, 0x08, 0x70, 0x08, 0x80, 0x0B, 0x00, 0x0C, // 2
+};              
+            </textarea></td>
+        </tr>
+        <tr>
+          <td>First char code:</td><td><input placeholder="First char code" type="number" id="code" value="1" min="1"/></td>
+        </tr>
+        <tr>
+          <td>Width:</td><td><input placeholder="Font width" type="number" id="width" value="10"/></td>
+        </tr>
+        <tr>
+          <td>Height:</td><td><input placeholder="Font height" type="number" id="height" value="13" max="64"/></td>
+        </tr>
+        <tr>
+          <td colspan="3"> </td>     <!--slightly improves layout-->
+        </tr>
+        <tr>
+          <td colspan="2"><button id="create">Create</button> <button id="generate">Generate</button> <button id="savetoFile">Save To File</button> </td>
+          <td><input type="file" id="fileinput" />  <button id="parse">Parse</button></td>
+        </tr>
+      </table>
+      <br/>
+    </div>
+    <div id="page">
+      <div id="charxContainer" ondragstart="return false;">
+        <div id="chars"></div><br/>
+        <button id="addChar">Add a character</button>
+      </div>
+      <div id="output">
+        <div class="output" id="header"> </div>
+        <div class="output" id="jump"> </div>
+        <div class="output" id="data"> </div>
+      </div>
+    </div>
+    <script>
+    (function() {
+      let font;
+      
+      class Font {
+        constructor() {
+          this.height = parseInt(document.getElementById('height').value);
+          this.width = parseInt(document.getElementById('width').value);
+          this.currentCharCode = parseInt(document.getElementById('code').value);
+          this.fontContainer = document.getElementById('chars');
+          this.bytesForHeight = (1 + ((this.height - 1) >> 3));  // number of bytes needed for this font height
+          document.body.className = "started";
+          document.getElementById('height').disabled = true;
+          document.getElementById('width').disabled = true;          
+        }
+        
+        // Should we have a Char and a Pixel class ? not sure it's worth it.
+        // Let's use the DOM to store everything for now
+        
+        static updateCaption(element, code) {
+          element.textContent = `Char #${code}`;
+        }
+        
+        // Add a pixel matrix to draw a new character
+        // jumpaData not used for now: some day, use the last byte for optimisation 
+        addChar(jumpData, charData) {
+          let charContainer = this.fontContainer.appendChild(document.createElement("table"));
+          charContainer.setAttribute("code", this.currentCharCode);
+          let caption = charContainer.appendChild(document.createElement("caption"));
+          Font.updateCaption(caption, this.currentCharCode);
+          let header = charContainer.appendChild(document.createElement("tr"));
+          header.innerHTML = '<th  title="Delete this char" action="delete">&cross;</th>'
+              + '<th title="Add a char above" action="add">+</th>'
+              + '<th title="Shift pixels to the left" action="left">&larr;</th>'
+              + '<th title="Shift pixels down" action="down">&darr;</th>'
+              + '<th title="Shift pixels up" action="up">&uarr;</th>'
+              + '<th title="Shift pixels to the right" action="right">&rarr;</th>'
+              + '<th title="Copy from another character" action="copy">&copy;</th>'
+              + '<th title="Reset all pixels" action="clean">&empty;</th>';
+          // If data is provided, decode it to pixel initialization friendly structure
+          let pixelInit = [];
+          if (charData && charData.length) {
+            // charData byte count needs to be a multiple of bytesForHeight. End bytes with value 0 may have been trimmed
+            let missingBytes = charData.length % this.bytesForHeight;
+            for(let b = 0; b < missingBytes ; b++) {
+              charData.push(0);
+            }
+            while(charData.length) {
+              let row = charData.splice(0, this.bytesForHeight).reverse();
+              let pixelRow = [];
+              for (let b = 0; b < row.length; b++) {
+                let mask = 0x80;
+                let byte = row[b];
+                for (let bit = 0; bit < 8; bit++) {
+                  if (byte & mask) {
+                    pixelRow.push(1);
+                  } else {
+                    pixelRow.push(0);
+                  }
+                  mask = mask >> 1;
+                }
+              }
+              pixelRow.splice(0, pixelRow.length - this.height);
+              //Font.output('data', pixelRow);
+              pixelInit.push(pixelRow.reverse());
+            }
+          }
+          
+          for(let r = 0; r < this.height; r++) {
+          	let rowContainer = charContainer.appendChild(document.createElement("tr"));
+            for(let c = 0; c < this.width; c++) {
+          		let pixContainer = rowContainer.appendChild(document.createElement("td"));
+              pixContainer.setAttribute('action', 'toggle');
+          		// If there is some init data, set the pixel accordingly
+              if (pixelInit.length && pixelInit[c]) {
+                if (pixelInit[c][r]) {
+                  pixContainer.className = 'on';
+                }
+              }          		
+            }
+          }
+          this.currentCharCode++;
+          return charContainer;
+        }
+        
+        static togglePixel(pixel) {
+          pixel.className = pixel.className === 'on' ? '': 'on';
+        }
+        
+        // Return anInt as hex string
+        static toHexString(aByte) {
+          let zero = aByte < 16?'0':'';
+          return `0x${zero}${aByte.toString(16).toUpperCase()}`
+        }
+        
+        // Return least significant byte as hex string
+        static getLsB(anInt) {
+          return Font.toHexString(anInt & 0xFF);      
+        }
+        // Return most significant byte as hex string
+        static getMsB(anInt) {
+          return Font.toHexString(anInt>>>8);      
+        }
+       
+        static output(targetId, msg) {
+          let output = document.getElementById(targetId);
+          let line = output.appendChild(document.createElement('div'));
+          line.textContent = msg;
+        }
+        static emptyChars() {
+          document.getElementById('chars').textContent = '';
+        }
+        static emptyOutput() {
+          document.getElementById('header').textContent = '';
+          document.getElementById('jump').textContent = '';
+          document.getElementById('data').textContent = '';
+        }
+		
+        saveFile() {
+          let filename = document.getElementById('name').value.replace(/[^a-zA-Z0-9_$]/g, '_') + ".h";
+          let data = document.getElementById("output").innerText;
+          if(data.length < 10) return;
+          let blobObject = new Blob([data], {type:'text/plain'}); 
+    
+          if(window.navigator.msSaveBlob) {
+            window.navigator.msSaveBlob(blobObject, filename);
+          } else {
+            let a = document.createElement("a");
+            a.setAttribute("href", URL.createObjectURL(blobObject));
+            a.setAttribute("download", filename);
+            if (document.createEvent) {
+              let event = document.createEvent('MouseEvents');
+              event.initEvent('click', true, true);
+              a.dispatchEvent(event);
+            } else {
+              a.click();
+            }
+          }  
+        }
+			
+        // Read from the <td> css class the pixels that need to be on
+        // generates the jump table and font data 
+        generate() {
+          Font.emptyOutput();
+          let chars = this.fontContainer.getElementsByTagName('table');
+          let firstCharCode = parseInt(document.getElementById('code').value);
+          let name = document.getElementById('name').value.replace(/[^a-zA-Z0-9_$]/g, '_');
+          
+          let bits2add = this.bytesForHeight*8 - this.height;  // number of missing bits to fill leftmost byte
+          let charCount = chars.length;
+          let charAddr = 0;
+          // Comments are used when parsing back a generated font
+          Font.output('jump', '  // Jump Table:');
+          Font.output('data', '  // Font Data:');
+          // Browse each character
+          for(let ch = 0; ch < charCount; ch++) {
+            // Fix renumbering in case first char code was modified  
+            Font.updateCaption(chars[ch].getElementsByTagName('caption')[0], ch + firstCharCode);
+            let charBytes = [];
+            let charCode = ch + firstCharCode;
+            let rows = chars[ch].getElementsByTagName('tr');
+            let notZero = false;
+            // Browse each column
+            for(let col = 0; col < this.width ; col++) {
+              let bits = ""; // using string because js uses 32b ints when performing bit operations
+              // Browse each row starting from the bottom one, going up, and accumulate pixels in
+              // a string: this rotates the glyph
+              // Beware, row 0 is table headers.
+              for(let r = rows.length-1; r >=1 ; r--) {
+                let pixelState = rows[r].children[col].className;
+                bits += (pixelState === 'on' ? '1': '0');           
+              }
+              // Need to complete missing bits to have a sizeof byte multiple number of bits
+              for(let b = 0; b < bits2add; b++) {
+                bits =  '0' + bits;
+              }
+              // Font.output('data', `  // ${bits}`);  // Debugging help: rotated bitmap
+
+              // read bytes from the end
+              for(let b = bits.length - 1; b >= 7; b -= 8) {
+                //Font.output('data', `  // ${bits.substr(b-7, 8)}`);  // Debugging help: rotated bitmap
+                let byte = parseInt(bits.substr(b-7, 8), 2);
+                if (byte !== 0) {
+                  notZero = true;
+                }
+                charBytes.push(Font.toHexString(byte));
+              } 
+            }
+            // Remove bytes with value 0 at the end of the array.
+            while(parseInt(charBytes[charBytes.length-1]) === 0 && charBytes.length !== 1) {
+              charBytes.pop();
+            }
+            
+            if (notZero) {
+              Font.output('data', `  ${charBytes.join(', ')},  // ${charCode}`);
+              // TODO: last param width is not the best value. Need to compute the actual occupied width
+              Font.output('jump', `  ${Font.getMsB(charAddr)}, ${Font.getLsB(charAddr)}, ${Font.toHexString(charBytes.length)}, ${Font.toHexString(this.width)},  // ${charCode} `);
+              charAddr += charBytes.length;
+            } else {
+              Font.output('jump', `  0xFF, 0xFF, 0x00, ${Font.toHexString(this.width)},  // ${charCode} `);
+            }
+          }
+          Font.output('data', '};');
+          
+          Font.output('header', "// Font generated or edited with the glyphEditor");
+          Font.output('header', `const char ${name}[] PROGMEM = {`);
+          // Comments are used when parsing back a generated font
+          Font.output('header', `  ${Font.toHexString(this.width)}, // Width: ${this.width}`);
+          Font.output('header', `  ${Font.toHexString(this.height)}, // Height: ${this.height}`);          
+          Font.output('header', `  ${Font.toHexString(firstCharCode)}, // First char: ${firstCharCode}`);
+          Font.output('header', `  ${Font.toHexString(charCount)}, // Number of chars: ${charCount}`);
+        }
+      }
+	  
+      document.getElementById('fileinput').addEventListener('change', function(e) {
+        let f = e.target.files[0]; 
+        if (f) {
+          let r = new FileReader();
+          r.onload = function(e) { 
+            let contents = e.target.result;
+                alert( "Got the file.\n" 
+                +"name: " + f.name + "\n"
+                +"type: " + f.type + "\n"
+                +"size: " + f.size + " bytes\n"
+                +"starts with: " + contents.substr(0, contents.indexOf("\n")) 
+            );
+              document.getElementById("inputText").value = contents;
+          };
+          r.readAsText(f);
+        } else { 
+          alert("Failed to load file");
+        }
+        });
+      
+      document.getElementById('savetoFile').addEventListener('click', function() {
+        font.saveFile();
+      });
+      
+      document.getElementById('generate').addEventListener('click', function() {
+        font.generate();
+      });
+      document.getElementById('addChar').addEventListener('click', function() {
+        font.addChar();
+      });
+      document.getElementById('inputText').addEventListener('click', function(e) {
+        let target = e.target;
+        target.select();
+      });
+      document.getElementById('chars').addEventListener('mousedown', function(e) {
+        if (e.button !== 0) return;
+        let target = e.target;
+        let action = target.getAttribute('action') || '';
+        if (action === '') return;
+        let result, code, nextContainer, previousContainer, pixels ;
+        let currentContainer = target.parentNode.parentNode;
+        switch(action) {
+          case 'add':
+            code = currentContainer.getAttribute('code');
+            nextContainer = font.addChar();
+            currentContainer.parentNode.insertBefore(nextContainer, currentContainer);
+            do {
+              nextContainer.setAttribute('code', code);
+              Font.updateCaption(nextContainer.getElementsByTagName('caption')[0], code);
+              code ++;
+            } while (nextContainer = nextContainer.nextSibling);
+            break;
+
+          case 'delete':
+            result = confirm("Delete this character ?");
+            if (!result) return;
+            code = currentContainer.getAttribute('code');
+            nextContainer = currentContainer;
+            while (nextContainer = nextContainer.nextSibling) {
+              nextContainer.setAttribute('code', code);
+              Font.updateCaption(nextContainer.getElementsByTagName('caption')[0], code);
+              code ++;
+            }
+            currentContainer.parentNode.removeChild(currentContainer);
+            break;
+
+          // Shift pixels to the left  
+          case 'left':
+            pixels = currentContainer.getElementsByTagName('td');
+            for(p = 0; p < pixels.length; p++) {
+              if((p + 1) % font.width) {
+                pixels[p].className = pixels[p + 1].className;
+              } else {
+                pixels[p].className = '';
+              }
+            }
+            break;
+          
+          // Shift pixels to the right
+          case 'right':
+            pixels = currentContainer.getElementsByTagName('td');
+            for(p = pixels.length-1; p >=0 ; p--) {
+              if(p % font.width) {
+                pixels[p].className = pixels[p - 1].className;
+              } else {
+                pixels[p].className = '';
+              }
+            }
+            break;
+
+          // Shift pixels down
+          case 'down':
+            pixels = currentContainer.getElementsByTagName('td');
+            for(p = pixels.length-1; p >=0 ; p--) {
+              if(p >= font.width) {
+                pixels[p].className = pixels[p - font.width].className;
+              } else {
+                pixels[p].className = '';
+              }
+            }            break;
+
+          // Shift pixels up
+          case 'up':
+            pixels = currentContainer.getElementsByTagName('td');
+            for(p = 0; p < pixels.length; p++) {
+              if(p < font.width*(font.height -1)) {
+                pixels[p].className = pixels[p + font.width].className;
+              } else {
+                pixels[p].className = '';
+              }
+            }            
+            break;
+
+          case 'toggle':
+            Font.togglePixel(target);
+            break;
+
+          case 'clean':
+            result = confirm("Delete the pixels ?");
+            if (!result) return;
+            pixels = currentContainer.getElementsByTagName('td');
+            for (let p = 0; p < pixels.length; p++) {
+              pixels[p].className = '';
+            }
+            break;
+          
+          case 'copy':
+             let charNumber = parseInt(prompt("Source char #: "));
+             let chars = font.fontContainer.getElementsByTagName('table');
+             let tableOffset = charNumber - parseInt(document.getElementById('code').value);
+             let srcPixels = chars[tableOffset].getElementsByTagName('td');
+             let targetPixels = currentContainer.getElementsByTagName('td');
+             for(let i=0; i < srcPixels.length; i++) {
+               // First tds are in the th row, for editing actions. Skip them
+               if (targetPixels[i].parentNode.localName === 'th') continue; // In case we give them css at some point...
+               targetPixels[i].className = srcPixels[i].className;
+             }
+            break;
+          default:
+            // no.
+        }
+        
+      });
+      document.getElementById('chars').addEventListener('mouseover', function(e) {
+        let target = e.target;
+        let action = target.getAttribute('action');
+        if (action !== 'toggle' || e.buttons !== 1) return;
+        Font.togglePixel(target);
+      });
+      document.getElementById('chars').addEventListener('dragstart', function() {
+        return false;
+      });
+
+      document.getElementById('create').addEventListener('click', function() {
+      	font = new Font();
+        font.addChar();
+      });
+
+      // parse a char array declaration for an existing font.
+      // parsing heavily relies on comments.
+      document.getElementById('parse').addEventListener('click', function() {
+        if (document.getElementById('chars').childElementCount) {
+          let result = confirm("Confirm you want to overwrite the existing grids ?");
+          if (!result) return;          
+        } 
+        let lines = document.getElementById('inputText').value.split('\n');
+        let name = '';
+        let height = 0;
+        let width = 0;
+        let firstCharCode = 0;
+        let jumpTable = [];
+        let charData = [];
+        let readingJumpTable = false;
+        let readingData = false;
+        
+        for(let l = 0 ; l < lines.length; l++) {
+          // TODO ? keep C compilation directives to copy them (not lowercased :)) to newly generated char array
+          let line = lines[l].trim();
+          //alert(line);
+          let fields;
+
+          // Declaration line: grab the name
+          if (line.indexOf('PROGMEM') > 0) {
+            fields = line.split(' ');
+            name = fields[2].replace(/[\[\]]/g, '');
+            continue;
+          }
+          line = line.toLowerCase();
+          // Todo: could rely on line order...
+          // width line: grab the width
+          if (line.indexOf('width') > 0) {
+            fields = line.split(',');
+            width = fields[0];
+            continue;
+          }
+          // height line: grab the height 
+          if (line.indexOf('height') > 0) {
+            fields = line.split(',');
+            height = fields[0];
+            continue;
+          }
+          // first char code line: grab the first char code 
+          if (line.indexOf('first char') > 0) {
+            fields = line.split(',');
+            firstCharCode = fields[0];
+            continue;
+          }
+          // End of array declaration
+          // TODO warn if more lines: next fonts are ignored
+          if (line.indexOf('};') === 0) {
+            break;
+          }
+          
+          if (readingJumpTable || readingData) {
+            if (line.indexOf('#') !== 0 && line.length !== 0 && line.indexOf('//') !== 0) {
+              line = line.replace(/\/\/.*/, ''); // get rid of end of line comments
+              fields = line.split(',');
+              let newEntry = [];
+              for(let f=0; f < fields.length; f++) {
+                let value = parseInt(fields[f]);
+                if (isNaN(value)) continue;
+                if (readingData) {
+                  charData.push(value);
+                }
+                if (readingJumpTable) {
+                  newEntry.push(value);
+                }
+              }
+              if (readingJumpTable) {
+                jumpTable.push(newEntry);
+              }
+            }            
+          }
+          
+          // Begining of data
+          if (line.indexOf('font data') > 0) {
+            readingData = true;
+            readingJumpTable = false;
+          }
+          // Begining of jump table
+          if (line.indexOf('jump table') > 0) {
+            readingJumpTable = true;
+          }
+        }
+        if (!name || !height || !width || !firstCharCode) {
+          alert("Does not look like a parsable font. Try again.");
+          return;
+        }
+        
+        Font.emptyChars();
+        Font.emptyOutput();
+        document.getElementById('name').value = name;
+        document.getElementById('height').value = parseInt(height);
+        document.getElementById('width').value = parseInt(width);
+        document.getElementById('code').value = parseInt(firstCharCode);
+      	font = new Font();
+      	for(let c = 0 ; c < jumpTable.length; c++) {
+      	  let jumpEntry = jumpTable[c];
+      	  let charEntry = [];
+      	  // displayable character 
+      	  if (jumpEntry[0] !== 255 || jumpEntry[1] !== 255) {
+      	    charEntry = charData.splice(0, jumpEntry[2]);
+          }
+      	  font.addChar(jumpEntry, charEntry);
+        }
+        document.body.className = "started";
+      });        
+      
+      })();
+    </script>  
+  </body>
+</html>
diff --git a/libraries/esp8266-oled-ssd1306-4.0.0/resources/glyphEditor.png b/libraries/esp8266-oled-ssd1306-4.0.0/resources/glyphEditor.png
new file mode 100644
index 0000000000000000000000000000000000000000..800efc56f4bd50ba347eab57f3205ec8d0c0dd31
GIT binary patch
literal 68751
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
V=l%V&;(J^#ke61GDt>7i_#ZiQOU?iQ

literal 0
HcmV?d00001

diff --git a/libraries/oled-ssd1306/resources/xbmPreview.png b/libraries/esp8266-oled-ssd1306-4.0.0/resources/xbmPreview.png
similarity index 100%
rename from libraries/oled-ssd1306/resources/xbmPreview.png
rename to libraries/esp8266-oled-ssd1306-4.0.0/resources/xbmPreview.png
diff --git a/libraries/oled-ssd1306/OLEDDisplay.cpp b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplay.cpp
similarity index 79%
rename from libraries/oled-ssd1306/OLEDDisplay.cpp
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplay.cpp
index a7ca6472..2c0c72a9 100644
--- a/libraries/oled-ssd1306/OLEDDisplay.cpp
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplay.cpp
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,29 +22,43 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #include "OLEDDisplay.h"
 
+OLEDDisplay::~OLEDDisplay() {
+  end();
+}
+
 bool OLEDDisplay::init() {
   if (!this->connect()) {
     DEBUG_OLEDDISPLAY("[OLEDDISPLAY][init] Can't establish connection to display\n");
     return false;
   }
-  this->buffer = (uint8_t*) malloc(sizeof(uint8_t) * DISPLAY_BUFFER_SIZE);
+
+  if(this->buffer==NULL) {
+  this->buffer = (uint8_t*) malloc(sizeof(uint8_t) * displayBufferSize);
+
   if(!this->buffer) {
     DEBUG_OLEDDISPLAY("[OLEDDISPLAY][init] Not enough memory to create display\n");
     return false;
   }
+  }
 
   #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-  this->buffer_back = (uint8_t*) malloc(sizeof(uint8_t) * DISPLAY_BUFFER_SIZE);
+  if(this->buffer_back==NULL) {
+  this->buffer_back = (uint8_t*) malloc(sizeof(uint8_t) * displayBufferSize);
+
   if(!this->buffer_back) {
     DEBUG_OLEDDISPLAY("[OLEDDISPLAY][init] Not enough memory to create back buffer\n");
     free(this->buffer);
     return false;
   }
+  }
   #endif
 
   sendInitCommands();
@@ -54,16 +68,17 @@ bool OLEDDisplay::init() {
 }
 
 void OLEDDisplay::end() {
-  if (this->buffer) free(this->buffer);
+  if (this->buffer) { free(this->buffer); this->buffer = NULL; }
   #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-  if (this->buffer_back) free(this->buffer_back);
+  if (this->buffer_back) { free(this->buffer_back); this->buffer_back = NULL; }
   #endif
+  if (this->logBuffer != NULL) { free(this->logBuffer); this->logBuffer = NULL; }
 }
 
 void OLEDDisplay::resetDisplay(void) {
   clear();
   #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-  memset(buffer_back, 1, DISPLAY_BUFFER_SIZE);
+  memset(buffer_back, 1, displayBufferSize);
   #endif
   display();
 }
@@ -72,12 +87,16 @@ void OLEDDisplay::setColor(OLEDDISPLAY_COLOR color) {
   this->color = color;
 }
 
+OLEDDISPLAY_COLOR OLEDDisplay::getColor() {
+  return this->color;
+}
+
 void OLEDDisplay::setPixel(int16_t x, int16_t y) {
-  if (x >= 0 && x < 128 && y >= 0 && y < 64) {
+  if (x >= 0 && x < this->width() && y >= 0 && y < this->height()) {
     switch (color) {
-      case WHITE:   buffer[x + (y / 8) * DISPLAY_WIDTH] |=  (1 << (y & 7)); break;
-      case BLACK:   buffer[x + (y / 8) * DISPLAY_WIDTH] &= ~(1 << (y & 7)); break;
-      case INVERSE: buffer[x + (y / 8) * DISPLAY_WIDTH] ^=  (1 << (y & 7)); break;
+      case WHITE:   buffer[x + (y / 8) * this->width()] |=  (1 << (y & 7)); break;
+      case BLACK:   buffer[x + (y / 8) * this->width()] &= ~(1 << (y & 7)); break;
+      case INVERSE: buffer[x + (y / 8) * this->width()] ^=  (1 << (y & 7)); break;
     }
   }
 }
@@ -222,21 +241,21 @@ void OLEDDisplay::fillCircle(int16_t x0, int16_t y0, int16_t radius) {
 }
 
 void OLEDDisplay::drawHorizontalLine(int16_t x, int16_t y, int16_t length) {
-  if (y < 0 || y >= DISPLAY_HEIGHT) { return; }
+  if (y < 0 || y >= this->height()) { return; }
 
   if (x < 0) {
     length += x;
     x = 0;
   }
 
-  if ( (x + length) > DISPLAY_WIDTH) {
-    length = (DISPLAY_WIDTH - x);
+  if ( (x + length) > this->width()) {
+    length = (this->width() - x);
   }
 
   if (length <= 0) { return; }
 
   uint8_t * bufferPtr = buffer;
-  bufferPtr += (y >> 3) * DISPLAY_WIDTH;
+  bufferPtr += (y >> 3) * this->width();
   bufferPtr += x;
 
   uint8_t drawBit = 1 << (y & 7);
@@ -255,15 +274,15 @@ void OLEDDisplay::drawHorizontalLine(int16_t x, int16_t y, int16_t length) {
 }
 
 void OLEDDisplay::drawVerticalLine(int16_t x, int16_t y, int16_t length) {
-  if (x < 0 || x >= DISPLAY_WIDTH) return;
+  if (x < 0 || x >= this->width()) return;
 
   if (y < 0) {
     length += y;
     y = 0;
   }
 
-  if ( (y + length) > DISPLAY_HEIGHT) {
-    length = (DISPLAY_HEIGHT - y);
+  if ( (y + length) > this->height()) {
+    length = (this->height() - y);
   }
 
   if (length <= 0) return;
@@ -273,7 +292,7 @@ void OLEDDisplay::drawVerticalLine(int16_t x, int16_t y, int16_t length) {
   uint8_t drawBit;
   uint8_t *bufferPtr = buffer;
 
-  bufferPtr += (y >> 3) * DISPLAY_WIDTH;
+  bufferPtr += (y >> 3) * this->width();
   bufferPtr += x;
 
   if (yOffset) {
@@ -293,7 +312,7 @@ void OLEDDisplay::drawVerticalLine(int16_t x, int16_t y, int16_t length) {
     if (length < yOffset) return;
 
     length -= yOffset;
-    bufferPtr += DISPLAY_WIDTH;
+    bufferPtr += this->width();
   }
 
   if (length >= 8) {
@@ -303,14 +322,14 @@ void OLEDDisplay::drawVerticalLine(int16_t x, int16_t y, int16_t length) {
         drawBit = (color == WHITE) ? 0xFF : 0x00;
         do {
           *bufferPtr = drawBit;
-          bufferPtr += DISPLAY_WIDTH;
+          bufferPtr += this->width();
           length -= 8;
         } while (length >= 8);
         break;
       case INVERSE:
         do {
           *bufferPtr = ~(*bufferPtr);
-          bufferPtr += DISPLAY_WIDTH;
+          bufferPtr += this->width();
           length -= 8;
         } while (length >= 8);
         break;
@@ -340,20 +359,20 @@ void OLEDDisplay::drawProgressBar(uint16_t x, uint16_t y, uint16_t width, uint16
   drawHorizontalLine(xRadius, y + height, width - doubleRadius + 1);
   drawCircleQuads(x + width - radius, yRadius, radius, 0b00001001);
 
-  uint16_t maxProgressWidth = (width - doubleRadius - 1) * progress / 100;
+  uint16_t maxProgressWidth = (width - doubleRadius + 1) * progress / 100;
 
   fillCircle(xRadius, yRadius, innerRadius);
   fillRect(xRadius + 1, y + 2, maxProgressWidth, height - 3);
   fillCircle(xRadius + maxProgressWidth, yRadius, innerRadius);
 }
 
-void OLEDDisplay::drawFastImage(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const char *image) {
+void OLEDDisplay::drawFastImage(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *image) {
   drawInternal(xMove, yMove, width, height, image, 0, 0);
 }
 
-void OLEDDisplay::drawXbm(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const char *xbm) {
+void OLEDDisplay::drawXbm(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *xbm) {
   int16_t widthInXbm = (width + 7) / 8;
-  uint8_t data;
+  uint8_t data = 0;
 
   for(int16_t y = 0; y < height; y++) {
     for(int16_t x = 0; x < width; x++ ) {
@@ -388,11 +407,13 @@ void OLEDDisplay::drawStringInternal(int16_t xMove, int16_t yMove, char* text, u
     case TEXT_ALIGN_RIGHT:
       xMove -= textWidth;
       break;
+    case TEXT_ALIGN_LEFT:
+      break;
   }
 
   // Don't draw anything if it is not on the screen.
-  if (xMove + textWidth  < 0 || xMove > DISPLAY_WIDTH ) {return;}
-  if (yMove + textHeight < 0 || yMove > DISPLAY_HEIGHT) {return;}
+  if (xMove + textWidth  < 0 || xMove > this->width() ) {return;}
+  if (yMove + textHeight < 0 || yMove > this->width() ) {return;}
 
   for (uint16_t j = 0; j < textLength; j++) {
     int16_t xPos = xMove + cursorX;
@@ -525,7 +546,7 @@ void OLEDDisplay::setTextAlignment(OLEDDISPLAY_TEXT_ALIGNMENT textAlignment) {
   this->textAlignment = textAlignment;
 }
 
-void OLEDDisplay::setFont(const char *fontData) {
+void OLEDDisplay::setFont(const uint8_t *fontData) {
   this->fontData = fontData;
 }
 
@@ -545,9 +566,39 @@ void OLEDDisplay::normalDisplay(void) {
   sendCommand(NORMALDISPLAY);
 }
 
-void OLEDDisplay::setContrast(char contrast) {
+void OLEDDisplay::setContrast(uint8_t contrast, uint8_t precharge, uint8_t comdetect) {
+  sendCommand(SETPRECHARGE); //0xD9
+  sendCommand(precharge); //0xF1 default, to lower the contrast, put 1-1F
   sendCommand(SETCONTRAST);
-  sendCommand(contrast);
+  sendCommand(contrast); // 0-255
+  sendCommand(SETVCOMDETECT); //0xDB, (additionally needed to lower the contrast)
+  sendCommand(comdetect);	//0x40 default, to lower the contrast, put 0
+  sendCommand(DISPLAYALLON_RESUME);
+  sendCommand(NORMALDISPLAY);
+  sendCommand(DISPLAYON);
+}
+
+void OLEDDisplay::setBrightness(uint8_t brightness) {
+  uint8_t contrast = brightness;
+  if (brightness < 128) {
+    // Magic values to get a smooth/ step-free transition
+    contrast = brightness * 1.171;
+  } else {
+    contrast = brightness * 1.171 - 43;
+  }
+
+  uint8_t precharge = 241;
+  if (brightness == 0) {
+    precharge = 0;
+  }
+  uint8_t comdetect = brightness / 8;
+
+  setContrast(contrast, precharge, comdetect);
+}
+
+void OLEDDisplay::resetOrientation() {
+  sendCommand(SEGREMAP);
+  sendCommand(COMSCANINC);           //Reset screen rotation or mirroring
 }
 
 void OLEDDisplay::flipScreenVertically() {
@@ -555,8 +606,13 @@ void OLEDDisplay::flipScreenVertically() {
   sendCommand(COMSCANDEC);           //Rotate screen 180 Deg
 }
 
+void OLEDDisplay::mirrorScreen() {
+  sendCommand(SEGREMAP);
+  sendCommand(COMSCANDEC);           //Mirror screen
+}
+
 void OLEDDisplay::clear(void) {
-  memset(buffer, 0, DISPLAY_BUFFER_SIZE);
+  memset(buffer, 0, displayBufferSize);
 }
 
 void OLEDDisplay::drawLogBuffer(uint16_t xMove, uint16_t yMove) {
@@ -591,11 +647,20 @@ void OLEDDisplay::drawLogBuffer(uint16_t xMove, uint16_t yMove) {
   }
 }
 
+uint16_t OLEDDisplay::getWidth(void) {
+  return displayWidth;
+}
+
+uint16_t OLEDDisplay::getHeight(void) {
+  return displayHeight;
+}
+
 bool OLEDDisplay::setLogBuffer(uint16_t lines, uint16_t chars){
   if (logBuffer != NULL) free(logBuffer);
   uint16_t size = lines * chars;
   if (size > 0) {
     this->logBufferLine     = 0;      // Lines printed
+    this->logBufferFilled   = 0;      // Nothing stored yet
     this->logBufferMaxLines = lines;  // Lines max printable
     this->logBufferSize     = size;   // Total number of characters the buffer can hold
     this->logBuffer         = (char *) malloc(size * sizeof(uint8_t));
@@ -612,12 +677,17 @@ size_t OLEDDisplay::write(uint8_t c) {
     // Don't waste space on \r\n line endings, dropping \r
     if (c == 13) return 1;
 
+    // convert UTF-8 character to font table index
+    c = (this->fontTableLookupFunction)(c);
+    // drop unknown character
+    if (c == 0) return 1;
+
     bool maxLineNotReached = this->logBufferLine < this->logBufferMaxLines;
     bool bufferNotFull = this->logBufferFilled < this->logBufferSize;
 
     // Can we write to the buffer?
     if (bufferNotFull && maxLineNotReached) {
-      this->logBuffer[logBufferFilled] = utf8ascii(c);
+      this->logBuffer[logBufferFilled] = c;
       this->logBufferFilled++;
       // Keep track of lines written
       if (c == 10) this->logBufferLine++;
@@ -665,12 +735,24 @@ size_t OLEDDisplay::write(const char* str) {
 }
 
 // Private functions
+void OLEDDisplay::setGeometry(OLEDDISPLAY_GEOMETRY g) {
+  this->geometry = g;
+  if (g == GEOMETRY_128_64) {
+    this->displayWidth                     = 128;
+    this->displayHeight                    = 64;
+  } else if (g == GEOMETRY_128_32) {
+    this->displayWidth                     = 128;
+    this->displayHeight                    = 32;
+  }
+  this->displayBufferSize                = displayWidth*displayHeight/8;
+}
+
 void OLEDDisplay::sendInitCommands(void) {
   sendCommand(DISPLAYOFF);
   sendCommand(SETDISPLAYCLOCKDIV);
   sendCommand(0xF0); // Increase speed of the display max ~96Hz
   sendCommand(SETMULTIPLEX);
-  sendCommand(0x3F);
+  sendCommand(this->height() - 1);
   sendCommand(SETDISPLAYOFFSET);
   sendCommand(0x00);
   sendCommand(SETSTARTLINE);
@@ -681,21 +763,35 @@ void OLEDDisplay::sendInitCommands(void) {
   sendCommand(SEGREMAP);
   sendCommand(COMSCANINC);
   sendCommand(SETCOMPINS);
-  sendCommand(0x12);
+
+  if (geometry == GEOMETRY_128_64) {
+    sendCommand(0x12);
+  } else if (geometry == GEOMETRY_128_32) {
+    sendCommand(0x02);
+  }
+
   sendCommand(SETCONTRAST);
-  sendCommand(0xCF);
+
+  if (geometry == GEOMETRY_128_64) {
+    sendCommand(0xCF);
+  } else if (geometry == GEOMETRY_128_32) {
+    sendCommand(0x8F);
+  }
+
   sendCommand(SETPRECHARGE);
   sendCommand(0xF1);
+  sendCommand(SETVCOMDETECT); //0xDB, (additionally needed to lower the contrast)
+  sendCommand(0x40);	        //0x40 default, to lower the contrast, put 0
   sendCommand(DISPLAYALLON_RESUME);
   sendCommand(NORMALDISPLAY);
   sendCommand(0x2e);            // stop scroll
   sendCommand(DISPLAYON);
 }
 
-void inline OLEDDisplay::drawInternal(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const char *data, uint16_t offset, uint16_t bytesInData) {
+void inline OLEDDisplay::drawInternal(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *data, uint16_t offset, uint16_t bytesInData) {
   if (width < 0 || height < 0) return;
-  if (yMove + height < 0 || yMove > DISPLAY_HEIGHT)  return;
-  if (xMove + width  < 0 || xMove > DISPLAY_WIDTH)   return;
+  if (yMove + height < 0 || yMove > this->height())  return;
+  if (xMove + width  < 0 || xMove > this->width())   return;
 
   uint8_t  rasterHeight = 1 + ((height - 1) >> 3); // fast ceil(height / 8.0)
   int8_t   yOffset      = yMove & 7;
@@ -717,13 +813,13 @@ void inline OLEDDisplay::drawInternal(int16_t xMove, int16_t yMove, int16_t widt
     byte currentByte = pgm_read_byte(data + offset + i);
 
     int16_t xPos = xMove + (i / rasterHeight);
-    int16_t yPos = ((yMove >> 3) + (i % rasterHeight)) * DISPLAY_WIDTH;
+    int16_t yPos = ((yMove >> 3) + (i % rasterHeight)) * this->width();
 
-    int16_t yScreenPos = yMove + yOffset;
+//    int16_t yScreenPos = yMove + yOffset;
     int16_t dataPos    = xPos  + yPos;
 
-    if (dataPos >=  0  && dataPos < DISPLAY_BUFFER_SIZE &&
-        xPos    >=  0  && xPos    < DISPLAY_WIDTH ) {
+    if (dataPos >=  0  && dataPos < displayBufferSize &&
+        xPos    >=  0  && xPos    < this->width() ) {
 
       if (yOffset >= 0) {
         switch (this->color) {
@@ -731,11 +827,12 @@ void inline OLEDDisplay::drawInternal(int16_t xMove, int16_t yMove, int16_t widt
           case BLACK:   buffer[dataPos] &= ~(currentByte << yOffset); break;
           case INVERSE: buffer[dataPos] ^= currentByte << yOffset; break;
         }
-        if (dataPos < (DISPLAY_BUFFER_SIZE - DISPLAY_WIDTH)) {
+
+        if (dataPos < (displayBufferSize - this->width())) {
           switch (this->color) {
-            case WHITE:   buffer[dataPos + DISPLAY_WIDTH] |= currentByte >> (8 - yOffset); break;
-            case BLACK:   buffer[dataPos + DISPLAY_WIDTH] &= ~(currentByte >> (8 - yOffset)); break;
-            case INVERSE: buffer[dataPos + DISPLAY_WIDTH] ^= currentByte >> (8 - yOffset); break;
+            case WHITE:   buffer[dataPos + this->width()] |= currentByte >> (8 - yOffset); break;
+            case BLACK:   buffer[dataPos + this->width()] &= ~(currentByte >> (8 - yOffset)); break;
+            case INVERSE: buffer[dataPos + this->width()] ^= currentByte >> (8 - yOffset); break;
           }
         }
       } else {
@@ -754,32 +851,12 @@ void inline OLEDDisplay::drawInternal(int16_t xMove, int16_t yMove, int16_t widt
         // and setting the new yOffset
         yOffset = 8 - yOffset;
       }
-      optimistic_yield(10000);
+
+      yield();
     }
   }
 }
 
-// Code form http://playground.arduino.cc/Main/Utf8ascii
-uint8_t OLEDDisplay::utf8ascii(byte ascii) {
-  static uint8_t LASTCHAR;
-
-  if ( ascii < 128 ) { // Standard ASCII-set 0..0x7F handling
-    LASTCHAR = 0;
-    return ascii;
-  }
-
-  uint8_t last = LASTCHAR;   // get last char
-  LASTCHAR = ascii;
-
-  switch (last) {    // conversion depnding on first UTF8-character
-    case 0xC2: return  (ascii);  break;
-    case 0xC3: return  (ascii | 0xC0);  break;
-    case 0x82: if (ascii == 0xAC) return (0x80);    // special case Euro-symbol
-  }
-
-  return  0; // otherwise: return zero, if character has to be ignored
-}
-
 // You need to free the char!
 char* OLEDDisplay::utf8ascii(String str) {
   uint16_t k = 0;
@@ -796,7 +873,7 @@ char* OLEDDisplay::utf8ascii(String str) {
   length--;
 
   for (uint16_t i=0; i < length; i++) {
-    char c = utf8ascii(s[i]);
+    char c = (this->fontTableLookupFunction)(s[i]);
     if (c!=0) {
       s[k++]=c;
     }
@@ -807,3 +884,7 @@ char* OLEDDisplay::utf8ascii(String str) {
   // This will leak 's' be sure to free it in the calling function.
   return s;
 }
+
+void OLEDDisplay::setFontTableLookupFunction(FontTableLookupFunction function) {
+  this->fontTableLookupFunction = function;
+}
diff --git a/libraries/oled-ssd1306/OLEDDisplay.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplay.h
similarity index 70%
rename from libraries/oled-ssd1306/OLEDDisplay.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplay.h
index 81537a24..ddf80bd4 100644
--- a/libraries/oled-ssd1306/OLEDDisplay.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplay.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef OLEDDISPLAY_h
@@ -42,12 +45,6 @@
 #define OLEDDISPLAY_DOUBLE_BUFFER
 #endif
 
-
-// Display settings
-#define DISPLAY_WIDTH 128
-#define DISPLAY_HEIGHT 64
-#define DISPLAY_BUFFER_SIZE 1024
-
 // Header Values
 #define JUMPTABLE_BYTES 4
 
@@ -108,8 +105,22 @@ enum OLEDDISPLAY_TEXT_ALIGNMENT {
 };
 
 
+enum OLEDDISPLAY_GEOMETRY {
+  GEOMETRY_128_64   = 0,
+  GEOMETRY_128_32   = 1
+};
+
+typedef byte (*FontTableLookupFunction)(const byte ch);
+
+
 class OLEDDisplay : public Print {
+
   public:
+    virtual ~OLEDDisplay();
+
+    const uint16_t width(void) const { return displayWidth; };
+    const uint16_t height(void) const { return displayHeight; };
+
     // Initialize the display
     bool init();
 
@@ -123,6 +134,9 @@ class OLEDDisplay : public Print {
     // Sets the color of all pixel operations
     void setColor(OLEDDISPLAY_COLOR color);
 
+    // Returns the current color.
+    OLEDDISPLAY_COLOR getColor();
+
     // Draw a pixel at given position
     void setPixel(int16_t x, int16_t y);
 
@@ -147,18 +161,18 @@ class OLEDDisplay : public Print {
     // Draw a line horizontally
     void drawHorizontalLine(int16_t x, int16_t y, int16_t length);
 
-    // Draw a lin vertically
+    // Draw a line vertically
     void drawVerticalLine(int16_t x, int16_t y, int16_t length);
 
-    // Draws a rounded progress bar with the outer dimensions given by width and height. Progress is 
+    // Draws a rounded progress bar with the outer dimensions given by width and height. Progress is
     // a unsigned byte value between 0 and 100
     void drawProgressBar(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint8_t progress);
 
     // Draw a bitmap in the internal image format
-    void drawFastImage(int16_t x, int16_t y, int16_t width, int16_t height, const char *image);
+    void drawFastImage(int16_t x, int16_t y, int16_t width, int16_t height, const uint8_t *image);
 
     // Draw a XBM
-    void drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, const char *xbm);
+    void drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, const uint8_t *xbm);
 
     /* Text functions */
 
@@ -184,7 +198,10 @@ class OLEDDisplay : public Print {
 
     // Sets the current font. Available default fonts
     // ArialMT_Plain_10, ArialMT_Plain_16, ArialMT_Plain_24
-    void setFont(const char *fontData);
+    void setFont(const uint8_t *fontData);
+
+    // Set the function that will convert utf-8 to font table index
+    void setFontTableLookupFunction(FontTableLookupFunction function);
 
     /* Display functions */
 
@@ -201,11 +218,22 @@ class OLEDDisplay : public Print {
     void normalDisplay(void);
 
     // Set display contrast
-    void setContrast(char contrast);
+    // really low brightness & contrast: contrast = 10, precharge = 5, comdetect = 0
+    // normal brightness & contrast:  contrast = 100
+    void setContrast(uint8_t contrast, uint8_t precharge = 241, uint8_t comdetect = 64);
+
+    // Convenience method to access 
+    void setBrightness(uint8_t);
+
+    // Reset display rotation or mirroring
+    void resetOrientation();
 
     // Turn the display upside down
     void flipScreenVertically();
 
+    // Mirror the display (to be used in a mirror or as a projector)
+    void mirrorScreen();
+
     // Write the buffer to the display memory
     virtual void display(void) = 0;
 
@@ -222,22 +250,35 @@ class OLEDDisplay : public Print {
     // Draw the log buffer at position (x, y)
     void drawLogBuffer(uint16_t x, uint16_t y);
 
-    // Implementent needed function to be compatible with Print class
+    // Get screen geometry
+    uint16_t getWidth(void);
+    uint16_t getHeight(void);
+
+    // Implement needed function to be compatible with Print class
     size_t write(uint8_t c);
     size_t write(const char* s);
 
-    uint8_t            *buffer;
+    uint8_t            *buffer = NULL;
 
     #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-    uint8_t            *buffer_back;
+    uint8_t            *buffer_back = NULL;
     #endif
 
   protected:
 
+    OLEDDISPLAY_GEOMETRY geometry              = GEOMETRY_128_64;
+
+    uint16_t  displayWidth                     = 128;
+    uint16_t  displayHeight                    = 64;
+    uint16_t  displayBufferSize                = 1024;
+
+    // Set the correct height, width and buffer for the geometry
+    void setGeometry(OLEDDISPLAY_GEOMETRY g);
+
     OLEDDISPLAY_TEXT_ALIGNMENT   textAlignment = TEXT_ALIGN_LEFT;
     OLEDDISPLAY_COLOR            color         = WHITE;
 
-    const char          *fontData              = ArialMT_Plain_10;
+    const uint8_t          *fontData     = ArialMT_Plain_10;
 
     // State values for logBuffer
     uint16_t   logBufferSize                   = 0;
@@ -247,22 +288,42 @@ class OLEDDisplay : public Print {
     char      *logBuffer                       = NULL;
 
     // Send a command to the display (low level function)
-    virtual void sendCommand(uint8_t com) {};
+    virtual void sendCommand(uint8_t com) {(void)com;};
 
     // Connect to the display
-    virtual bool connect() {};
+    virtual bool connect() { return false; };
 
     // Send all the init commands
     void sendInitCommands();
 
     // converts utf8 characters to extended ascii
-    static char* utf8ascii(String s);
-    static byte utf8ascii(byte ascii);
+    char* utf8ascii(String s);
 
-    void inline drawInternal(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const char *data, uint16_t offset, uint16_t bytesInData) __attribute__((always_inline));
+    void inline drawInternal(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *data, uint16_t offset, uint16_t bytesInData) __attribute__((always_inline));
 
     void drawStringInternal(int16_t xMove, int16_t yMove, char* text, uint16_t textLength, uint16_t textWidth);
 
+    // UTF-8 to font table index converter
+    // Code form http://playground.arduino.cc/Main/Utf8ascii
+    FontTableLookupFunction fontTableLookupFunction = [](const byte ch) {
+      static uint8_t LASTCHAR;
+
+      if (ch < 128) { // Standard ASCII-set 0..0x7F handling
+        LASTCHAR = 0;
+        return ch;
+      }
+
+      uint8_t last = LASTCHAR;   // get last char
+      LASTCHAR = ch;
+
+      switch (last) {    // conversion depnding on first UTF8-character
+        case 0xC2: return (uint8_t) ch;
+        case 0xC3: return (uint8_t) (ch | 0xC0);
+        case 0x82: if (ch == 0xAC) return (uint8_t) 0x80;    // special case Euro-symbol
+      }
+
+      return (uint8_t) 0; // otherwise: return zero, if character has to be ignored
+    };
 };
 
 #endif
diff --git a/libraries/oled-ssd1306/OLEDDisplayFonts.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayFonts.h
similarity index 99%
rename from libraries/oled-ssd1306/OLEDDisplayFonts.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayFonts.h
index 6dd21ef6..3544edb8 100644
--- a/libraries/oled-ssd1306/OLEDDisplayFonts.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayFonts.h
@@ -1,7 +1,7 @@
 #ifndef OLEDDISPLAYFONTS_h
 #define OLEDDISPLAYFONTS_h
 
-const char ArialMT_Plain_10[] PROGMEM = {
+const uint8_t ArialMT_Plain_10[] PROGMEM = {
   0x0A, // Width: 10
   0x0D, // Height: 13
   0x20, // First Char: 32
@@ -425,7 +425,7 @@ const char ArialMT_Plain_10[] PROGMEM = {
   0x20,0x00,0xC8,0x09,0x00,0x06,0xC8,0x01,0x20  // 255
 };
 
-const char ArialMT_Plain_16[] PROGMEM = {
+const uint8_t ArialMT_Plain_16[] PROGMEM = {
   0x10, // Width: 16
   0x13, // Height: 19
   0x20, // First Char: 32
@@ -848,7 +848,7 @@ const char ArialMT_Plain_16[] PROGMEM = {
   0x00,0x00,0x00,0xF8,0xFF,0x03,0x80,0x20,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x80,0x20,0x00,0x00,0x1F, // 254
   0xC0,0x01,0x00,0x00,0x06,0x02,0x10,0x38,0x02,0x00,0xE0,0x01,0x10,0x38,0x00,0x00,0x07,0x00,0xC0  // 255
 };
-const char ArialMT_Plain_24[] PROGMEM = {
+const uint8_t ArialMT_Plain_24[] PROGMEM = {
   0x18, // Width: 24
   0x1C, // Height: 28
   0x20, // First Char: 32
@@ -1271,4 +1271,4 @@ const char ArialMT_Plain_24[] PROGMEM = {
   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0xFF,0x07,0xE0,0xFF,0xFF,0x07,0x00,0x1C,0x18,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x0E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xF0,0x03, // 254
   0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x7E,0x00,0x06,0xC0,0xF0,0x01,0x06,0xC0,0x80,0x0F,0x07,0x00,0x00,0xFE,0x03,0x00,0x00,0xFC,0x00,0xC0,0xC0,0x1F,0x00,0xC0,0xF8,0x03,0x00,0x00,0x3E,0x00,0x00,0x00,0x06 // 255
 };
-#endif 
+#endif
diff --git a/libraries/oled-ssd1306/OLEDDisplayUi.cpp b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayUi.cpp
similarity index 86%
rename from libraries/oled-ssd1306/OLEDDisplayUi.cpp
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayUi.cpp
index 94232cdf..cd371a01 100644
--- a/libraries/oled-ssd1306/OLEDDisplayUi.cpp
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayUi.cpp
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,6 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #include "OLEDDisplayUi.h"
@@ -61,10 +65,10 @@ void OLEDDisplayUi::setAutoTransitionBackwards(){
   this->lastTransitionDirection = -1;
 }
 void OLEDDisplayUi::setTimePerFrame(uint16_t time){
-  this->ticksPerFrame = (int) ( (float) time / (float) updateInterval);
+  this->ticksPerFrame = (uint16_t) ( (float) time / (float) updateInterval);
 }
 void OLEDDisplayUi::setTimePerTransition(uint16_t time){
-  this->ticksPerTransition = (int) ( (float) time / (float) updateInterval);
+  this->ticksPerTransition = (uint16_t) ( (float) time / (float) updateInterval);
 }
 
 // -/------ Customize indicator position and style -------\-
@@ -90,10 +94,10 @@ void OLEDDisplayUi::setIndicatorPosition(IndicatorPosition pos) {
 void OLEDDisplayUi::setIndicatorDirection(IndicatorDirection dir) {
   this->indicatorDirection = dir;
 }
-void OLEDDisplayUi::setActiveSymbol(const char* symbol) {
+void OLEDDisplayUi::setActiveSymbol(const uint8_t* symbol) {
   this->activeSymbol = symbol;
 }
-void OLEDDisplayUi::setInactiveSymbol(const char* symbol) {
+void OLEDDisplayUi::setInactiveSymbol(const uint8_t* symbol) {
   this->inactiveSymbol = symbol;
 }
 
@@ -132,7 +136,7 @@ void OLEDDisplayUi::runLoadingProcess(LoadingStage* stages, uint8_t stagesCount)
     stages[i].callback();
 
     progress += increment;
-    optimistic_yield(10000);
+    yield();
   }
 
   display->clear();
@@ -190,7 +194,7 @@ OLEDDisplayUiState* OLEDDisplayUi::getUiState(){
 
 
 int8_t OLEDDisplayUi::update(){
-  long frameStart = millis();
+  unsigned long frameStart = millis();
   int8_t timeBudget = this->updateInterval - (frameStart - this->state.lastUpdate);
   if ( timeBudget <= 0) {
     // Implement frame skipping to ensure time budget is keept
@@ -251,31 +255,32 @@ void OLEDDisplayUi::drawFrame(){
   switch (this->state.frameState){
      case IN_TRANSITION: {
        float progress = (float) this->state.ticksSinceLastStateSwitch / (float) this->ticksPerTransition;
-       int16_t x, y, x1, y1;
+       int16_t x = 0, y = 0, x1 = 0, y1 = 0;
        switch(this->frameAnimationDirection){
         case SLIDE_LEFT:
-          x = -128 * progress;
+          x = -this->display->width() * progress;
           y = 0;
-          x1 = x + 128;
+          x1 = x + this->display->width();
           y1 = 0;
           break;
         case SLIDE_RIGHT:
-          x = 128 * progress;
+          x = this->display->width() * progress;
           y = 0;
-          x1 = x - 128;
+          x1 = x - this->display->width();
           y1 = 0;
           break;
         case SLIDE_UP:
           x = 0;
-          y = -64 * progress;
+          y = -this->display->height() * progress;
           x1 = 0;
-          y1 = y + 64;
+          y1 = y + this->display->height();
           break;
         case SLIDE_DOWN:
+        default:
           x = 0;
-          y = 64 * progress;
+          y = this->display->height() * progress;
           x1 = 0;
-          y1 = y - 64;
+          y1 = y - this->display->height();
           break;
        }
 
@@ -331,7 +336,7 @@ void OLEDDisplayUi::drawIndicator() {
       return;
     }
 
-    uint8_t posOfHighlightFrame;
+    uint8_t posOfHighlightFrame = 0;
     float indicatorFadeProgress = 0;
 
     // if the indicator needs to be slided in we want to
@@ -345,6 +350,7 @@ void OLEDDisplayUi::drawIndicator() {
         posOfHighlightFrame = frameToHighlight;
         break;
       case RIGHT_LEFT:
+      default:
         posOfHighlightFrame = this->frameCount - frameToHighlight;
         break;
     }
@@ -360,27 +366,37 @@ void OLEDDisplayUi::drawIndicator() {
         break;
     }
 
-    uint16_t frameStartPos = (12 * frameCount / 2);
-    const char *image;
-    uint16_t x,y;
+    //Space between indicators - reduce for small screen sizes
+    uint16_t indicatorSpacing = 12;
+    if (this->display->getHeight() < 64 && (this->indicatorPosition == RIGHT || this->indicatorPosition == LEFT)) {
+      indicatorSpacing = 6;
+    }
+
+    uint16_t frameStartPos = (indicatorSpacing * frameCount / 2);
+    const uint8_t *image;
+
+    uint16_t x = 0,y = 0;
+
+
     for (byte i = 0; i < this->frameCount; i++) {
 
       switch (this->indicatorPosition){
         case TOP:
           y = 0 - (8 * indicatorFadeProgress);
-          x = 64 - frameStartPos + 12 * i;
+          x = (this->display->width() / 2) - frameStartPos + 12 * i;
           break;
         case BOTTOM:
-          y = 56 + (8 * indicatorFadeProgress);
-          x = 64 - frameStartPos + 12 * i;
+          y = (this->display->height() - 8) + (8 * indicatorFadeProgress);
+          x = (this->display->width() / 2) - frameStartPos + 12 * i;
           break;
         case RIGHT:
-          x = 120 + (8 * indicatorFadeProgress);
-          y = 32 - frameStartPos + 2 + 12 * i;
+          x = (this->display->width() - 8) + (8 * indicatorFadeProgress);
+          y = (this->display->height() / 2) - frameStartPos + 2 + 12 * i;
           break;
         case LEFT:
+        default:
           x = 0 - (8 * indicatorFadeProgress);
-          y = 32 - frameStartPos + 2 + 12 * i;
+          y = (this->display->height() / 2) - frameStartPos + 2 + indicatorSpacing * i;
           break;
       }
 
diff --git a/libraries/oled-ssd1306/OLEDDisplayUi.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayUi.h
similarity index 92%
rename from libraries/oled-ssd1306/OLEDDisplayUi.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayUi.h
index 35a1e99b..2cabf300 100644
--- a/libraries/oled-ssd1306/OLEDDisplayUi.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/OLEDDisplayUi.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,6 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef OLEDDISPLAYUI_h
@@ -61,11 +65,11 @@ enum FrameState {
 };
 
 
-const char ANIMATION_activeSymbol[] PROGMEM = {
+const uint8_t ANIMATION_activeSymbol[] PROGMEM = {
   0x00, 0x18, 0x3c, 0x7e, 0x7e, 0x3c, 0x18, 0x00
 };
 
-const char ANIMATION_inactiveSymbol[] PROGMEM = {
+const uint8_t ANIMATION_inactiveSymbol[] PROGMEM = {
   0x00, 0x0, 0x0, 0x18, 0x18, 0x0, 0x0, 0x00
 };
 
@@ -106,8 +110,8 @@ class OLEDDisplayUi {
     IndicatorPosition   indicatorPosition         = BOTTOM;
     IndicatorDirection  indicatorDirection        = LEFT_RIGHT;
 
-    const char*         activeSymbol              = ANIMATION_activeSymbol;
-    const char*         inactiveSymbol            = ANIMATION_inactiveSymbol;
+    const uint8_t*         activeSymbol              = ANIMATION_activeSymbol;
+    const uint8_t*         inactiveSymbol            = ANIMATION_inactiveSymbol;
 
     bool                shouldDrawIndicators      = true;
 
@@ -240,12 +244,12 @@ class OLEDDisplayUi {
     /**
      * Set the symbol to indicate an active frame in the indicator bar.
      */
-    void setActiveSymbol(const char* symbol);
+    void setActiveSymbol(const uint8_t* symbol);
 
     /**
      * Set the symbol to indicate an inactive frame in the indicator bar.
      */
-    void setInactiveSymbol(const char* symbol);
+    void setInactiveSymbol(const uint8_t* symbol);
 
 
     // Frame settings
diff --git a/libraries/oled-ssd1306/SH1106.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106.h
similarity index 81%
rename from libraries/oled-ssd1306/SH1106.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106.h
index 55dd4090..47188d1f 100644
--- a/libraries/oled-ssd1306/SH1106.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef SH1106_h
diff --git a/libraries/oled-ssd1306/SH1106Brzo.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Brzo.h
similarity index 81%
rename from libraries/oled-ssd1306/SH1106Brzo.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Brzo.h
index 4270066d..8ef3d5b8 100644
--- a/libraries/oled-ssd1306/SH1106Brzo.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Brzo.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef SH1106Brzo_h
@@ -44,7 +47,9 @@ class SH1106Brzo : public OLEDDisplay {
       uint8_t             _scl;
 
   public:
-    SH1106Brzo(uint8_t _address, uint8_t _sda, uint8_t _scl) {
+	SH1106Brzo(uint8_t _address, uint8_t _sda, uint8_t _scl, OLEDDISPLAY_GEOMETRY g = GEOMETRY_128_64) {
+		setGeometry(g);
+
       this->_address = _address;
       this->_sda = _sda;
       this->_scl = _scl;
@@ -57,18 +62,18 @@ class SH1106Brzo : public OLEDDisplay {
 
     void display(void) {
     #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-       uint8_t minBoundY = ~0;
+       uint8_t minBoundY = UINT8_MAX;
        uint8_t maxBoundY = 0;
 
-       uint8_t minBoundX = ~0;
+       uint8_t minBoundX = UINT8_MAX;
        uint8_t maxBoundX = 0;
        uint8_t x, y;
 
        // Calculate the Y bounding box of changes
        // and copy buffer[pos] to buffer_back[pos];
-       for (y = 0; y < (DISPLAY_HEIGHT / 8); y++) {
-         for (x = 0; x < DISPLAY_WIDTH; x++) {
-          uint16_t pos = x + y * DISPLAY_WIDTH;
+       for (y = 0; y < (displayHeight / 8); y++) {
+         for (x = 0; x < displayWidth; x++) {
+          uint16_t pos = x + y * displayWidth;
           if (buffer[pos] != buffer_back[pos]) {
             minBoundY = _min(minBoundY, y);
             maxBoundY = _max(maxBoundY, y);
@@ -77,19 +82,19 @@ class SH1106Brzo : public OLEDDisplay {
           }
           buffer_back[pos] = buffer[pos];
         }
-        optimistic_yield(10000);
+        yield();
        }
 
        // If the minBoundY wasn't updated
        // we can savely assume that buffer_back[pos] == buffer[pos]
        // holdes true for all values of pos
-       if (minBoundY == ~0) return;
+       if (minBoundY == UINT8_MAX) return;
 
        byte k = 0;
        uint8_t sendBuffer[17];
        sendBuffer[0] = 0x40;
 
-       // Calculate the colum offset 
+       // Calculate the colum offset
        uint8_t minBoundXp2H = (minBoundX + 2) & 0x0F;
        uint8_t minBoundXp2L = 0x10 | ((minBoundX + 2) >> 4 );
 
@@ -101,7 +106,7 @@ class SH1106Brzo : public OLEDDisplay {
          sendCommand(minBoundXp2L);
          for (x = minBoundX; x <= maxBoundX; x++) {
              k++;
-             sendBuffer[k] = buffer[x + y * DISPLAY_WIDTH];
+             sendBuffer[k] = buffer[x + y * displayWidth];
              if (k == 16)  {
                brzo_i2c_write(sendBuffer, 17, true);
                k = 0;
@@ -111,7 +116,7 @@ class SH1106Brzo : public OLEDDisplay {
            brzo_i2c_write(sendBuffer, k + 1, true);
            k = 0;
          }
-         optimistic_yield(10000);
+         yield();
        }
        if (k != 0) {
          brzo_i2c_write(sendBuffer, k + 1, true);
diff --git a/libraries/oled-ssd1306/SH1106Spi.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Spi.h
similarity index 77%
rename from libraries/oled-ssd1306/SH1106Spi.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Spi.h
index 48d2cfba..cf8f088e 100644
--- a/libraries/oled-ssd1306/SH1106Spi.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Spi.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef SH1106Spi_h
@@ -37,8 +40,9 @@ class SH1106Spi : public OLEDDisplay {
       uint8_t             _dc;
 
   public:
+    SH1106Spi(uint8_t _rst, uint8_t _dc, uint8_t _cs, OLEDDISPLAY_GEOMETRY g = GEOMETRY_128_64) {
+        setGeometry(g);
 
-    SH1106Spi(uint8_t _rst, uint8_t _dc) {
       this->_rst = _rst;
       this->_dc  = _dc;
     }
@@ -61,19 +65,19 @@ class SH1106Spi : public OLEDDisplay {
 
     void display(void) {
     #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-       uint8_t minBoundY = ~0;
+       uint8_t minBoundY = UINT8_MAX;
        uint8_t maxBoundY = 0;
 
-       uint8_t minBoundX = ~0;
+       uint8_t minBoundX = UINT8_MAX;
        uint8_t maxBoundX = 0;
 
        uint8_t x, y;
 
        // Calculate the Y bounding box of changes
        // and copy buffer[pos] to buffer_back[pos];
-       for (y = 0; y < (DISPLAY_HEIGHT / 8); y++) {
-         for (x = 0; x < DISPLAY_WIDTH; x++) {
-          uint16_t pos = x + y * DISPLAY_WIDTH;
+       for (y = 0; y < (displayHeight / 8); y++) {
+         for (x = 0; x < displayWidth; x++) {
+          uint16_t pos = x + y * displayWidth;
           if (buffer[pos] != buffer_back[pos]) {
             minBoundY = _min(minBoundY, y);
             maxBoundY = _max(maxBoundY, y);
@@ -82,13 +86,13 @@ class SH1106Spi : public OLEDDisplay {
           }
           buffer_back[pos] = buffer[pos];
         }
-        optimistic_yield(10000);
+        yield();
        }
 
        // If the minBoundY wasn't updated
        // we can savely assume that buffer_back[pos] == buffer[pos]
        // holdes true for all values of pos
-       if (minBoundY == ~0) return;
+       if (minBoundY == UINT8_MAX) return;
 
        // Calculate the colum offset
        uint8_t minBoundXp2H = (minBoundX + 2) & 0x0F;
@@ -100,20 +104,20 @@ class SH1106Spi : public OLEDDisplay {
          sendCommand(minBoundXp2L);
          digitalWrite(_dc, HIGH);   // data mode
          for (x = minBoundX; x <= maxBoundX; x++) {
-           SPI.transfer(buffer[x + y * DISPLAY_WIDTH]);
+           SPI.transfer(buffer[x + y * displayWidth]);
          }
-        optimistic_yield(10000);
+         yield();
        }
      #else
-      for (uint8_t y=0; y<DISPLAY_HEIGHT/8; y++) {
+      for (uint8_t y=0; y<displayHeight/8; y++) {
         sendCommand(0xB0 + y);
         sendCommand(0x02);
         sendCommand(0x10);
         digitalWrite(_dc, HIGH);   // data mode
-        for( uint8_t x=0; x < DISPLAY_WIDTH; x++) {
-          SPI.transfer(buffer[x + y * DISPLAY_WIDTH]);
+        for( uint8_t x=0; x < displayWidth; x++) {
+          SPI.transfer(buffer[x + y * displayWidth]);
         }
-        optimistic_yield(10000);
+        yield();
       }
      #endif
     }
diff --git a/libraries/oled-ssd1306/SH1106Wire.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Wire.h
similarity index 84%
rename from libraries/oled-ssd1306/SH1106Wire.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Wire.h
index 7d313602..486ba1ad 100644
--- a/libraries/oled-ssd1306/SH1106Wire.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/SH1106Wire.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef SH1106Wire_h
@@ -44,7 +47,9 @@ class SH1106Wire : public OLEDDisplay {
       uint8_t             _scl;
 
   public:
-    SH1106Wire(uint8_t _address, uint8_t _sda, uint8_t _scl) {
+    SH1106Wire(uint8_t _address, uint8_t _sda, uint8_t _scl, OLEDDISPLAY_GEOMETRY g = GEOMETRY_128_64) {
+      setGeometry(g);
+
       this->_address = _address;
       this->_sda = _sda;
       this->_scl = _scl;
@@ -60,19 +65,19 @@ class SH1106Wire : public OLEDDisplay {
 
     void display(void) {
       #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-        uint8_t minBoundY = ~0;
+        uint8_t minBoundY = UINT8_MAX;
         uint8_t maxBoundY = 0;
 
-        uint8_t minBoundX = ~0;
+        uint8_t minBoundX = UINT8_MAX;
         uint8_t maxBoundX = 0;
 
         uint8_t x, y;
 
         // Calculate the Y bounding box of changes
         // and copy buffer[pos] to buffer_back[pos];
-        for (y = 0; y < (DISPLAY_HEIGHT / 8); y++) {
-          for (x = 0; x < DISPLAY_WIDTH; x++) {
-           uint16_t pos = x + y * DISPLAY_WIDTH;
+        for (y = 0; y < (displayHeight / 8); y++) {
+          for (x = 0; x < displayWidth; x++) {
+           uint16_t pos = x + y * displayWidth;
            if (buffer[pos] != buffer_back[pos]) {
              minBoundY = _min(minBoundY, y);
              maxBoundY = _max(maxBoundY, y);
@@ -81,13 +86,13 @@ class SH1106Wire : public OLEDDisplay {
            }
            buffer_back[pos] = buffer[pos];
          }
-         optimistic_yield(10000);
+         yield();
         }
 
         // If the minBoundY wasn't updated
         // we can savely assume that buffer_back[pos] == buffer[pos]
         // holdes true for all values of pos
-        if (minBoundY == ~0) return;
+        if (minBoundY == UINT8_MAX) return;
 
         // Calculate the colum offset
         uint8_t minBoundXp2H = (minBoundX + 2) & 0x0F;
@@ -103,7 +108,7 @@ class SH1106Wire : public OLEDDisplay {
               Wire.beginTransmission(_address);
               Wire.write(0x40);
             }
-            Wire.write(buffer[x + y * DISPLAY_WIDTH]);
+            Wire.write(buffer[x + y * displayWidth]);
             k++;
             if (k == 16)  {
               Wire.endTransmission();
@@ -114,7 +119,7 @@ class SH1106Wire : public OLEDDisplay {
             Wire.endTransmission();
             k = 0;
           }
-          optimistic_yield(10000);
+          yield();
         }
 
         if (k != 0) {
diff --git a/libraries/oled-ssd1306/SSD1306.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306.h
similarity index 81%
rename from libraries/oled-ssd1306/SSD1306.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306.h
index f3b79094..f6bd554c 100644
--- a/libraries/oled-ssd1306/SSD1306.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef SSD1306_h
diff --git a/libraries/oled-ssd1306/SSD1306Brzo.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Brzo.h
similarity index 79%
rename from libraries/oled-ssd1306/SSD1306Brzo.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Brzo.h
index 1cccd5da..e90b7b36 100644
--- a/libraries/oled-ssd1306/SSD1306Brzo.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Brzo.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef SSD1306Brzo_h
@@ -44,7 +47,9 @@ class SSD1306Brzo : public OLEDDisplay {
       uint8_t             _scl;
 
   public:
-    SSD1306Brzo(uint8_t _address, uint8_t _sda, uint8_t _scl) {
+    SSD1306Brzo(uint8_t _address, uint8_t _sda, uint8_t _scl, OLEDDISPLAY_GEOMETRY g = GEOMETRY_128_64) {
+      setGeometry(g);
+
       this->_address = _address;
       this->_sda = _sda;
       this->_scl = _scl;
@@ -57,19 +62,19 @@ class SSD1306Brzo : public OLEDDisplay {
 
     void display(void) {
     #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-       uint8_t minBoundY = ~0;
+       uint8_t minBoundY = UINT8_MAX;
        uint8_t maxBoundY = 0;
 
-       uint8_t minBoundX = ~0;
+       uint8_t minBoundX = UINT8_MAX;
        uint8_t maxBoundX = 0;
 
        uint8_t x, y;
 
        // Calculate the Y bounding box of changes
        // and copy buffer[pos] to buffer_back[pos];
-       for (y = 0; y < (DISPLAY_HEIGHT / 8); y++) {
-         for (x = 0; x < DISPLAY_WIDTH; x++) {
-          uint16_t pos = x + y * DISPLAY_WIDTH;
+       for (y = 0; y < (displayHeight / 8); y++) {
+         for (x = 0; x < displayWidth; x++) {
+          uint16_t pos = x + y * displayWidth;
           if (buffer[pos] != buffer_back[pos]) {
             minBoundY = _min(minBoundY, y);
             maxBoundY = _max(maxBoundY, y);
@@ -78,13 +83,13 @@ class SSD1306Brzo : public OLEDDisplay {
           }
           buffer_back[pos] = buffer[pos];
         }
-        optimistic_yield(10000);
+        yield();
        }
 
        // If the minBoundY wasn't updated
        // we can savely assume that buffer_back[pos] == buffer[pos]
        // holdes true for all values of pos
-       if (minBoundY == ~0) return;
+       if (minBoundY == UINT8_MAX) return;
 
        sendCommand(COLUMNADDR);
        sendCommand(minBoundX);
@@ -101,13 +106,13 @@ class SSD1306Brzo : public OLEDDisplay {
        for (y = minBoundY; y <= maxBoundY; y++) {
            for (x = minBoundX; x <= maxBoundX; x++) {
                k++;
-               sendBuffer[k] = buffer[x + y * DISPLAY_WIDTH];
+               sendBuffer[k] = buffer[x + y * displayWidth];
                if (k == 16)  {
                  brzo_i2c_write(sendBuffer, 17, true);
                  k = 0;
                }
            }
-           optimistic_yield(10000);
+           yield();
        }
        brzo_i2c_write(sendBuffer, k + 1, true);
        brzo_i2c_end_transaction();
@@ -119,19 +124,24 @@ class SSD1306Brzo : public OLEDDisplay {
 
        sendCommand(PAGEADDR);
        sendCommand(0x0);
-       sendCommand(0x7);
+
+       if (geometry == GEOMETRY_128_64) {
+         sendCommand(0x7);
+       } else if (geometry == GEOMETRY_128_32) {
+         sendCommand(0x3);
+       }
 
        uint8_t sendBuffer[17];
        sendBuffer[0] = 0x40;
        brzo_i2c_start_transaction(this->_address, BRZO_I2C_SPEED);
-       for (uint16_t i=0; i<DISPLAY_BUFFER_SIZE; i++) {
+       for (uint16_t i=0; i<displayBufferSize; i++) {
          for (uint8_t x=1; x<17; x++) {
            sendBuffer[x] = buffer[i];
            i++;
          }
          i--;
          brzo_i2c_write(sendBuffer,  17,  true);
-        optimistic_yield(10000);
+         yield();
        }
        brzo_i2c_end_transaction();
      #endif
diff --git a/libraries/oled-ssd1306/SSD1306Spi.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Spi.h
similarity index 78%
rename from libraries/oled-ssd1306/SSD1306Spi.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Spi.h
index 67beebb5..988dc2c5 100644
--- a/libraries/oled-ssd1306/SSD1306Spi.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Spi.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef SSD1306Spi_h
@@ -44,7 +47,9 @@ class SSD1306Spi : public OLEDDisplay {
       uint8_t             _cs;
 
   public:
-    SSD1306Spi(uint8_t _rst, uint8_t _dc, uint8_t _cs) {
+    SSD1306Spi(uint8_t _rst, uint8_t _dc, uint8_t _cs, OLEDDISPLAY_GEOMETRY g = GEOMETRY_128_64) {
+        setGeometry(g);
+
       this->_rst = _rst;
       this->_dc  = _dc;
       this->_cs  = _cs;
@@ -69,19 +74,19 @@ class SSD1306Spi : public OLEDDisplay {
 
     void display(void) {
     #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-       uint8_t minBoundY = ~0;
+       uint8_t minBoundY = UINT8_MAX;
        uint8_t maxBoundY = 0;
 
-       uint8_t minBoundX = ~0;
+       uint8_t minBoundX = UINT8_MAX;
        uint8_t maxBoundX = 0;
 
        uint8_t x, y;
 
        // Calculate the Y bounding box of changes
        // and copy buffer[pos] to buffer_back[pos];
-       for (y = 0; y < (DISPLAY_HEIGHT / 8); y++) {
-         for (x = 0; x < DISPLAY_WIDTH; x++) {
-          uint16_t pos = x + y * DISPLAY_WIDTH;
+       for (y = 0; y < (displayHeight / 8); y++) {
+         for (x = 0; x < displayWidth; x++) {
+          uint16_t pos = x + y * displayWidth;
           if (buffer[pos] != buffer_back[pos]) {
             minBoundY = _min(minBoundY, y);
             maxBoundY = _max(maxBoundY, y);
@@ -90,13 +95,13 @@ class SSD1306Spi : public OLEDDisplay {
           }
           buffer_back[pos] = buffer[pos];
         }
-        optimistic_yield(10000);
+        yield();
        }
 
        // If the minBoundY wasn't updated
        // we can savely assume that buffer_back[pos] == buffer[pos]
        // holdes true for all values of pos
-       if (minBoundY == ~0) return;
+       if (minBoundY == UINT8_MAX) return;
 
        sendCommand(COLUMNADDR);
        sendCommand(minBoundX);
@@ -111,9 +116,9 @@ class SSD1306Spi : public OLEDDisplay {
        digitalWrite(_cs, LOW);
        for (y = minBoundY; y <= maxBoundY; y++) {
          for (x = minBoundX; x <= maxBoundX; x++) {
-           SPI.transfer(buffer[x + y * DISPLAY_WIDTH]);
+           SPI.transfer(buffer[x + y * displayWidth]);
          }
-         optimistic_yield(10000);
+         yield();
        }
        digitalWrite(_cs, HIGH);
      #else
@@ -124,14 +129,19 @@ class SSD1306Spi : public OLEDDisplay {
 
        sendCommand(PAGEADDR);
        sendCommand(0x0);
-       sendCommand(0x7);
+
+       if (geometry == GEOMETRY_128_64) {
+         sendCommand(0x7);
+       } else if (geometry == GEOMETRY_128_32) {
+         sendCommand(0x3);
+       }
 
         digitalWrite(_cs, HIGH);
         digitalWrite(_dc, HIGH);   // data mode
         digitalWrite(_cs, LOW);
-        for (uint16_t i=0; i<DISPLAY_BUFFER_SIZE; i++) {
+        for (uint16_t i=0; i<displayBufferSize; i++) {
           SPI.transfer(buffer[i]);
-          optimistic_yield(10000);
+          yield();
         }
         digitalWrite(_cs, HIGH);
      #endif
diff --git a/libraries/oled-ssd1306/SSD1306Wire.h b/libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Wire.h
similarity index 69%
rename from libraries/oled-ssd1306/SSD1306Wire.h
rename to libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Wire.h
index 69291351..a3d0a055 100644
--- a/libraries/oled-ssd1306/SSD1306Wire.h
+++ b/libraries/esp8266-oled-ssd1306-4.0.0/src/SSD1306Wire.h
@@ -1,8 +1,8 @@
 /**
  * The MIT License (MIT)
  *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
- * Credits for parts of this code go to Mike Rankin. Thank you so much for sharing!
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
  */
 
 #ifndef SSD1306Wire_h
@@ -36,9 +39,12 @@ class SSD1306Wire : public OLEDDisplay {
       uint8_t             _address;
       uint8_t             _sda;
       uint8_t             _scl;
+      bool                _doI2cAutoInit = false;
 
   public:
-    SSD1306Wire(uint8_t _address, uint8_t _sda, uint8_t _scl) {
+    SSD1306Wire(uint8_t _address, uint8_t _sda, uint8_t _scl, OLEDDISPLAY_GEOMETRY g = GEOMETRY_128_64) {
+      setGeometry(g);
+
       this->_address = _address;
       this->_sda = _sda;
       this->_scl = _scl;
@@ -53,19 +59,21 @@ class SSD1306Wire : public OLEDDisplay {
     }
 
     void display(void) {
+      initI2cIfNeccesary();
+      const int x_offset = (128 - this->width()) / 2;
       #ifdef OLEDDISPLAY_DOUBLE_BUFFER
-        uint8_t minBoundY = ~0;
+        uint8_t minBoundY = UINT8_MAX;
         uint8_t maxBoundY = 0;
 
-        uint8_t minBoundX = ~0;
+        uint8_t minBoundX = UINT8_MAX;
         uint8_t maxBoundX = 0;
         uint8_t x, y;
 
         // Calculate the Y bounding box of changes
         // and copy buffer[pos] to buffer_back[pos];
-        for (y = 0; y < (DISPLAY_HEIGHT / 8); y++) {
-          for (x = 0; x < DISPLAY_WIDTH; x++) {
-           uint16_t pos = x + y * DISPLAY_WIDTH;
+        for (y = 0; y < (this->height() / 8); y++) {
+          for (x = 0; x < this->width(); x++) {
+           uint16_t pos = x + y * this->width();
            if (buffer[pos] != buffer_back[pos]) {
              minBoundY = _min(minBoundY, y);
              maxBoundY = _max(maxBoundY, y);
@@ -74,17 +82,18 @@ class SSD1306Wire : public OLEDDisplay {
            }
            buffer_back[pos] = buffer[pos];
          }
-         optimistic_yield(10000);
+         yield();
         }
 
         // If the minBoundY wasn't updated
         // we can savely assume that buffer_back[pos] == buffer[pos]
         // holdes true for all values of pos
-        if (minBoundY == ~0) return;
+
+        if (minBoundY == UINT8_MAX) return;
 
         sendCommand(COLUMNADDR);
-        sendCommand(minBoundX);
-        sendCommand(maxBoundX);
+        sendCommand(x_offset + minBoundX);
+        sendCommand(x_offset + maxBoundX);
 
         sendCommand(PAGEADDR);
         sendCommand(minBoundY);
@@ -97,14 +106,15 @@ class SSD1306Wire : public OLEDDisplay {
               Wire.beginTransmission(_address);
               Wire.write(0x40);
             }
-            Wire.write(buffer[x + y * DISPLAY_WIDTH]);
+
+            Wire.write(buffer[x + y * this->width()]);
             k++;
             if (k == 16)  {
               Wire.endTransmission();
               k = 0;
             }
           }
-          optimistic_yield(10000);
+          yield();
         }
 
         if (k != 0) {
@@ -113,14 +123,20 @@ class SSD1306Wire : public OLEDDisplay {
       #else
 
         sendCommand(COLUMNADDR);
-        sendCommand(0x0);
-        sendCommand(0x7F);
+        sendCommand(x_offset);
+        sendCommand(x_offset + (this->width() - 1));
 
         sendCommand(PAGEADDR);
         sendCommand(0x0);
-        sendCommand(0x7);
+        sendCommand((this->height() / 8) - 1);
 
-        for (uint16_t i=0; i < DISPLAY_BUFFER_SIZE; i++) {
+        if (geometry == GEOMETRY_128_64) {
+          sendCommand(0x7);
+        } else if (geometry == GEOMETRY_128_32) {
+          sendCommand(0x3);
+        }
+
+        for (uint16_t i=0; i < displayBufferSize; i++) {
           Wire.beginTransmission(this->_address);
           Wire.write(0x40);
           for (uint8_t x = 0; x < 16; x++) {
@@ -133,14 +149,24 @@ class SSD1306Wire : public OLEDDisplay {
       #endif
     }
 
+    void setI2cAutoInit(bool doI2cAutoInit) {
+      _doI2cAutoInit = doI2cAutoInit;
+    }
+
   private:
     inline void sendCommand(uint8_t command) __attribute__((always_inline)){
+      initI2cIfNeccesary();
       Wire.beginTransmission(_address);
       Wire.write(0x80);
       Wire.write(command);
       Wire.endTransmission();
     }
 
+    void initI2cIfNeccesary() {
+      if (_doI2cAutoInit) {
+        Wire.begin(this->_sda, this->_scl);
+      }
+    }
 
 };
 
diff --git a/libraries/oled-ssd1306/examples/SSD1306DrawingDemo/SSD1306DrawingDemo.ino b/libraries/oled-ssd1306/examples/SSD1306DrawingDemo/SSD1306DrawingDemo.ino
deleted file mode 100644
index cf37fb04..00000000
--- a/libraries/oled-ssd1306/examples/SSD1306DrawingDemo/SSD1306DrawingDemo.ino
+++ /dev/null
@@ -1,229 +0,0 @@
-/**
- * The MIT License (MIT)
- *
- * Copyright (c) 2016 by Daniel Eichhorn
- * Copyright (c) 2016 by Fabrice Weinberg
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- */
-
- // Include the correct display library
- // For a connection via I2C using Wire include
- #include <Wire.h>  // Only needed for Arduino 1.6.5 and earlier
- #include "SSD1306.h" // alias for `#include "SSD1306Wire.h"`
- // or #include "SH1106.h" alis for `#include "SH1106Wire.h"`
- // For a connection via I2C using brzo_i2c (must be installed) include
- // #include <brzo_i2c.h> // Only needed for Arduino 1.6.5 and earlier
- // #include "SSD1306Brzo.h"
- // #include "SH1106Brzo.h"
- // For a connection via SPI include
- // #include <SPI.h> // Only needed for Arduino 1.6.5 and earlier
- // #include "SSD1306Spi.h"
- // #include "SH1106SPi.h"
-
- // Use the corresponding display class:
-
- // Initialize the OLED display using SPI
- // D5 -> CLK
- // D7 -> MOSI (DOUT)
- // D0 -> RES
- // D2 -> DC
- // D8 -> CS
- // SSD1306Spi        display(D0, D2, D8);
- // or
- // SH1106Spi         display(D0, D2);
-
- // Initialize the OLED display using brzo_i2c
- // D3 -> SDA
- // D5 -> SCL
- // SSD1306Brzo display(0x3c, D3, D5);
- // or
- // SH1106Brzo  display(0x3c, D3, D5);
-
- // Initialize the OLED display using Wire library
- SSD1306  display(0x3c, D3, D5);
- // SH1106 display(0x3c, D3, D5);
-
-// Adapted from Adafruit_SSD1306
-void drawLines() {
-  for (int16_t i=0; i<DISPLAY_WIDTH; i+=4) {
-    display.drawLine(0, 0, i, DISPLAY_HEIGHT-1);
-    display.display();
-    delay(10);
-  }
-  for (int16_t i=0; i<DISPLAY_HEIGHT; i+=4) {
-    display.drawLine(0, 0, DISPLAY_WIDTH-1, i);
-    display.display();
-    delay(10);
-  }
-  delay(250);
-
-  display.clear();
-  for (int16_t i=0; i<DISPLAY_WIDTH; i+=4) {
-    display.drawLine(0, DISPLAY_HEIGHT-1, i, 0);
-    display.display();
-    delay(10);
-  }
-  for (int16_t i=DISPLAY_HEIGHT-1; i>=0; i-=4) {
-    display.drawLine(0, DISPLAY_HEIGHT-1, DISPLAY_WIDTH-1, i);
-    display.display();
-    delay(10);
-  }
-  delay(250);
-
-  display.clear();
-  for (int16_t i=DISPLAY_WIDTH-1; i>=0; i-=4) {
-    display.drawLine(DISPLAY_WIDTH-1, DISPLAY_HEIGHT-1, i, 0);
-    display.display();
-    delay(10);
-  }
-  for (int16_t i=DISPLAY_HEIGHT-1; i>=0; i-=4) {
-    display.drawLine(DISPLAY_WIDTH-1, DISPLAY_HEIGHT-1, 0, i);
-    display.display();
-    delay(10);
-  }
-  delay(250);
-  display.clear();
-  for (int16_t i=0; i<DISPLAY_HEIGHT; i+=4) {
-    display.drawLine(DISPLAY_WIDTH-1, 0, 0, i);
-    display.display();
-    delay(10);
-  }
-  for (int16_t i=0; i<DISPLAY_WIDTH; i+=4) {
-    display.drawLine(DISPLAY_WIDTH-1, 0, i, DISPLAY_HEIGHT-1);
-    display.display();
-    delay(10);
-  }
-  delay(250);
-}
-
-// Adapted from Adafruit_SSD1306
-void drawRect(void) {
-  for (int16_t i=0; i<DISPLAY_HEIGHT/2; i+=2) {
-    display.drawRect(i, i, DISPLAY_WIDTH-2*i, DISPLAY_HEIGHT-2*i);
-    display.display();
-    delay(10);
-  }
-}
-
-// Adapted from Adafruit_SSD1306
-void fillRect(void) {
-  uint8_t color = 1;
-  for (int16_t i=0; i<DISPLAY_HEIGHT/2; i+=3) {
-    display.setColor((color % 2 == 0) ? BLACK : WHITE); // alternate colors
-    display.fillRect(i, i, DISPLAY_WIDTH - i*2, DISPLAY_HEIGHT - i*2);
-    display.display();
-    delay(10);
-    color++;
-  }
-  // Reset back to WHITE
-  display.setColor(WHITE);
-}
-
-// Adapted from Adafruit_SSD1306
-void drawCircle(void) {
-  for (int16_t i=0; i<DISPLAY_HEIGHT; i+=2) {
-    display.drawCircle(DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2, i);
-    display.display();
-    delay(10);
-  }
-  delay(1000);
-  display.clear();
-
-  // This will draw the part of the circel in quadrant 1
-  // Quadrants are numberd like this:
-  //   0010 | 0001
-  //  ------|-----
-  //   0100 | 1000
-  //
-  display.drawCircleQuads(DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2, DISPLAY_HEIGHT/4, 0b00000001);
-  display.display();
-  delay(200);
-  display.drawCircleQuads(DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2, DISPLAY_HEIGHT/4, 0b00000011);
-  display.display();
-  delay(200);
-  display.drawCircleQuads(DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2, DISPLAY_HEIGHT/4, 0b00000111);
-  display.display();
-  delay(200);
-  display.drawCircleQuads(DISPLAY_WIDTH/2, DISPLAY_HEIGHT/2, DISPLAY_HEIGHT/4, 0b00001111);
-  display.display();
-}
-
-void printBuffer(void) {
-  // Initialize the log buffer
-  // allocate memory to store 8 lines of text and 30 chars per line.
-  display.setLogBuffer(5, 30);
-
-  // Some test data
-  const char* test[] = {
-      "Hello",
-      "World" ,
-      "----",
-      "Show off",
-      "how",
-      "the log buffer",
-      "is",
-      "working.",
-      "Even",
-      "scrolling is",
-      "working"
-  };
-
-  for (uint8_t i = 0; i < 11; i++) {
-    display.clear();
-    // Print to the screen
-    display.println(test[i]);
-    // Draw it to the internal screen buffer
-    display.drawLogBuffer(0, 0);
-    // Display it on the screen
-    display.display();
-    delay(500);
-  }
-}
-
-void setup() {
-  display.init();
-
-  // display.flipScreenVertically();
-
-  display.setContrast(255);
-
-  drawLines();
-  delay(1000);
-  display.clear();
-
-  drawRect();
-  delay(1000);
-  display.clear();
-
-  fillRect();
-  delay(1000);
-  display.clear();
-
-  drawCircle();
-  delay(1000);
-  display.clear();
-
-  printBuffer();
-  delay(1000);
-  display.clear();
-}
-
-void loop() { }