sharp screen working

12 files changed, 2976 insertions, 7 deletions

diff --git a/Makefile b/Makefile
index bf1f58d..81d8522 100755
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,7 @@ CXX = $(CROSS)g++
 OBJCOPY = $(CROSS)objcopy
 NRFUTIL = adafruit-nrfutil
 
-COMFLAGS = -DFLOAT_ABI_HARD \
+COMFLAGS = -DARDUINO=100 -DFLOAT_ABI_HARD \
 	-DNRF52 -DNRF52832_XXAA -DS132 \
 	-Wno-register
 
@@ -40,6 +40,7 @@ CSRC = $(wildcard $(ARDUINO)/cores/nRF5/freertos/Source/*.c) \
 	$(ARDUINO)/libraries/Bluefruit52Lib/src/utility/bootloader_util.c
 
 CXXSRC = $(wildcard source/*.cpp) \
+	$(wildcard source/sharp/*.cpp) \
 	$(ARDUINO)/libraries/Bluefruit52Lib/src/BLEAdvertising.cpp \
 	$(ARDUINO)/libraries/Bluefruit52Lib/src/BLECentral.cpp \
 	$(ARDUINO)/libraries/Bluefruit52Lib/src/BLECharacteristic.cpp \
@@ -91,7 +92,8 @@ INCLUDES = -I$(ARDUINO)/libraries/Bluefruit52Lib/src \
 	-I$(ARDUINO)/cores/nRF5/freertos/Source/include \
 	-I$(ARDUINO)/cores/nRF5/freertos/portable/CMSIS/nrf52 \
 	-I$(ARDUINO)/cores/nRF5/freertos/portable/GCC/nrf52 \
-	-I$(ARDUINO)/variants/feather_nrf52832
+	-I$(ARDUINO)/variants/feather_nrf52832 \
+	-Isource/sharp
 
 all: $(OUTELF) $(OUTHEX) $(OUTDFU)
 
diff --git a/source/controller.cpp b/source/controller.cpp
index f6393e8..853e8fc 100755
--- a/source/controller.cpp
+++ b/source/controller.cpp
@@ -14,6 +14,8 @@
 
 #include <bluefruit.h>
 
+#include "driverSharp.h"
+
 BLEUart bleuart;
 
 // Function prototypes for packetparser.cpp
@@ -31,8 +33,7 @@ void setup(void)
   Serial.begin(115200);
   while ( !Serial ) delay(10);   // for nrf52840 with native usb
 
-  Serial.println(F("Adafruit Bluefruit52 Controller App Example"));
-  Serial.println(F("-------------------------------------------"));
+  Serial.println(F("Initializing..."));
 
   Bluefruit.begin();
   // Set max power. Accepted values are: -40, -30, -20, -16, -12, -8, -4, 0, 4
@@ -45,9 +46,9 @@ void setup(void)
   // Set up and start advertising
   startAdv();
 
-  Serial.println(F("Please use Adafruit Bluefruit LE app to connect in Controller mode"));
-  Serial.println(F("Then activate/use the sensors, color picker, game controller, etc!"));
-  Serial.println();  
+  Serial.println(F("Ready."));
+
+  sharpInit();
 }
 
 void startAdv(void)
@@ -85,6 +86,8 @@ void startAdv(void)
 /**************************************************************************/
 void loop(void)
 {
+  sharpRefresh(300);
+
   // Wait for new data to arrive
   uint8_t len = readPacket(&bleuart, 500);
   if (len == 0) return;
diff --git a/source/driverSharp.cpp b/source/driverSharp.cpp
new file mode 100644
index 0000000..74a2a70
--- /dev/null
+++ b/source/driverSharp.cpp
@@ -0,0 +1,27 @@
+#include "sharp/Adafruit_SharpMem.h"
+
+#define SHARP_SCK  12
+#define SHARP_MOSI 13
+#define SHARP_SS   6
+
+Adafruit_SharpMem display(SHARP_SCK, SHARP_MOSI, SHARP_SS, 144, 168);
+
+#define BLACK 0
+#define WHITE 1
+
+void sharpInit(void)
+{
+	display.begin();
+	display.clearDisplay();
+	display.setTextSize(1);
+	display.setTextColor(BLACK);
+	display.setCursor(0, 0);
+	display.println("Hello!");
+}
+
+void sharpRefresh(unsigned int pause)
+{
+	display.refresh();
+	delay(pause);
+}
+
diff --git a/source/driverSharp.h b/source/driverSharp.h
new file mode 100644
index 0000000..9da6f98
--- /dev/null
+++ b/source/driverSharp.h
@@ -0,0 +1,3 @@
+
+void sharpInit(void);
+void sharpRefresh(unsigned int pause = 500);
diff --git a/source/sharp/Adafruit_GFX.cpp b/source/sharp/Adafruit_GFX.cpp
new file mode 100755
index 0000000..f51ce47
--- /dev/null
+++ b/source/sharp/Adafruit_GFX.cpp
@@ -0,0 +1,1972 @@
+/*
+This is the core graphics library for all our displays, providing a common
+set of graphics primitives (points, lines, circles, etc.).  It needs to be
+paired with a hardware-specific library for each display device we carry
+(to handle the lower-level functions).
+
+Adafruit invests time and resources providing this open source code, please
+support Adafruit & open-source hardware by purchasing products from Adafruit!
+
+Copyright (c) 2013 Adafruit Industries.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "Adafruit_GFX.h"
+#include "glcdfont.c"
+#ifdef __AVR__
+  #include <avr/pgmspace.h>
+#elif defined(ESP8266) || defined(ESP32)
+  #include <pgmspace.h>
+#endif
+
+// Many (but maybe not all) non-AVR board installs define macros
+// for compatibility with existing PROGMEM-reading AVR code.
+// Do our own checks and defines here for good measure...
+
+#ifndef pgm_read_byte
+ #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
+#endif
+#ifndef pgm_read_word
+ #define pgm_read_word(addr) (*(const unsigned short *)(addr))
+#endif
+#ifndef pgm_read_dword
+ #define pgm_read_dword(addr) (*(const unsigned long *)(addr))
+#endif
+
+// Pointers are a peculiar case...typically 16-bit on AVR boards,
+// 32 bits elsewhere.  Try to accommodate both...
+
+#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
+ #define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
+#else
+ #define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
+#endif
+
+#ifndef min
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#ifndef _swap_int16_t
+#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
+#endif
+
+/**************************************************************************/
+/*!
+   @brief    Instatiate a GFX context for graphics! Can only be done by a superclass
+   @param    w   Display width, in pixels
+   @param    h   Display height, in pixels
+*/
+/**************************************************************************/
+Adafruit_GFX::Adafruit_GFX(int16_t w, int16_t h):
+WIDTH(w), HEIGHT(h)
+{
+    _width    = WIDTH;
+    _height   = HEIGHT;
+    rotation  = 0;
+    cursor_y  = cursor_x    = 0;
+    textsize  = 1;
+    textcolor = textbgcolor = 0xFFFF;
+    wrap      = true;
+    _cp437    = false;
+    gfxFont   = NULL;
+}
+
+/**************************************************************************/
+/*!
+   @brief    Write a line.  Bresenham's algorithm - thx wikpedia
+    @param    x0  Start point x coordinate
+    @param    y0  Start point y coordinate
+    @param    x1  End point x coordinate
+    @param    y1  End point y coordinate
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
+        uint16_t color) {
+    int16_t steep = abs(y1 - y0) > abs(x1 - x0);
+    if (steep) {
+        _swap_int16_t(x0, y0);
+        _swap_int16_t(x1, y1);
+    }
+
+    if (x0 > x1) {
+        _swap_int16_t(x0, x1);
+        _swap_int16_t(y0, y1);
+    }
+
+    int16_t dx, dy;
+    dx = x1 - x0;
+    dy = abs(y1 - y0);
+
+    int16_t err = dx / 2;
+    int16_t ystep;
+
+    if (y0 < y1) {
+        ystep = 1;
+    } else {
+        ystep = -1;
+    }
+
+    for (; x0<=x1; x0++) {
+        if (steep) {
+            writePixel(y0, x0, color);
+        } else {
+            writePixel(x0, y0, color);
+        }
+        err -= dy;
+        if (err < 0) {
+            y0 += ystep;
+            err += dx;
+        }
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Start a display-writing routine, overwrite in subclasses.
+*/
+/**************************************************************************/
+void Adafruit_GFX::startWrite(){
+}
+
+/**************************************************************************/
+/*!
+   @brief    Write a pixel, overwrite in subclasses if startWrite is defined!
+    @param   x   x coordinate
+    @param   y   y coordinate
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::writePixel(int16_t x, int16_t y, uint16_t color){
+    drawPixel(x, y, color);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Write a perfectly vertical line, overwrite in subclasses if startWrite is defined!
+    @param    x   Top-most x coordinate
+    @param    y   Top-most y coordinate
+    @param    h   Height in pixels
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::writeFastVLine(int16_t x, int16_t y,
+        int16_t h, uint16_t color) {
+    // Overwrite in subclasses if startWrite is defined!
+    // Can be just writeLine(x, y, x, y+h-1, color);
+    // or writeFillRect(x, y, 1, h, color);
+    drawFastVLine(x, y, h, color);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Write a perfectly horizontal line, overwrite in subclasses if startWrite is defined!
+    @param    x   Left-most x coordinate
+    @param    y   Left-most y coordinate
+    @param    w   Width in pixels
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::writeFastHLine(int16_t x, int16_t y,
+        int16_t w, uint16_t color) {
+    // Overwrite in subclasses if startWrite is defined!
+    // Example: writeLine(x, y, x+w-1, y, color);
+    // or writeFillRect(x, y, w, 1, color);
+    drawFastHLine(x, y, w, color);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Write a rectangle completely with one color, overwrite in subclasses if startWrite is defined!
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    w   Width in pixels
+    @param    h   Height in pixels
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h,
+        uint16_t color) {
+    // Overwrite in subclasses if desired!
+    fillRect(x,y,w,h,color);
+}
+
+/**************************************************************************/
+/*!
+   @brief    End a display-writing routine, overwrite in subclasses if startWrite is defined!
+*/
+/**************************************************************************/
+void Adafruit_GFX::endWrite(){
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw a perfectly vertical line (this is often optimized in a subclass!)
+    @param    x   Top-most x coordinate
+    @param    y   Top-most y coordinate
+    @param    h   Height in pixels
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y,
+        int16_t h, uint16_t color) {
+    startWrite();
+    writeLine(x, y, x, y+h-1, color);
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw a perfectly horizontal line (this is often optimized in a subclass!)
+    @param    x   Left-most x coordinate
+    @param    y   Left-most y coordinate
+    @param    w   Width in pixels
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y,
+        int16_t w, uint16_t color) {
+    startWrite();
+    writeLine(x, y, x+w-1, y, color);
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief    Fill a rectangle completely with one color. Update in subclasses if desired!
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    w   Width in pixels
+    @param    h   Height in pixels
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
+        uint16_t color) {
+    startWrite();
+    for (int16_t i=x; i<x+w; i++) {
+        writeFastVLine(i, y, h, color);
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief    Fill the screen completely with one color. Update in subclasses if desired!
+    @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::fillScreen(uint16_t color) {
+    fillRect(0, 0, _width, _height, color);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw a line
+    @param    x0  Start point x coordinate
+    @param    y0  Start point y coordinate
+    @param    x1  End point x coordinate
+    @param    y1  End point y coordinate
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
+        uint16_t color) {
+    // Update in subclasses if desired!
+    if(x0 == x1){
+        if(y0 > y1) _swap_int16_t(y0, y1);
+        drawFastVLine(x0, y0, y1 - y0 + 1, color);
+    } else if(y0 == y1){
+        if(x0 > x1) _swap_int16_t(x0, x1);
+        drawFastHLine(x0, y0, x1 - x0 + 1, color);
+    } else {
+        startWrite();
+        writeLine(x0, y0, x1, y1, color);
+        endWrite();
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw a circle outline
+    @param    x0   Center-point x coordinate
+    @param    y0   Center-point y coordinate
+    @param    r   Radius of circle
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r,
+        uint16_t color) {
+    int16_t f = 1 - r;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * r;
+    int16_t x = 0;
+    int16_t y = r;
+
+    startWrite();
+    writePixel(x0  , y0+r, color);
+    writePixel(x0  , y0-r, color);
+    writePixel(x0+r, y0  , color);
+    writePixel(x0-r, y0  , color);
+
+    while (x<y) {
+        if (f >= 0) {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f += ddF_x;
+
+        writePixel(x0 + x, y0 + y, color);
+        writePixel(x0 - x, y0 + y, color);
+        writePixel(x0 + x, y0 - y, color);
+        writePixel(x0 - x, y0 - y, color);
+        writePixel(x0 + y, y0 + x, color);
+        writePixel(x0 - y, y0 + x, color);
+        writePixel(x0 + y, y0 - x, color);
+        writePixel(x0 - y, y0 - x, color);
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+    @brief    Quarter-circle drawer, used to do circles and roundrects
+    @param    x0   Center-point x coordinate
+    @param    y0   Center-point y coordinate
+    @param    r   Radius of circle
+    @param    cornername  Mask bit #1 or bit #2 to indicate which quarters of the circle we're doing
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawCircleHelper( int16_t x0, int16_t y0,
+        int16_t r, uint8_t cornername, uint16_t color) {
+    int16_t f     = 1 - r;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * r;
+    int16_t x     = 0;
+    int16_t y     = r;
+
+    while (x<y) {
+        if (f >= 0) {
+            y--;
+            ddF_y += 2;
+            f     += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f     += ddF_x;
+        if (cornername & 0x4) {
+            writePixel(x0 + x, y0 + y, color);
+            writePixel(x0 + y, y0 + x, color);
+        }
+        if (cornername & 0x2) {
+            writePixel(x0 + x, y0 - y, color);
+            writePixel(x0 + y, y0 - x, color);
+        }
+        if (cornername & 0x8) {
+            writePixel(x0 - y, y0 + x, color);
+            writePixel(x0 - x, y0 + y, color);
+        }
+        if (cornername & 0x1) {
+            writePixel(x0 - y, y0 - x, color);
+            writePixel(x0 - x, y0 - y, color);
+        }
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw a circle with filled color
+    @param    x0   Center-point x coordinate
+    @param    y0   Center-point y coordinate
+    @param    r   Radius of circle
+    @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r,
+        uint16_t color) {
+    startWrite();
+    writeFastVLine(x0, y0-r, 2*r+1, color);
+    fillCircleHelper(x0, y0, r, 3, 0, color);
+    endWrite();
+}
+
+
+/**************************************************************************/
+/*!
+    @brief  Quarter-circle drawer with fill, used for circles and roundrects
+    @param  x0       Center-point x coordinate
+    @param  y0       Center-point y coordinate
+    @param  r        Radius of circle
+    @param  corners  Mask bits indicating which quarters we're doing
+    @param  delta    Offset from center-point, used for round-rects
+    @param  color    16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
+  uint8_t corners, int16_t delta, uint16_t color) {
+
+    int16_t f     = 1 - r;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * r;
+    int16_t x     = 0;
+    int16_t y     = r;
+    int16_t px    = x;
+    int16_t py    = y;
+
+    delta++; // Avoid some +1's in the loop
+
+    while(x < y) {
+        if (f >= 0) {
+            y--;
+            ddF_y += 2;
+            f     += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f     += ddF_x;
+        // These checks avoid double-drawing certain lines, important
+        // for the SSD1306 library which has an INVERT drawing mode.
+        if(x < (y + 1)) {
+            if(corners & 1) writeFastVLine(x0+x, y0-y, 2*y+delta, color);
+            if(corners & 2) writeFastVLine(x0-x, y0-y, 2*y+delta, color);
+        }
+        if(y != py) {
+            if(corners & 1) writeFastVLine(x0+py, y0-px, 2*px+delta, color);
+            if(corners & 2) writeFastVLine(x0-py, y0-px, 2*px+delta, color);
+            py = y;
+        }
+        px = x;
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief   Draw a rectangle with no fill color
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    w   Width in pixels
+    @param    h   Height in pixels
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
+        uint16_t color) {
+    startWrite();
+    writeFastHLine(x, y, w, color);
+    writeFastHLine(x, y+h-1, w, color);
+    writeFastVLine(x, y, h, color);
+    writeFastVLine(x+w-1, y, h, color);
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief   Draw a rounded rectangle with no fill color
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    w   Width in pixels
+    @param    h   Height in pixels
+    @param    r   Radius of corner rounding
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w,
+  int16_t h, int16_t r, uint16_t color) {
+    int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis
+    if(r > max_radius) r = max_radius;
+    // smarter version
+    startWrite();
+    writeFastHLine(x+r  , y    , w-2*r, color); // Top
+    writeFastHLine(x+r  , y+h-1, w-2*r, color); // Bottom
+    writeFastVLine(x    , y+r  , h-2*r, color); // Left
+    writeFastVLine(x+w-1, y+r  , h-2*r, color); // Right
+    // draw four corners
+    drawCircleHelper(x+r    , y+r    , r, 1, color);
+    drawCircleHelper(x+w-r-1, y+r    , r, 2, color);
+    drawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
+    drawCircleHelper(x+r    , y+h-r-1, r, 8, color);
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief   Draw a rounded rectangle with fill color
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    w   Width in pixels
+    @param    h   Height in pixels
+    @param    r   Radius of corner rounding
+    @param    color 16-bit 5-6-5 Color to draw/fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w,
+  int16_t h, int16_t r, uint16_t color) {
+    int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis
+    if(r > max_radius) r = max_radius;
+    // smarter version
+    startWrite();
+    writeFillRect(x+r, y, w-2*r, h, color);
+    // draw four corners
+    fillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
+    fillCircleHelper(x+r    , y+r, r, 2, h-2*r-1, color);
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief   Draw a triangle with no fill color
+    @param    x0  Vertex #0 x coordinate
+    @param    y0  Vertex #0 y coordinate
+    @param    x1  Vertex #1 x coordinate
+    @param    y1  Vertex #1 y coordinate
+    @param    x2  Vertex #2 x coordinate
+    @param    y2  Vertex #2 y coordinate
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawTriangle(int16_t x0, int16_t y0,
+        int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
+    drawLine(x0, y0, x1, y1, color);
+    drawLine(x1, y1, x2, y2, color);
+    drawLine(x2, y2, x0, y0, color);
+}
+
+/**************************************************************************/
+/*!
+   @brief     Draw a triangle with color-fill
+    @param    x0  Vertex #0 x coordinate
+    @param    y0  Vertex #0 y coordinate
+    @param    x1  Vertex #1 x coordinate
+    @param    y1  Vertex #1 y coordinate
+    @param    x2  Vertex #2 x coordinate
+    @param    y2  Vertex #2 y coordinate
+    @param    color 16-bit 5-6-5 Color to fill/draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::fillTriangle(int16_t x0, int16_t y0,
+        int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
+
+    int16_t a, b, y, last;
+
+    // Sort coordinates by Y order (y2 >= y1 >= y0)
+    if (y0 > y1) {
+        _swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
+    }
+    if (y1 > y2) {
+        _swap_int16_t(y2, y1); _swap_int16_t(x2, x1);
+    }
+    if (y0 > y1) {
+        _swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
+    }
+
+    startWrite();
+    if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing
+        a = b = x0;
+        if(x1 < a)      a = x1;
+        else if(x1 > b) b = x1;
+        if(x2 < a)      a = x2;
+        else if(x2 > b) b = x2;
+        writeFastHLine(a, y0, b-a+1, color);
+        endWrite();
+        return;
+    }
+
+    int16_t
+    dx01 = x1 - x0,
+    dy01 = y1 - y0,
+    dx02 = x2 - x0,
+    dy02 = y2 - y0,
+    dx12 = x2 - x1,
+    dy12 = y2 - y1;
+    int32_t
+    sa   = 0,
+    sb   = 0;
+
+    // For upper part of triangle, find scanline crossings for segments
+    // 0-1 and 0-2.  If y1=y2 (flat-bottomed triangle), the scanline y1
+    // is included here (and second loop will be skipped, avoiding a /0
+    // error there), otherwise scanline y1 is skipped here and handled
+    // in the second loop...which also avoids a /0 error here if y0=y1
+    // (flat-topped triangle).
+    if(y1 == y2) last = y1;   // Include y1 scanline
+    else         last = y1-1; // Skip it
+
+    for(y=y0; y<=last; y++) {
+        a   = x0 + sa / dy01;
+        b   = x0 + sb / dy02;
+        sa += dx01;
+        sb += dx02;
+        /* longhand:
+        a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
+        b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
+        */
+        if(a > b) _swap_int16_t(a,b);
+        writeFastHLine(a, y, b-a+1, color);
+    }
+
+    // For lower part of triangle, find scanline crossings for segments
+    // 0-2 and 1-2.  This loop is skipped if y1=y2.
+    sa = dx12 * (y - y1);
+    sb = dx02 * (y - y0);
+    for(; y<=y2; y++) {
+        a   = x1 + sa / dy12;
+        b   = x0 + sb / dy02;
+        sa += dx12;
+        sb += dx02;
+        /* longhand:
+        a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
+        b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
+        */
+        if(a > b) _swap_int16_t(a,b);
+        writeFastHLine(a, y, b-a+1, color);
+    }
+    endWrite();
+}
+
+// BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS ---------------------
+
+/**************************************************************************/
+/*!
+   @brief      Draw a PROGMEM-resident 1-bit image at the specified (x,y) position, using the specified foreground color (unset bits are transparent).
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with monochrome bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Hieght of bitmap in pixels
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
+  const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color) {
+
+    int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
+    uint8_t byte = 0;
+
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++) {
+            if(i & 7) byte <<= 1;
+            else      byte   = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
+            if(byte & 0x80) writePixel(x+i, y, color);
+        }
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief      Draw a PROGMEM-resident 1-bit image at the specified (x,y) position, using the specified foreground (for set bits) and background (unset bits) colors.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with monochrome bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Hieght of bitmap in pixels
+    @param    color 16-bit 5-6-5 Color to draw pixels with
+    @param    bg 16-bit 5-6-5 Color to draw background with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
+  const uint8_t bitmap[], int16_t w, int16_t h,
+  uint16_t color, uint16_t bg) {
+
+    int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
+    uint8_t byte = 0;
+
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            if(i & 7) byte <<= 1;
+            else      byte   = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
+            writePixel(x+i, y, (byte & 0x80) ? color : bg);
+        }
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief      Draw a RAM-resident 1-bit image at the specified (x,y) position, using the specified foreground color (unset bits are transparent).
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with monochrome bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Hieght of bitmap in pixels
+    @param    color 16-bit 5-6-5 Color to draw with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
+  uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
+
+    int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
+    uint8_t byte = 0;
+
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            if(i & 7) byte <<= 1;
+            else      byte   = bitmap[j * byteWidth + i / 8];
+            if(byte & 0x80) writePixel(x+i, y, color);
+        }
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief      Draw a RAM-resident 1-bit image at the specified (x,y) position, using the specified foreground (for set bits) and background (unset bits) colors.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with monochrome bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Hieght of bitmap in pixels
+    @param    color 16-bit 5-6-5 Color to draw pixels with
+    @param    bg 16-bit 5-6-5 Color to draw background with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
+  uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
+
+    int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
+    uint8_t byte = 0;
+
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            if(i & 7) byte <<= 1;
+            else      byte   = bitmap[j * byteWidth + i / 8];
+            writePixel(x+i, y, (byte & 0x80) ? color : bg);
+        }
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief      Draw PROGMEM-resident XBitMap Files (*.xbm), exported from GIMP. 
+   Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
+   C Array can be directly used with this function.
+   There is no RAM-resident version of this function; if generating bitmaps
+   in RAM, use the format defined by drawBitmap() and call that instead.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with monochrome bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Hieght of bitmap in pixels
+    @param    color 16-bit 5-6-5 Color to draw pixels with
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawXBitmap(int16_t x, int16_t y,
+  const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color) {
+
+    int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
+    uint8_t byte = 0;
+
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            if(i & 7) byte >>= 1;
+            else      byte   = pgm_read_byte(&bitmap[j * byteWidth + i / 8]);
+            // Nearly identical to drawBitmap(), only the bit order
+            // is reversed here (left-to-right = LSB to MSB):
+            if(byte & 0x01) writePixel(x+i, y, color);
+        }
+    }
+    endWrite();
+}
+
+
+/**************************************************************************/
+/*!
+   @brief   Draw a PROGMEM-resident 8-bit image (grayscale) at the specified (x,y) pos.  
+   Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with grayscale bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Hieght of bitmap in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
+  const uint8_t bitmap[], int16_t w, int16_t h) {
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            writePixel(x+i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i]));
+        }
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief   Draw a RAM-resident 8-bit image (grayscale) at the specified (x,y) pos.  
+   Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with grayscale bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Hieght of bitmap in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
+  uint8_t *bitmap, int16_t w, int16_t h) {
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            writePixel(x+i, y, bitmap[j * w + i]);
+        }
+    }
+    endWrite();
+}
+
+
+/**************************************************************************/
+/*!
+   @brief   Draw a PROGMEM-resident 8-bit image (grayscale) with a 1-bit mask
+   (set bits = opaque, unset bits = clear) at the specified (x,y) position.
+   BOTH buffers (grayscale and mask) must be PROGMEM-resident.
+   Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with grayscale bitmap
+    @param    mask  byte array with mask bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Height of bitmap in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
+  const uint8_t bitmap[], const uint8_t mask[],
+  int16_t w, int16_t h) {
+    int16_t bw   = (w + 7) / 8; // Bitmask scanline pad = whole byte
+    uint8_t byte = 0;
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            if(i & 7) byte <<= 1;
+            else      byte   = pgm_read_byte(&mask[j * bw + i / 8]);
+            if(byte & 0x80) {
+                writePixel(x+i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i]));
+            }
+        }
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief   Draw a RAM-resident 8-bit image (grayscale) with a 1-bit mask
+   (set bits = opaque, unset bits = clear) at the specified (x,y) position.
+   BOTH buffers (grayscale and mask) must be RAM-residentt, no mix-and-match
+   Specifically for 8-bit display devices such as IS31FL3731; no color reduction/expansion is performed.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with grayscale bitmap
+    @param    mask  byte array with mask bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Height of bitmap in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y,
+  uint8_t *bitmap, uint8_t *mask, int16_t w, int16_t h) {
+    int16_t bw   = (w + 7) / 8; // Bitmask scanline pad = whole byte
+    uint8_t byte = 0;
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            if(i & 7) byte <<= 1;
+            else      byte   = mask[j * bw + i / 8];
+            if(byte & 0x80) {
+                writePixel(x+i, y, bitmap[j * w + i]);
+            }
+        }
+    }
+    endWrite();
+}
+
+
+/**************************************************************************/
+/*!
+   @brief   Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) at the specified (x,y) position.  
+   For 16-bit display devices; no color reduction performed.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with 16-bit color bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Height of bitmap in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y,
+  const uint16_t bitmap[], int16_t w, int16_t h) {
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            writePixel(x+i, y, pgm_read_word(&bitmap[j * w + i]));
+        }
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief   Draw a RAM-resident 16-bit image (RGB 5/6/5) at the specified (x,y) position.  
+   For 16-bit display devices; no color reduction performed.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with 16-bit color bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Height of bitmap in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y,
+  uint16_t *bitmap, int16_t w, int16_t h) {
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            writePixel(x+i, y, bitmap[j * w + i]);
+        }
+    }
+    endWrite();
+}
+
+
+/**************************************************************************/
+/*!
+   @brief   Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH buffers (color and mask) must be PROGMEM-resident. For 16-bit display devices; no color reduction performed.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with 16-bit color bitmap
+    @param    mask  byte array with monochrome mask bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Height of bitmap in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y,
+  const uint16_t bitmap[], const uint8_t mask[],
+  int16_t w, int16_t h) {
+    int16_t bw   = (w + 7) / 8; // Bitmask scanline pad = whole byte
+    uint8_t byte = 0;
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            if(i & 7) byte <<= 1;
+            else      byte   = pgm_read_byte(&mask[j * bw + i / 8]);
+            if(byte & 0x80) {
+                writePixel(x+i, y, pgm_read_word(&bitmap[j * w + i]));
+            }
+        }
+    }
+    endWrite();
+}
+
+/**************************************************************************/
+/*!
+   @brief   Draw a RAM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask (set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH buffers (color and mask) must be RAM-resident. For 16-bit display devices; no color reduction performed.
+    @param    x   Top left corner x coordinate
+    @param    y   Top left corner y coordinate
+    @param    bitmap  byte array with 16-bit color bitmap
+    @param    mask  byte array with monochrome mask bitmap
+    @param    w   Width of bitmap in pixels
+    @param    h   Height of bitmap in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y,
+  uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h) {
+    int16_t bw   = (w + 7) / 8; // Bitmask scanline pad = whole byte
+    uint8_t byte = 0;
+    startWrite();
+    for(int16_t j=0; j<h; j++, y++) {
+        for(int16_t i=0; i<w; i++ ) {
+            if(i & 7) byte <<= 1;
+            else      byte   = mask[j * bw + i / 8];
+            if(byte & 0x80) {
+                writePixel(x+i, y, bitmap[j * w + i]);
+            }
+        }
+    }
+    endWrite();
+}
+
+// TEXT- AND CHARACTER-HANDLING FUNCTIONS ----------------------------------
+
+// Draw a character
+/**************************************************************************/
+/*!
+   @brief   Draw a single character
+    @param    x   Bottom left corner x coordinate
+    @param    y   Bottom left corner y coordinate
+    @param    c   The 8-bit font-indexed character (likely ascii)
+    @param    color 16-bit 5-6-5 Color to draw chraracter with
+    @param    bg 16-bit 5-6-5 Color to fill background with (if same as color, no background)
+    @param    size  Font magnification level, 1 is 'original' size
+*/
+/**************************************************************************/
+void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
+  uint16_t color, uint16_t bg, uint8_t size) {
+
+    if(!gfxFont) { // 'Classic' built-in font
+
+        if((x >= _width)            || // Clip right
+           (y >= _height)           || // Clip bottom
+           ((x + 6 * size - 1) < 0) || // Clip left
+           ((y + 8 * size - 1) < 0))   // Clip top
+            return;
+
+        if(!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior
+
+        startWrite();
+        for(int8_t i=0; i<5; i++ ) { // Char bitmap = 5 columns
+            uint8_t line = pgm_read_byte(&font[c * 5 + i]);
+            for(int8_t j=0; j<8; j++, line >>= 1) {
+                if(line & 1) {
+                    if(size == 1)
+                        writePixel(x+i, y+j, color);
+                    else
+                        writeFillRect(x+i*size, y+j*size, size, size, color);
+                } else if(bg != color) {
+                    if(size == 1)
+                        writePixel(x+i, y+j, bg);
+                    else
+                        writeFillRect(x+i*size, y+j*size, size, size, bg);
+                }
+            }
+        }
+        if(bg != color) { // If opaque, draw vertical line for last column
+            if(size == 1) writeFastVLine(x+5, y, 8, bg);
+            else          writeFillRect(x+5*size, y, size, 8*size, bg);
+        }
+        endWrite();
+
+    } else { // Custom font
+
+        // Character is assumed previously filtered by write() to eliminate
+        // newlines, returns, non-printable characters, etc.  Calling
+        // drawChar() directly with 'bad' characters of font may cause mayhem!
+
+        c -= (uint8_t)pgm_read_byte(&gfxFont->first);
+        GFXglyph *glyph  = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
+        uint8_t  *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
+
+        uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
+        uint8_t  w  = pgm_read_byte(&glyph->width),
+                 h  = pgm_read_byte(&glyph->height);
+        int8_t   xo = pgm_read_byte(&glyph->xOffset),
+                 yo = pgm_read_byte(&glyph->yOffset);
+        uint8_t  xx, yy, bits = 0, bit = 0;
+        int16_t  xo16 = 0, yo16 = 0;
+
+        if(size > 1) {
+            xo16 = xo;
+            yo16 = yo;
+        }
+
+        // Todo: Add character clipping here
+
+        // NOTE: THERE IS NO 'BACKGROUND' COLOR OPTION ON CUSTOM FONTS.
+        // THIS IS ON PURPOSE AND BY DESIGN.  The background color feature
+        // has typically been used with the 'classic' font to overwrite old
+        // screen contents with new data.  This ONLY works because the
+        // characters are a uniform size; it's not a sensible thing to do with
+        // proportionally-spaced fonts with glyphs of varying sizes (and that
+        // may overlap).  To replace previously-drawn text when using a custom
+        // font, use the getTextBounds() function to determine the smallest
+        // rectangle encompassing a string, erase the area with fillRect(),
+        // then draw new text.  This WILL infortunately 'blink' the text, but
+        // is unavoidable.  Drawing 'background' pixels will NOT fix this,
+        // only creates a new set of problems.  Have an idea to work around
+        // this (a canvas object type for MCUs that can afford the RAM and
+        // displays supporting setAddrWindow() and pushColors()), but haven't
+        // implemented this yet.
+
+        startWrite();
+        for(yy=0; yy<h; yy++) {
+            for(xx=0; xx<w; xx++) {
+                if(!(bit++ & 7)) {
+                    bits = pgm_read_byte(&bitmap[bo++]);
+                }
+                if(bits & 0x80) {
+                    if(size == 1) {
+                        writePixel(x+xo+xx, y+yo+yy, color);
+                    } else {
+                        writeFillRect(x+(xo16+xx)*size, y+(yo16+yy)*size,
+                          size, size, color);
+                    }
+                }
+                bits <<= 1;
+            }
+        }
+        endWrite();
+
+    } // End classic vs custom font
+}
+/**************************************************************************/
+/*!
+    @brief  Print one byte/character of data, used to support print()
+    @param  c  The 8-bit ascii character to write
+*/
+/**************************************************************************/
+size_t Adafruit_GFX::write(uint8_t c) {
+    if(!gfxFont) { // 'Classic' built-in font
+
+        if(c == '\n') {                        // Newline?
+            cursor_x  = 0;                     // Reset x to zero,
+            cursor_y += textsize * 8;          // advance y one line
+        } else if(c != '\r') {                 // Ignore carriage returns
+            if(wrap && ((cursor_x + textsize * 6) > _width)) { // Off right?
+                cursor_x  = 0;                 // Reset x to zero,
+                cursor_y += textsize * 8;      // advance y one line
+            }
+            drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
+            cursor_x += textsize * 6;          // Advance x one char
+        }
+
+    } else { // Custom font
+
+        if(c == '\n') {
+            cursor_x  = 0;
+            cursor_y += (int16_t)textsize *
+                        (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
+        } else if(c != '\r') {
+            uint8_t first = pgm_read_byte(&gfxFont->first);
+            if((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) {
+                GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(
+                  &gfxFont->glyph))[c - first]);
+                uint8_t   w     = pgm_read_byte(&glyph->width),
+                          h     = pgm_read_byte(&glyph->height);
+                if((w > 0) && (h > 0)) { // Is there an associated bitmap?
+                    int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
+                    if(wrap && ((cursor_x + textsize * (xo + w)) > _width)) {
+                        cursor_x  = 0;
+                        cursor_y += (int16_t)textsize *
+                          (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
+                    }
+                    drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
+                }
+                cursor_x += (uint8_t)pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize;
+            }
+        }
+
+    }
+    return 1;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set text cursor location
+    @param  x    X coordinate in pixels
+    @param  y    Y coordinate in pixels
+*/
+/**************************************************************************/
+void Adafruit_GFX::setCursor(int16_t x, int16_t y) {
+    cursor_x = x;
+    cursor_y = y;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Get text cursor X location
+    @returns    X coordinate in pixels
+*/
+/**************************************************************************/
+int16_t Adafruit_GFX::getCursorX(void) const {
+    return cursor_x;
+}
+
+/**************************************************************************/
+/*!
+    @brief      Get text cursor Y location
+    @returns    Y coordinate in pixels
+*/
+/**************************************************************************/
+int16_t Adafruit_GFX::getCursorY(void) const {
+    return cursor_y;
+}
+
+/**************************************************************************/
+/*!
+    @brief   Set text 'magnification' size. Each increase in s makes 1 pixel that much bigger.
+    @param  s  Desired text size. 1 is default 6x8, 2 is 12x16, 3 is 18x24, etc
+*/
+/**************************************************************************/
+void Adafruit_GFX::setTextSize(uint8_t s) {
+    textsize = (s > 0) ? s : 1;
+}
+
+/**************************************************************************/
+/*!
+    @brief   Set text font color with transparant background
+    @param   c   16-bit 5-6-5 Color to draw text with
+*/
+/**************************************************************************/
+void Adafruit_GFX::setTextColor(uint16_t c) {
+    // For 'transparent' background, we'll set the bg
+    // to the same as fg instead of using a flag
+    textcolor = textbgcolor = c;
+}
+
+/**************************************************************************/
+/*!
+    @brief   Set text font color with custom background color
+    @param   c   16-bit 5-6-5 Color to draw text with
+    @param   b   16-bit 5-6-5 Color to draw background/fill with
+*/
+/**************************************************************************/
+void Adafruit_GFX::setTextColor(uint16_t c, uint16_t b) {
+    textcolor   = c;
+    textbgcolor = b;
+}
+
+/**************************************************************************/
+/*!
+    @brief      Whether text that is too long should 'wrap' around to the next line.
+    @param  w Set true for wrapping, false for clipping
+*/
+/**************************************************************************/
+void Adafruit_GFX::setTextWrap(boolean w) {
+    wrap = w;
+}
+
+/**************************************************************************/
+/*!
+    @brief      Get rotation setting for display
+    @returns    0 thru 3 corresponding to 4 cardinal rotations
+*/
+/**************************************************************************/
+uint8_t Adafruit_GFX::getRotation(void) const {
+    return rotation;
+}
+
+/**************************************************************************/
+/*!
+    @brief      Set rotation setting for display
+    @param  x   0 thru 3 corresponding to 4 cardinal rotations
+*/
+/**************************************************************************/
+void Adafruit_GFX::setRotation(uint8_t x) {
+    rotation = (x & 3);
+    switch(rotation) {
+        case 0:
+        case 2:
+            _width  = WIDTH;
+            _height = HEIGHT;
+            break;
+        case 1:
+        case 3:
+            _width  = HEIGHT;
+            _height = WIDTH;
+            break;
+    }
+}
+
+/**************************************************************************/
+/*!
+    @brief Enable (or disable) Code Page 437-compatible charset.
+    There was an error in glcdfont.c for the longest time -- one character
+    (#176, the 'light shade' block) was missing -- this threw off the index
+    of every character that followed it.  But a TON of code has been written
+    with the erroneous character indices.  By default, the library uses the
+    original 'wrong' behavior and old sketches will still work.  Pass 'true'
+    to this function to use correct CP437 character values in your code.
+    @param  x  Whether to enable (True) or not (False)
+*/
+/**************************************************************************/
+void Adafruit_GFX::cp437(boolean x) {
+    _cp437 = x;
+}
+
+/**************************************************************************/
+/*!
+    @brief Set the font to display when print()ing, either custom or default
+    @param  f  The GFXfont object, if NULL use built in 6x8 font
+*/
+/**************************************************************************/
+void Adafruit_GFX::setFont(const GFXfont *f) {
+    if(f) {            // Font struct pointer passed in?
+        if(!gfxFont) { // And no current font struct?
+            // Switching from classic to new font behavior.
+            // Move cursor pos down 6 pixels so it's on baseline.
+            cursor_y += 6;
+        }
+    } else if(gfxFont) { // NULL passed.  Current font struct defined?
+        // Switching from new to classic font behavior.
+        // Move cursor pos up 6 pixels so it's at top-left of char.
+        cursor_y -= 6;
+    }
+    gfxFont = (GFXfont *)f;
+}
+
+
+/**************************************************************************/
+/*!
+    @brief    Helper to determine size of a character with current font/size.
+       Broke this out as it's used by both the PROGMEM- and RAM-resident getTextBounds() functions.
+    @param    c     The ascii character in question
+    @param    x     Pointer to x location of character
+    @param    y     Pointer to y location of character
+    @param    minx  Minimum clipping value for X
+    @param    miny  Minimum clipping value for Y
+    @param    maxx  Maximum clipping value for X
+    @param    maxy  Maximum clipping value for Y
+*/
+/**************************************************************************/
+void Adafruit_GFX::charBounds(char c, int16_t *x, int16_t *y,
+  int16_t *minx, int16_t *miny, int16_t *maxx, int16_t *maxy) {
+
+    if(gfxFont) {
+
+        if(c == '\n') { // Newline?
+            *x  = 0;    // Reset x to zero, advance y by one line
+            *y += textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
+        } else if(c != '\r') { // Not a carriage return; is normal char
+            uint8_t first = pgm_read_byte(&gfxFont->first),
+                    last  = pgm_read_byte(&gfxFont->last);
+            if((c >= first) && (c <= last)) { // Char present in this font?
+                GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(
+                  &gfxFont->glyph))[c - first]);
+                uint8_t gw = pgm_read_byte(&glyph->width),
+                        gh = pgm_read_byte(&glyph->height),
+                        xa = pgm_read_byte(&glyph->xAdvance);
+                int8_t  xo = pgm_read_byte(&glyph->xOffset),
+                        yo = pgm_read_byte(&glyph->yOffset);
+                if(wrap && ((*x+(((int16_t)xo+gw)*textsize)) > _width)) {
+                    *x  = 0; // Reset x to zero, advance y by one line
+                    *y += textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
+                }
+                int16_t ts = (int16_t)textsize,
+                        x1 = *x + xo * ts,
+                        y1 = *y + yo * ts,
+                        x2 = x1 + gw * ts - 1,
+                        y2 = y1 + gh * ts - 1;
+                if(x1 < *minx) *minx = x1;
+                if(y1 < *miny) *miny = y1;
+                if(x2 > *maxx) *maxx = x2;
+                if(y2 > *maxy) *maxy = y2;
+                *x += xa * ts;
+            }
+        }
+
+    } else { // Default font
+
+        if(c == '\n') {                     // Newline?
+            *x  = 0;                        // Reset x to zero,
+            *y += textsize * 8;             // advance y one line
+            // min/max x/y unchaged -- that waits for next 'normal' character
+        } else if(c != '\r') {  // Normal char; ignore carriage returns
+            if(wrap && ((*x + textsize * 6) > _width)) { // Off right?
+                *x  = 0;                    // Reset x to zero,
+                *y += textsize * 8;         // advance y one line
+            }
+            int x2 = *x + textsize * 6 - 1, // Lower-right pixel of char
+                y2 = *y + textsize * 8 - 1;
+            if(x2 > *maxx) *maxx = x2;      // Track max x, y
+            if(y2 > *maxy) *maxy = y2;
+            if(*x < *minx) *minx = *x;      // Track min x, y
+            if(*y < *miny) *miny = *y;
+            *x += textsize * 6;             // Advance x one char
+        }
+    }
+}
+
+/**************************************************************************/
+/*!
+    @brief    Helper to determine size of a string with current font/size. Pass string and a cursor position, returns UL corner and W,H.
+    @param    str     The ascii string to measure
+    @param    x       The current cursor X
+    @param    y       The current cursor Y
+    @param    x1      The boundary X coordinate, set by function
+    @param    y1      The boundary Y coordinate, set by function
+    @param    w      The boundary width, set by function
+    @param    h      The boundary height, set by function
+*/
+/**************************************************************************/
+void Adafruit_GFX::getTextBounds(const char *str, int16_t x, int16_t y,
+        int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
+    uint8_t c; // Current character
+
+    *x1 = x;
+    *y1 = y;
+    *w  = *h = 0;
+
+    int16_t minx = _width, miny = _height, maxx = -1, maxy = -1;
+
+    while((c = *str++))
+        charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy);
+
+    if(maxx >= minx) {
+        *x1 = minx;
+        *w  = maxx - minx + 1;
+    }
+    if(maxy >= miny) {
+        *y1 = miny;
+        *h  = maxy - miny + 1;
+    }
+}
+
+/**************************************************************************/
+/*!
+    @brief    Helper to determine size of a string with current font/size. Pass string and a cursor position, returns UL corner and W,H.
+    @param    str    The ascii string to measure (as an arduino String() class)
+    @param    x      The current cursor X
+    @param    y      The current cursor Y
+    @param    x1     The boundary X coordinate, set by function
+    @param    y1     The boundary Y coordinate, set by function
+    @param    w      The boundary width, set by function
+    @param    h      The boundary height, set by function
+*/
+/**************************************************************************/
+void Adafruit_GFX::getTextBounds(const String &str, int16_t x, int16_t y,
+        int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
+    if (str.length() != 0) {
+        getTextBounds(const_cast<char*>(str.c_str()), x, y, x1, y1, w, h);
+    }
+}
+
+
+/**************************************************************************/
+/*!
+    @brief    Helper to determine size of a PROGMEM string with current font/size. Pass string and a cursor position, returns UL corner and W,H.
+    @param    str     The flash-memory ascii string to measure
+    @param    x       The current cursor X
+    @param    y       The current cursor Y
+    @param    x1      The boundary X coordinate, set by function
+    @param    y1      The boundary Y coordinate, set by function
+    @param    w      The boundary width, set by function
+    @param    h      The boundary height, set by function
+*/
+/**************************************************************************/
+void Adafruit_GFX::getTextBounds(const __FlashStringHelper *str,
+        int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
+    uint8_t *s = (uint8_t *)str, c;
+
+    *x1 = x;
+    *y1 = y;
+    *w  = *h = 0;
+
+    int16_t minx = _width, miny = _height, maxx = -1, maxy = -1;
+
+    while((c = pgm_read_byte(s++)))
+        charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy);
+
+    if(maxx >= minx) {
+        *x1 = minx;
+        *w  = maxx - minx + 1;
+    }
+    if(maxy >= miny) {
+        *y1 = miny;
+        *h  = maxy - miny + 1;
+    }
+}
+
+/**************************************************************************/
+/*!
+    @brief      Get width of the display, accounting for the current rotation
+    @returns    Width in pixels
+*/
+/**************************************************************************/
+int16_t Adafruit_GFX::width(void) const {
+    return _width;
+}
+
+/**************************************************************************/
+/*!
+    @brief      Get height of the display, accounting for the current rotation
+    @returns    Height in pixels
+*/
+/**************************************************************************/
+int16_t Adafruit_GFX::height(void) const {
+    return _height;
+}
+
+/**************************************************************************/
+/*!
+    @brief      Invert the display (ideally using built-in hardware command)
+    @param   i  True if you want to invert, false to make 'normal'
+*/
+/**************************************************************************/
+void Adafruit_GFX::invertDisplay(boolean i) {
+    // Do nothing, must be subclassed if supported by hardware
+}
+
+/***************************************************************************/
+
+/**************************************************************************/
+/*!
+   @brief    Create a simple drawn button UI element
+*/
+/**************************************************************************/
+Adafruit_GFX_Button::Adafruit_GFX_Button(void) {
+  _gfx = 0;
+}
+
+/**************************************************************************/
+/*!
+   @brief    Initialize button with our desired color/size/settings
+   @param    gfx     Pointer to our display so we can draw to it!
+   @param    x       The X coordinate of the center of the button
+   @param    y       The Y coordinate of the center of the button
+   @param    w       Width of the buttton
+   @param    h       Height of the buttton
+   @param    outline  Color of the outline (16-bit 5-6-5 standard)
+   @param    fill  Color of the button fill (16-bit 5-6-5 standard)
+   @param    textcolor  Color of the button label (16-bit 5-6-5 standard)
+   @param    label  Ascii string of the text inside the button
+   @param    textsize The font magnification of the label text
+*/
+/**************************************************************************/
+// Classic initButton() function: pass center & size
+void Adafruit_GFX_Button::initButton(
+ Adafruit_GFX *gfx, int16_t x, int16_t y, uint16_t w, uint16_t h,
+ uint16_t outline, uint16_t fill, uint16_t textcolor,
+ char *label, uint8_t textsize)
+{
+  // Tweak arguments and pass to the newer initButtonUL() function...
+  initButtonUL(gfx, x - (w / 2), y - (h / 2), w, h, outline, fill,
+    textcolor, label, textsize);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Initialize button with our desired color/size/settings, with upper-left coordinates
+   @param    gfx     Pointer to our display so we can draw to it!
+   @param    x1       The X coordinate of the Upper-Left corner of the button
+   @param    y1       The Y coordinate of the Upper-Left corner of the button
+   @param    w       Width of the buttton
+   @param    h       Height of the buttton
+   @param    outline  Color of the outline (16-bit 5-6-5 standard)
+   @param    fill  Color of the button fill (16-bit 5-6-5 standard)
+   @param    textcolor  Color of the button label (16-bit 5-6-5 standard)
+   @param    label  Ascii string of the text inside the button
+   @param    textsize The font magnification of the label text
+*/
+/**************************************************************************/
+void Adafruit_GFX_Button::initButtonUL(
+ Adafruit_GFX *gfx, int16_t x1, int16_t y1, uint16_t w, uint16_t h,
+ uint16_t outline, uint16_t fill, uint16_t textcolor,
+ char *label, uint8_t textsize)
+{
+  _x1           = x1;
+  _y1           = y1;
+  _w            = w;
+  _h            = h;
+  _outlinecolor = outline;
+  _fillcolor    = fill;
+  _textcolor    = textcolor;
+  _textsize     = textsize;
+  _gfx          = gfx;
+  strncpy(_label, label, 9);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw the button on the screen
+   @param    inverted Whether to draw with fill/text swapped to indicate 'pressed'
+*/
+/**************************************************************************/
+void Adafruit_GFX_Button::drawButton(boolean inverted) {
+  uint16_t fill, outline, text;
+
+  if(!inverted) {
+    fill    = _fillcolor;
+    outline = _outlinecolor;
+    text    = _textcolor;
+  } else {
+    fill    = _textcolor;
+    outline = _outlinecolor;
+    text    = _fillcolor;
+  }
+
+  uint8_t r = min(_w, _h) / 4; // Corner radius
+  _gfx->fillRoundRect(_x1, _y1, _w, _h, r, fill);
+  _gfx->drawRoundRect(_x1, _y1, _w, _h, r, outline);
+
+  _gfx->setCursor(_x1 + (_w/2) - (strlen(_label) * 3 * _textsize),
+    _y1 + (_h/2) - (4 * _textsize));
+  _gfx->setTextColor(text);
+  _gfx->setTextSize(_textsize);
+  _gfx->print(_label);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Helper to let us know if a coordinate is within the bounds of the button
+    @param    x       The X coordinate to check
+    @param    y       The Y coordinate to check
+   @returns   True if within button graphics outline
+*/
+/**************************************************************************/
+boolean Adafruit_GFX_Button::contains(int16_t x, int16_t y) {
+  return ((x >= _x1) && (x < (int16_t) (_x1 + _w)) &&
+          (y >= _y1) && (y < (int16_t) (_y1 + _h)));
+}
+
+/**************************************************************************/
+/*!
+   @brief    Sets the state of the button, should be done by some touch function
+   @param    p  True for pressed, false for not.
+*/
+/**************************************************************************/
+void Adafruit_GFX_Button::press(boolean p) {
+  laststate = currstate;
+  currstate = p;
+}
+
+/**************************************************************************/
+/*!
+   @brief    Query whether the button is currently pressed
+   @returns  True if pressed
+*/
+/**************************************************************************/
+boolean Adafruit_GFX_Button::isPressed() { return currstate; }
+
+/**************************************************************************/
+/*!
+   @brief    Query whether the button was pressed since we last checked state
+   @returns  True if was not-pressed before, now is.
+*/
+/**************************************************************************/
+boolean Adafruit_GFX_Button::justPressed() { return (currstate && !laststate); }
+
+/**************************************************************************/
+/*!
+   @brief    Query whether the button was released since we last checked state
+   @returns  True if was pressed before, now is not.
+*/
+/**************************************************************************/
+boolean Adafruit_GFX_Button::justReleased() { return (!currstate && laststate); }
+
+// -------------------------------------------------------------------------
+
+// GFXcanvas1, GFXcanvas8 and GFXcanvas16 (currently a WIP, don't get too
+// comfy with the implementation) provide 1-, 8- and 16-bit offscreen
+// canvases, the address of which can be passed to drawBitmap() or
+// pushColors() (the latter appears only in a couple of GFX-subclassed TFT
+// libraries at this time).  This is here mostly to help with the recently-
+// added proportionally-spaced fonts; adds a way to refresh a section of the
+// screen without a massive flickering clear-and-redraw...but maybe you'll
+// find other uses too.  VERY RAM-intensive, since the buffer is in MCU
+// memory and not the display driver...GXFcanvas1 might be minimally useful
+// on an Uno-class board, but this and the others are much more likely to
+// require at least a Mega or various recent ARM-type boards (recommended,
+// as the text+bitmap draw can be pokey).  GFXcanvas1 requires 1 bit per
+// pixel (rounded up to nearest byte per scanline), GFXcanvas8 is 1 byte
+// per pixel (no scanline pad), and GFXcanvas16 uses 2 bytes per pixel (no
+// scanline pad).
+// NOT EXTENSIVELY TESTED YET.  MAY CONTAIN WORST BUGS KNOWN TO HUMANKIND.
+
+/**************************************************************************/
+/*!
+   @brief    Instatiate a GFX 1-bit canvas context for graphics
+   @param    w   Display width, in pixels
+   @param    h   Display height, in pixels
+*/
+/**************************************************************************/
+GFXcanvas1::GFXcanvas1(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
+    uint16_t bytes = ((w + 7) / 8) * h;
+    if((buffer = (uint8_t *)malloc(bytes))) {
+        memset(buffer, 0, bytes);
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Delete the canvas, free memory
+*/
+/**************************************************************************/
+GFXcanvas1::~GFXcanvas1(void) {
+    if(buffer) free(buffer);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Get a pointer to the internal buffer memory
+   @returns  A pointer to the allocated buffer
+*/
+/**************************************************************************/
+uint8_t* GFXcanvas1::getBuffer(void) {
+    return buffer;
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw a pixel to the canvas framebuffer
+    @param   x   x coordinate
+    @param   y   y coordinate
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void GFXcanvas1::drawPixel(int16_t x, int16_t y, uint16_t color) {
+#ifdef __AVR__
+    // Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR
+    static const uint8_t PROGMEM
+        GFXsetBit[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 },
+        GFXclrBit[] = { 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE };
+#endif
+
+    if(buffer) {
+        if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
+
+        int16_t t;
+        switch(rotation) {
+            case 1:
+                t = x;
+                x = WIDTH  - 1 - y;
+                y = t;
+                break;
+            case 2:
+                x = WIDTH  - 1 - x;
+                y = HEIGHT - 1 - y;
+                break;
+            case 3:
+                t = x;
+                x = y;
+                y = HEIGHT - 1 - t;
+                break;
+        }
+
+        uint8_t   *ptr  = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)];
+#ifdef __AVR__
+        if(color) *ptr |= pgm_read_byte(&GFXsetBit[x & 7]);
+        else      *ptr &= pgm_read_byte(&GFXclrBit[x & 7]);
+#else
+        if(color) *ptr |=   0x80 >> (x & 7);
+        else      *ptr &= ~(0x80 >> (x & 7));
+#endif
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Fill the framebuffer completely with one color
+    @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void GFXcanvas1::fillScreen(uint16_t color) {
+    if(buffer) {
+        uint16_t bytes = ((WIDTH + 7) / 8) * HEIGHT;
+        memset(buffer, color ? 0xFF : 0x00, bytes);
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Instatiate a GFX 8-bit canvas context for graphics
+   @param    w   Display width, in pixels
+   @param    h   Display height, in pixels
+*/
+/**************************************************************************/
+GFXcanvas8::GFXcanvas8(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
+    uint32_t bytes = w * h;
+    if((buffer = (uint8_t *)malloc(bytes))) {
+        memset(buffer, 0, bytes);
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Delete the canvas, free memory
+*/
+/**************************************************************************/
+GFXcanvas8::~GFXcanvas8(void) {
+    if(buffer) free(buffer);
+}
+
+
+/**************************************************************************/
+/*!
+   @brief    Get a pointer to the internal buffer memory
+   @returns  A pointer to the allocated buffer
+*/
+/**************************************************************************/
+uint8_t* GFXcanvas8::getBuffer(void) {
+    return buffer;
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw a pixel to the canvas framebuffer
+    @param   x   x coordinate
+    @param   y   y coordinate
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void GFXcanvas8::drawPixel(int16_t x, int16_t y, uint16_t color) {
+    if(buffer) {
+        if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
+
+        int16_t t;
+        switch(rotation) {
+            case 1:
+                t = x;
+                x = WIDTH  - 1 - y;
+                y = t;
+                break;
+            case 2:
+                x = WIDTH  - 1 - x;
+                y = HEIGHT - 1 - y;
+                break;
+            case 3:
+                t = x;
+                x = y;
+                y = HEIGHT - 1 - t;
+                break;
+        }
+
+        buffer[x + y * WIDTH] = color;
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Fill the framebuffer completely with one color
+    @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void GFXcanvas8::fillScreen(uint16_t color) {
+    if(buffer) {
+        memset(buffer, color, WIDTH * HEIGHT);
+    }
+}
+
+void GFXcanvas8::writeFastHLine(int16_t x, int16_t y,
+  int16_t w, uint16_t color) {
+
+    if((x >= _width) || (y < 0) || (y >= _height)) return;
+    int16_t x2 = x + w - 1;
+    if(x2 < 0) return;
+
+    // Clip left/right
+    if(x < 0) {
+        x = 0;
+        w = x2 + 1;
+    }
+    if(x2 >= _width) w = _width - x;
+
+    int16_t t;
+    switch(rotation) {
+        case 1:
+            t = x;
+            x = WIDTH  - 1 - y;
+            y = t;
+            break;
+        case 2:
+            x = WIDTH  - 1 - x;
+            y = HEIGHT - 1 - y;
+            break;
+        case 3:
+            t = x;
+            x = y;
+            y = HEIGHT - 1 - t;
+            break;
+    }
+
+    memset(buffer + y * WIDTH + x, color, w);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Instatiate a GFX 16-bit canvas context for graphics
+   @param    w   Display width, in pixels
+   @param    h   Display height, in pixels
+*/
+/**************************************************************************/
+GFXcanvas16::GFXcanvas16(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
+    uint32_t bytes = w * h * 2;
+    if((buffer = (uint16_t *)malloc(bytes))) {
+        memset(buffer, 0, bytes);
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Delete the canvas, free memory
+*/
+/**************************************************************************/
+GFXcanvas16::~GFXcanvas16(void) {
+    if(buffer) free(buffer);
+}
+
+/**************************************************************************/
+/*!
+   @brief    Get a pointer to the internal buffer memory
+   @returns  A pointer to the allocated buffer
+*/
+/**************************************************************************/
+uint16_t* GFXcanvas16::getBuffer(void) {
+    return buffer;
+}
+
+/**************************************************************************/
+/*!
+   @brief    Draw a pixel to the canvas framebuffer
+    @param   x   x coordinate
+    @param   y   y coordinate
+   @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void GFXcanvas16::drawPixel(int16_t x, int16_t y, uint16_t color) {
+    if(buffer) {
+        if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
+
+        int16_t t;
+        switch(rotation) {
+            case 1:
+                t = x;
+                x = WIDTH  - 1 - y;
+                y = t;
+                break;
+            case 2:
+                x = WIDTH  - 1 - x;
+                y = HEIGHT - 1 - y;
+                break;
+            case 3:
+                t = x;
+                x = y;
+                y = HEIGHT - 1 - t;
+                break;
+        }
+
+        buffer[x + y * WIDTH] = color;
+    }
+}
+
+/**************************************************************************/
+/*!
+   @brief    Fill the framebuffer completely with one color
+    @param    color 16-bit 5-6-5 Color to fill with
+*/
+/**************************************************************************/
+void GFXcanvas16::fillScreen(uint16_t color) {
+    if(buffer) {
+        uint8_t hi = color >> 8, lo = color & 0xFF;
+        if(hi == lo) {
+            memset(buffer, lo, WIDTH * HEIGHT * 2);
+        } else {
+            uint32_t i, pixels = WIDTH * HEIGHT;
+            for(i=0; i<pixels; i++) buffer[i] = color;
+        }
+    }
+}
+
diff --git a/source/sharp/Adafruit_GFX.h b/source/sharp/Adafruit_GFX.h
new file mode 100755
index 0000000..5af57aa
--- /dev/null
+++ b/source/sharp/Adafruit_GFX.h
@@ -0,0 +1,227 @@
+#ifndef _ADAFRUIT_GFX_H
+#define _ADAFRUIT_GFX_H
+
+#if ARDUINO >= 100
+ #include "Arduino.h"
+ #include "Print.h"
+#else
+ #include "WProgram.h"
+#endif
+#include "gfxfont.h"
+
+/// A generic graphics superclass that can handle all sorts of drawing. At a minimum you can subclass and provide drawPixel(). At a maximum you can do a ton of overriding to optimize. Used for any/all Adafruit displays!
+class Adafruit_GFX : public Print {
+
+ public:
+
+  Adafruit_GFX(int16_t w, int16_t h); // Constructor
+
+  // This MUST be defined by the subclass:
+  virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;    ///< Virtual drawPixel() function to draw to the screen/framebuffer/etc, must be overridden in subclass. @param x X coordinate.  @param y Y coordinate. @param color 16-bit pixel color. 
+
+  // TRANSACTION API / CORE DRAW API
+  // These MAY be overridden by the subclass to provide device-specific
+  // optimized code.  Otherwise 'generic' versions are used.
+  virtual void startWrite(void);
+  virtual void writePixel(int16_t x, int16_t y, uint16_t color);
+  virtual void writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
+  virtual void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
+  virtual void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+  virtual void writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
+  virtual void endWrite(void);
+
+  // CONTROL API
+  // These MAY be overridden by the subclass to provide device-specific
+  // optimized code.  Otherwise 'generic' versions are used.
+  virtual void setRotation(uint8_t r);
+  virtual void invertDisplay(boolean i);
+
+  // BASIC DRAW API
+  // These MAY be overridden by the subclass to provide device-specific
+  // optimized code.  Otherwise 'generic' versions are used.
+  virtual void
+    // It's good to implement those, even if using transaction API
+    drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
+    drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
+    fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
+    fillScreen(uint16_t color),
+    // Optional and probably not necessary to change
+    drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color),
+    drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
+
+  // These exist only with Adafruit_GFX (no subclass overrides)
+  void
+    drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
+    drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
+      uint16_t color),
+    fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
+    fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
+      int16_t delta, uint16_t color),
+    drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
+      int16_t x2, int16_t y2, uint16_t color),
+    fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
+      int16_t x2, int16_t y2, uint16_t color),
+    drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
+      int16_t radius, uint16_t color),
+    fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
+      int16_t radius, uint16_t color),
+    drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
+      int16_t w, int16_t h, uint16_t color),
+    drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
+      int16_t w, int16_t h, uint16_t color, uint16_t bg),
+    drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
+      int16_t w, int16_t h, uint16_t color),
+    drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
+      int16_t w, int16_t h, uint16_t color, uint16_t bg),
+    drawXBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
+      int16_t w, int16_t h, uint16_t color),
+    drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[],
+      int16_t w, int16_t h),
+    drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap,
+      int16_t w, int16_t h),
+    drawGrayscaleBitmap(int16_t x, int16_t y,
+      const uint8_t bitmap[], const uint8_t mask[],
+      int16_t w, int16_t h),
+    drawGrayscaleBitmap(int16_t x, int16_t y,
+      uint8_t *bitmap, uint8_t *mask, int16_t w, int16_t h),
+    drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[],
+      int16_t w, int16_t h),
+    drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap,
+      int16_t w, int16_t h),
+    drawRGBBitmap(int16_t x, int16_t y,
+      const uint16_t bitmap[], const uint8_t mask[],
+      int16_t w, int16_t h),
+    drawRGBBitmap(int16_t x, int16_t y,
+      uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h),
+    drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
+      uint16_t bg, uint8_t size),
+    setCursor(int16_t x, int16_t y),
+    setTextColor(uint16_t c),
+    setTextColor(uint16_t c, uint16_t bg),
+    setTextSize(uint8_t s),
+    setTextWrap(boolean w),
+    cp437(boolean x=true),
+    setFont(const GFXfont *f = NULL),
+    getTextBounds(const char *string, int16_t x, int16_t y,
+      int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
+    getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y,
+      int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
+    getTextBounds(const String &str, int16_t x, int16_t y,
+      int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
+
+
+#if ARDUINO >= 100
+  virtual size_t write(uint8_t);
+#else
+  virtual void   write(uint8_t);
+#endif
+
+  int16_t height(void) const;
+  int16_t width(void) const;
+
+  uint8_t getRotation(void) const;
+
+  // get current cursor position (get rotation safe maximum values, using: width() for x, height() for y)
+  int16_t getCursorX(void) const;
+  int16_t getCursorY(void) const;
+
+ protected:
+  void
+    charBounds(char c, int16_t *x, int16_t *y,
+      int16_t *minx, int16_t *miny, int16_t *maxx, int16_t *maxy);
+  const int16_t
+    WIDTH,          ///< This is the 'raw' display width - never changes
+    HEIGHT;         ///< This is the 'raw' display height - never changes
+  int16_t
+    _width,         ///< Display width as modified by current rotation
+    _height,        ///< Display height as modified by current rotation
+    cursor_x,       ///< x location to start print()ing text
+    cursor_y;       ///< y location to start print()ing text
+  uint16_t
+    textcolor,      ///< 16-bit background color for print()
+    textbgcolor;    ///< 16-bit text color for print()
+  uint8_t
+    textsize,       ///< Desired magnification of text to print()
+    rotation;       ///< Display rotation (0 thru 3)
+  boolean
+    wrap,           ///< If set, 'wrap' text at right edge of display
+    _cp437;         ///< If set, use correct CP437 charset (default is off)
+  GFXfont
+    *gfxFont;       ///< Pointer to special font
+};
+
+
+/// A simple drawn button UI element
+class Adafruit_GFX_Button {
+
+ public:
+  Adafruit_GFX_Button(void);
+  // "Classic" initButton() uses center & size
+  void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,
+   uint16_t w, uint16_t h, uint16_t outline, uint16_t fill,
+   uint16_t textcolor, char *label, uint8_t textsize);
+  // New/alt initButton() uses upper-left corner & size
+  void initButtonUL(Adafruit_GFX *gfx, int16_t x1, int16_t y1,
+   uint16_t w, uint16_t h, uint16_t outline, uint16_t fill,
+   uint16_t textcolor, char *label, uint8_t textsize);
+  void drawButton(boolean inverted = false);
+  boolean contains(int16_t x, int16_t y);
+
+  void press(boolean p);
+  boolean isPressed();
+  boolean justPressed();
+  boolean justReleased();
+
+ private:
+  Adafruit_GFX *_gfx;
+  int16_t       _x1, _y1; // Coordinates of top-left corner
+  uint16_t      _w, _h;
+  uint8_t       _textsize;
+  uint16_t      _outlinecolor, _fillcolor, _textcolor;
+  char          _label[10];
+
+  boolean currstate, laststate;
+};
+
+
+/// A GFX 1-bit canvas context for graphics
+class GFXcanvas1 : public Adafruit_GFX {
+ public:
+  GFXcanvas1(uint16_t w, uint16_t h);
+  ~GFXcanvas1(void);
+  void     drawPixel(int16_t x, int16_t y, uint16_t color),
+           fillScreen(uint16_t color);
+  uint8_t *getBuffer(void);
+ private:
+  uint8_t *buffer;
+};
+
+
+/// A GFX 8-bit canvas context for graphics
+class GFXcanvas8 : public Adafruit_GFX {
+ public:
+  GFXcanvas8(uint16_t w, uint16_t h);
+  ~GFXcanvas8(void);
+  void     drawPixel(int16_t x, int16_t y, uint16_t color),
+           fillScreen(uint16_t color),
+           writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
+
+  uint8_t *getBuffer(void);
+ private:
+  uint8_t *buffer;
+};
+
+
+///  A GFX 16-bit canvas context for graphics
+class GFXcanvas16 : public Adafruit_GFX {
+ public:
+  GFXcanvas16(uint16_t w, uint16_t h);
+  ~GFXcanvas16(void);
+  void      drawPixel(int16_t x, int16_t y, uint16_t color),
+            fillScreen(uint16_t color);
+  uint16_t *getBuffer(void);
+ private:
+  uint16_t *buffer;
+};
+
+#endif // _ADAFRUIT_GFX_H
diff --git a/source/sharp/Adafruit_SharpMem.cpp b/source/sharp/Adafruit_SharpMem.cpp
new file mode 100644
index 0000000..5e963ff
--- /dev/null
+++ b/source/sharp/Adafruit_SharpMem.cpp
@@ -0,0 +1,315 @@
+/*********************************************************************
+This is an Arduino library for our Monochrome SHARP Memory Displays
+
+  Pick one up today in the adafruit shop!
+  ------> http://www.adafruit.com/products/1393
+
+These displays use SPI to communicate, 3 pins are required to  
+interface
+
+Adafruit invests time and resources providing this open source code, 
+please support Adafruit and open-source hardware by purchasing 
+products from Adafruit!
+
+Written by Limor Fried/Ladyada  for Adafruit Industries.  
+BSD license, check license.txt for more information
+All text above, and the splash screen must be included in any redistribution
+*********************************************************************/
+
+#include "Adafruit_SharpMem.h"
+
+#ifndef _swap_int16_t
+#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
+#endif
+#ifndef _swap_uint16_t
+#define _swap_uint16_t(a, b) { uint16_t t = a; a = b; b = t; }
+#endif
+
+/**************************************************************************
+    Sharp Memory Display Connector
+    -----------------------------------------------------------------------
+    Pin   Function        Notes
+    ===   ==============  ===============================
+      1   VIN             3.3-5.0V (into LDO supply)
+      2   3V3             3.3V out
+      3   GND
+      4   SCLK            Serial Clock
+      5   MOSI            Serial Data Input
+      6   CS              Serial Chip Select
+      9   EXTMODE         COM Inversion Select (Low = SW clock/serial)
+      7   EXTCOMIN        External COM Inversion Signal
+      8   DISP            Display On(High)/Off(Low)
+
+ **************************************************************************/
+
+#define SHARPMEM_BIT_WRITECMD   (0x80)
+#define SHARPMEM_BIT_VCOM       (0x40)
+#define SHARPMEM_BIT_CLEAR      (0x20)
+#define TOGGLE_VCOM             do { _sharpmem_vcom = _sharpmem_vcom ? 0x00 : SHARPMEM_BIT_VCOM; } while(0);
+
+byte *sharpmem_buffer;
+
+/* ************* */
+/* CONSTRUCTORS  */
+/* ************* */
+Adafruit_SharpMem::Adafruit_SharpMem(uint8_t clk, uint8_t mosi, uint8_t ss, uint16_t width, uint16_t height) :
+Adafruit_GFX(width, height) {
+  _clk  = clk;
+  _mosi = mosi;
+  _ss   = ss;
+}
+
+boolean Adafruit_SharpMem::begin(void) {
+  // Set pin state before direction to make sure they start this way (no glitching)
+  digitalWrite(_ss, HIGH);  
+  digitalWrite(_clk, LOW);  
+  digitalWrite(_mosi, HIGH);  
+  
+  pinMode(_ss, OUTPUT);
+  pinMode(_clk, OUTPUT);
+  pinMode(_mosi, OUTPUT);
+
+#if defined(USE_FAST_PINIO)
+  clkport     = portOutputRegister(digitalPinToPort(_clk));
+  clkpinmask  = digitalPinToBitMask(_clk);
+  dataport    = portOutputRegister(digitalPinToPort(_mosi));
+  datapinmask = digitalPinToBitMask(_mosi);
+#endif
+
+  // Set the vcom bit to a defined state
+  _sharpmem_vcom = SHARPMEM_BIT_VCOM;
+
+
+  sharpmem_buffer = (byte *)malloc((WIDTH * HEIGHT) / 8);
+
+  if (!sharpmem_buffer) return false;
+
+  setRotation(0);
+
+  return true;
+}
+
+/* *************** */
+/* PRIVATE METHODS */
+/* *************** */
+
+ 
+/**************************************************************************/
+/*!
+    @brief  Sends a single byte in pseudo-SPI.
+*/
+/**************************************************************************/
+void Adafruit_SharpMem::sendbyte(uint8_t data) 
+{
+  uint8_t i = 0;
+
+  // LCD expects LSB first
+
+#if defined(USE_FAST_PINIO)
+  for (i=0; i<8; i++) {
+    // Make sure clock starts low
+    *clkport &= ~clkpinmask;
+    if (data & 0x80) 
+      *dataport |=  datapinmask;
+    else 
+      *dataport &= ~datapinmask;
+
+    // Clock is active high
+    *clkport |=  clkpinmask;
+    data <<= 1; 
+  }
+  *clkport &= ~clkpinmask;
+#else
+  for (i=0; i<8; i++) { 
+    // Make sure clock starts low
+    digitalWrite(_clk, LOW);
+    if (data & 0x80) 
+      digitalWrite(_mosi, HIGH);
+    else 
+      digitalWrite(_mosi, LOW);
+
+    // Clock is active high
+    digitalWrite(_clk, HIGH);
+    data <<= 1; 
+  }
+  // Make sure clock ends low
+  digitalWrite(_clk, LOW);
+#endif
+}
+
+void Adafruit_SharpMem::sendbyteLSB(uint8_t data) 
+{
+  uint8_t i = 0;
+
+  // LCD expects LSB first
+#if defined(USE_FAST_PINIO)
+  for (i=0; i<8; i++) { 
+    // Make sure clock starts low
+    *clkport &= ~clkpinmask;
+    if (data & 0x01) 
+      *dataport |=  datapinmask;
+    else 
+      *dataport &= ~datapinmask;
+    // Clock is active high
+    *clkport |=  clkpinmask;
+    data >>= 1; 
+  }
+  // Make sure clock ends low
+  *clkport &= ~clkpinmask;
+#else
+  for (i=0; i<8; i++) 
+  { 
+    // Make sure clock starts low
+    digitalWrite(_clk, LOW);
+    if (data & 0x01) 
+      digitalWrite(_mosi, HIGH);
+    else 
+      digitalWrite(_mosi, LOW);
+    // Clock is active high
+    digitalWrite(_clk, HIGH);
+    data >>= 1; 
+  }
+  // Make sure clock ends low
+  digitalWrite(_clk, LOW);
+#endif
+}
+
+/* ************** */
+/* PUBLIC METHODS */
+/* ************** */
+
+// 1<<n is a costly operation on AVR -- table usu. smaller & faster
+static const uint8_t PROGMEM
+  set[] = {  1,  2,  4,  8,  16,  32,  64,  128 },
+  clr[] = { (uint8_t)~1 , (uint8_t)~2 , (uint8_t)~4 , (uint8_t)~8,
+            (uint8_t)~16, (uint8_t)~32, (uint8_t)~64, (uint8_t)~128 };
+
+/**************************************************************************/
+/*! 
+    @brief Draws a single pixel in image buffer
+
+    @param[in]  x
+                The x position (0 based)
+    @param[in]  y
+                The y position (0 based)
+*/
+/**************************************************************************/
+void Adafruit_SharpMem::drawPixel(int16_t x, int16_t y, uint16_t color) 
+{
+  if((x < 0) || (x >= _width) || (y < 0) || (y >= _height)) return;
+
+  switch(rotation) {
+   case 1:
+    _swap_int16_t(x, y);
+    x = WIDTH  - 1 - x;
+    break;
+   case 2:
+    x = WIDTH  - 1 - x;
+    y = HEIGHT - 1 - y;
+    break;
+   case 3:
+    _swap_int16_t(x, y);
+    y = HEIGHT - 1 - y;
+    break;
+  }
+
+  if(color) {
+    sharpmem_buffer[(y * WIDTH + x) / 8] |=
+      pgm_read_byte(&set[x & 7]);
+  } else {
+    sharpmem_buffer[(y * WIDTH + x) / 8] &=
+      pgm_read_byte(&clr[x & 7]);
+  }
+}
+
+/**************************************************************************/
+/*! 
+    @brief Gets the value (1 or 0) of the specified pixel from the buffer
+
+    @param[in]  x
+                The x position (0 based)
+    @param[in]  y
+                The y position (0 based)
+
+    @return     1 if the pixel is enabled, 0 if disabled
+*/
+/**************************************************************************/
+uint8_t Adafruit_SharpMem::getPixel(uint16_t x, uint16_t y)
+{
+  if((x >= _width) || (y >= _height)) return 0; // <0 test not needed, unsigned
+
+  switch(rotation) {
+   case 1:
+    _swap_uint16_t(x, y);
+    x = WIDTH  - 1 - x;
+    break;
+   case 2:
+    x = WIDTH  - 1 - x;
+    y = HEIGHT - 1 - y;
+    break;
+   case 3:
+    _swap_uint16_t(x, y);
+    y = HEIGHT - 1 - y;
+    break;
+  }
+
+  return sharpmem_buffer[(y * WIDTH + x) / 8] &
+    pgm_read_byte(&set[x & 7]) ? 1 : 0;
+}
+
+/**************************************************************************/
+/*! 
+    @brief Clears the screen
+*/
+/**************************************************************************/
+void Adafruit_SharpMem::clearDisplay() 
+{
+  memset(sharpmem_buffer, 0xff, (WIDTH * HEIGHT) / 8);
+  // Send the clear screen command rather than doing a HW refresh (quicker)
+  digitalWrite(_ss, HIGH);
+  sendbyte(_sharpmem_vcom | SHARPMEM_BIT_CLEAR);
+  sendbyteLSB(0x00);
+  TOGGLE_VCOM;
+  digitalWrite(_ss, LOW);
+}
+
+/**************************************************************************/
+/*! 
+    @brief Renders the contents of the pixel buffer on the LCD
+*/
+/**************************************************************************/
+void Adafruit_SharpMem::refresh(void) 
+{
+  uint16_t i, totalbytes, currentline, oldline;  
+  totalbytes = (WIDTH * HEIGHT) / 8;
+
+  // Send the write command
+  digitalWrite(_ss, HIGH);
+  sendbyte(SHARPMEM_BIT_WRITECMD | _sharpmem_vcom);
+  TOGGLE_VCOM;
+
+  // Send the address for line 1
+  oldline = currentline = 1;
+  sendbyteLSB(currentline);
+
+  // Send image buffer
+  for (i=0; i<totalbytes; i++)
+  {
+    sendbyteLSB(sharpmem_buffer[i]);
+    currentline = ((i+1)/(WIDTH/8)) + 1;
+    if(currentline != oldline)
+    {
+      // Send end of line and address bytes
+      sendbyteLSB(0x00);
+      if (currentline <= HEIGHT)
+      {
+        sendbyteLSB(currentline);
+      }
+      oldline = currentline;
+    }
+  }
+
+  // Send another trailing 8 bits for the last line
+  sendbyteLSB(0x00);
+  digitalWrite(_ss, LOW);
+}
diff --git a/source/sharp/Adafruit_SharpMem.h b/source/sharp/Adafruit_SharpMem.h
new file mode 100644
index 0000000..1b0b581
--- /dev/null
+++ b/source/sharp/Adafruit_SharpMem.h
@@ -0,0 +1,70 @@
+/*********************************************************************
+This is an Arduino library for our Monochrome SHARP Memory Displays
+
+  Pick one up today in the adafruit shop!
+  ------> http://www.adafruit.com/products/1393
+
+These displays use SPI to communicate, 3 pins are required to  
+interface
+
+Adafruit invests time and resources providing this open source code, 
+please support Adafruit and open-source hardware by purchasing 
+products from Adafruit!
+
+Written by Limor Fried/Ladyada  for Adafruit Industries.  
+BSD license, check license.txt for more information
+All text above, and the splash screen must be included in any redistribution
+*********************************************************************/
+
+#if ARDUINO >= 100
+ #include "Arduino.h"
+#else
+ #include "WProgram.h"
+#endif
+
+#if defined(RAMSTART) && defined(RAMEND) && ((RAMEND-RAMSTART) < 4096)
+  #warning "Display may not work on devices with less than 4K RAM"
+#endif
+ 
+#include <Adafruit_GFX.h>
+#ifdef __AVR
+  #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+  #include <pgmspace.h>
+#endif
+
+#if defined(ARDUINO_STM32_FEATHER)
+  typedef volatile uint32 RwReg;
+  //#define USE_FAST_PINIO
+#elif defined(ARDUINO_FEATHER52) || defined (ESP8266) || defined (ESP32) || defined(__SAM3X8E__) || defined(ARDUINO_ARCH_SAMD)
+  typedef volatile uint32_t RwReg;
+  #define USE_FAST_PINIO  // tested!
+#elif defined (__AVR__) || defined(TEENSYDUINO)
+  typedef volatile uint8_t RwReg;
+  #define USE_FAST_PINIO
+#else
+  #undef USE_FAST_PINIO  
+#endif
+
+
+class Adafruit_SharpMem : public Adafruit_GFX {
+ public:
+  Adafruit_SharpMem(uint8_t clk, uint8_t mosi, uint8_t ss, uint16_t w = 96, uint16_t h = 96);
+  boolean begin();
+  void drawPixel(int16_t x, int16_t y, uint16_t color);
+  uint8_t getPixel(uint16_t x, uint16_t y);
+  void clearDisplay();
+  void refresh(void);
+
+ private:
+  uint8_t _ss, _clk, _mosi;
+  uint32_t _sharpmem_vcom;
+
+#ifdef USE_FAST_PINIO
+  volatile RwReg *dataport, *clkport;
+  uint32_t datapinmask, clkpinmask;
+#endif
+  
+  void sendbyte(uint8_t data);
+  void sendbyteLSB(uint8_t data);
+};
diff --git a/source/sharp/README.txt b/source/sharp/README.txt
new file mode 100644
index 0000000..0a84a65
--- /dev/null
+++ b/source/sharp/README.txt
@@ -0,0 +1,21 @@
+This is an Arduino library for our Monochrome SHARP Memory Displays
+
+  Pick one up today in the adafruit shop!
+  ------> http://www.adafruit.com/products/1393
+
+These displays use SPI to communicate, 3 pins are required to  
+interface
+
+To install this library, check out our detailed library install tutorial:
+http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use
+
+Also requires the Adafruit GFX library, install the same way
+https://github.com/adafruit/Adafruit-GFX-Library
+
+Adafruit invests time and resources providing this open source code, 
+please support Adafruit and open-source hardware by purchasing 
+products from Adafruit!
+
+Written by Limor Fried & Kevin Townsend  for Adafruit Industries.  
+BSD license, check license.txt for more information
+All text above, and the splash screen must be included in any redistribution
\ No newline at end of file
diff --git a/source/sharp/gfxfont.h b/source/sharp/gfxfont.h
new file mode 100644
index 0000000..c691de6
--- /dev/null
+++ b/source/sharp/gfxfont.h
@@ -0,0 +1,29 @@
+// Font structures for newer Adafruit_GFX (1.1 and later).
+// Example fonts are included in 'Fonts' directory.
+// To use a font in your Arduino sketch, #include the corresponding .h
+// file and pass address of GFXfont struct to setFont().  Pass NULL to
+// revert to 'classic' fixed-space bitmap font.
+
+#ifndef _GFXFONT_H_
+#define _GFXFONT_H_
+
+/// Font data stored PER GLYPH
+typedef struct {
+	uint16_t bitmapOffset;     ///< Pointer into GFXfont->bitmap
+	uint8_t  width;            ///< Bitmap dimensions in pixels
+        uint8_t  height;           ///< Bitmap dimensions in pixels
+	uint8_t  xAdvance;         ///< Distance to advance cursor (x axis)
+	int8_t   xOffset;          ///< X dist from cursor pos to UL corner
+        int8_t   yOffset;          ///< Y dist from cursor pos to UL corner
+} GFXglyph;
+
+/// Data stored for FONT AS A WHOLE
+typedef struct { 
+	uint8_t  *bitmap;      ///< Glyph bitmaps, concatenated
+	GFXglyph *glyph;       ///< Glyph array
+	uint8_t   first;       ///< ASCII extents (first char)
+        uint8_t   last;        ///< ASCII extents (last char)
+	uint8_t   yAdvance;    ///< Newline distance (y axis)
+} GFXfont;
+
+#endif // _GFXFONT_H_
diff --git a/source/sharp/glcdfont.c b/source/sharp/glcdfont.c
new file mode 100644
index 0000000..6f88bd2
--- /dev/null
+++ b/source/sharp/glcdfont.c
@@ -0,0 +1,276 @@
+// This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0.
+// See gfxfont.h for newer custom bitmap font info.
+
+#ifndef FONT5X7_H
+#define FONT5X7_H
+
+#ifdef __AVR__
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+#elif defined(ESP8266)
+ #include <pgmspace.h>
+#else
+ #define PROGMEM
+#endif
+
+// Standard ASCII 5x7 font
+
+static const unsigned char font[] PROGMEM = {
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x3E, 0x5B, 0x4F, 0x5B, 0x3E,
+	0x3E, 0x6B, 0x4F, 0x6B, 0x3E,
+	0x1C, 0x3E, 0x7C, 0x3E, 0x1C,
+	0x18, 0x3C, 0x7E, 0x3C, 0x18,
+	0x1C, 0x57, 0x7D, 0x57, 0x1C,
+	0x1C, 0x5E, 0x7F, 0x5E, 0x1C,
+	0x00, 0x18, 0x3C, 0x18, 0x00,
+	0xFF, 0xE7, 0xC3, 0xE7, 0xFF,
+	0x00, 0x18, 0x24, 0x18, 0x00,
+	0xFF, 0xE7, 0xDB, 0xE7, 0xFF,
+	0x30, 0x48, 0x3A, 0x06, 0x0E,
+	0x26, 0x29, 0x79, 0x29, 0x26,
+	0x40, 0x7F, 0x05, 0x05, 0x07,
+	0x40, 0x7F, 0x05, 0x25, 0x3F,
+	0x5A, 0x3C, 0xE7, 0x3C, 0x5A,
+	0x7F, 0x3E, 0x1C, 0x1C, 0x08,
+	0x08, 0x1C, 0x1C, 0x3E, 0x7F,
+	0x14, 0x22, 0x7F, 0x22, 0x14,
+	0x5F, 0x5F, 0x00, 0x5F, 0x5F,
+	0x06, 0x09, 0x7F, 0x01, 0x7F,
+	0x00, 0x66, 0x89, 0x95, 0x6A,
+	0x60, 0x60, 0x60, 0x60, 0x60,
+	0x94, 0xA2, 0xFF, 0xA2, 0x94,
+	0x08, 0x04, 0x7E, 0x04, 0x08,
+	0x10, 0x20, 0x7E, 0x20, 0x10,
+	0x08, 0x08, 0x2A, 0x1C, 0x08,
+	0x08, 0x1C, 0x2A, 0x08, 0x08,
+	0x1E, 0x10, 0x10, 0x10, 0x10,
+	0x0C, 0x1E, 0x0C, 0x1E, 0x0C,
+	0x30, 0x38, 0x3E, 0x38, 0x30,
+	0x06, 0x0E, 0x3E, 0x0E, 0x06,
+	0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x5F, 0x00, 0x00,
+	0x00, 0x07, 0x00, 0x07, 0x00,
+	0x14, 0x7F, 0x14, 0x7F, 0x14,
+	0x24, 0x2A, 0x7F, 0x2A, 0x12,
+	0x23, 0x13, 0x08, 0x64, 0x62,
+	0x36, 0x49, 0x56, 0x20, 0x50,
+	0x00, 0x08, 0x07, 0x03, 0x00,
+	0x00, 0x1C, 0x22, 0x41, 0x00,
+	0x00, 0x41, 0x22, 0x1C, 0x00,
+	0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
+	0x08, 0x08, 0x3E, 0x08, 0x08,
+	0x00, 0x80, 0x70, 0x30, 0x00,
+	0x08, 0x08, 0x08, 0x08, 0x08,
+	0x00, 0x00, 0x60, 0x60, 0x00,
+	0x20, 0x10, 0x08, 0x04, 0x02,
+	0x3E, 0x51, 0x49, 0x45, 0x3E,
+	0x00, 0x42, 0x7F, 0x40, 0x00,
+	0x72, 0x49, 0x49, 0x49, 0x46,
+	0x21, 0x41, 0x49, 0x4D, 0x33,
+	0x18, 0x14, 0x12, 0x7F, 0x10,
+	0x27, 0x45, 0x45, 0x45, 0x39,
+	0x3C, 0x4A, 0x49, 0x49, 0x31,
+	0x41, 0x21, 0x11, 0x09, 0x07,
+	0x36, 0x49, 0x49, 0x49, 0x36,
+	0x46, 0x49, 0x49, 0x29, 0x1E,
+	0x00, 0x00, 0x14, 0x00, 0x00,
+	0x00, 0x40, 0x34, 0x00, 0x00,
+	0x00, 0x08, 0x14, 0x22, 0x41,
+	0x14, 0x14, 0x14, 0x14, 0x14,
+	0x00, 0x41, 0x22, 0x14, 0x08,
+	0x02, 0x01, 0x59, 0x09, 0x06,
+	0x3E, 0x41, 0x5D, 0x59, 0x4E,
+	0x7C, 0x12, 0x11, 0x12, 0x7C,
+	0x7F, 0x49, 0x49, 0x49, 0x36,
+	0x3E, 0x41, 0x41, 0x41, 0x22,
+	0x7F, 0x41, 0x41, 0x41, 0x3E,
+	0x7F, 0x49, 0x49, 0x49, 0x41,
+	0x7F, 0x09, 0x09, 0x09, 0x01,
+	0x3E, 0x41, 0x41, 0x51, 0x73,
+	0x7F, 0x08, 0x08, 0x08, 0x7F,
+	0x00, 0x41, 0x7F, 0x41, 0x00,
+	0x20, 0x40, 0x41, 0x3F, 0x01,
+	0x7F, 0x08, 0x14, 0x22, 0x41,
+	0x7F, 0x40, 0x40, 0x40, 0x40,
+	0x7F, 0x02, 0x1C, 0x02, 0x7F,
+	0x7F, 0x04, 0x08, 0x10, 0x7F,
+	0x3E, 0x41, 0x41, 0x41, 0x3E,
+	0x7F, 0x09, 0x09, 0x09, 0x06,
+	0x3E, 0x41, 0x51, 0x21, 0x5E,
+	0x7F, 0x09, 0x19, 0x29, 0x46,
+	0x26, 0x49, 0x49, 0x49, 0x32,
+	0x03, 0x01, 0x7F, 0x01, 0x03,
+	0x3F, 0x40, 0x40, 0x40, 0x3F,
+	0x1F, 0x20, 0x40, 0x20, 0x1F,
+	0x3F, 0x40, 0x38, 0x40, 0x3F,
+	0x63, 0x14, 0x08, 0x14, 0x63,
+	0x03, 0x04, 0x78, 0x04, 0x03,
+	0x61, 0x59, 0x49, 0x4D, 0x43,
+	0x00, 0x7F, 0x41, 0x41, 0x41,
+	0x02, 0x04, 0x08, 0x10, 0x20,
+	0x00, 0x41, 0x41, 0x41, 0x7F,
+	0x04, 0x02, 0x01, 0x02, 0x04,
+	0x40, 0x40, 0x40, 0x40, 0x40,
+	0x00, 0x03, 0x07, 0x08, 0x00,
+	0x20, 0x54, 0x54, 0x78, 0x40,
+	0x7F, 0x28, 0x44, 0x44, 0x38,
+	0x38, 0x44, 0x44, 0x44, 0x28,
+	0x38, 0x44, 0x44, 0x28, 0x7F,
+	0x38, 0x54, 0x54, 0x54, 0x18,
+	0x00, 0x08, 0x7E, 0x09, 0x02,
+	0x18, 0xA4, 0xA4, 0x9C, 0x78,
+	0x7F, 0x08, 0x04, 0x04, 0x78,
+	0x00, 0x44, 0x7D, 0x40, 0x00,
+	0x20, 0x40, 0x40, 0x3D, 0x00,
+	0x7F, 0x10, 0x28, 0x44, 0x00,
+	0x00, 0x41, 0x7F, 0x40, 0x00,
+	0x7C, 0x04, 0x78, 0x04, 0x78,
+	0x7C, 0x08, 0x04, 0x04, 0x78,
+	0x38, 0x44, 0x44, 0x44, 0x38,
+	0xFC, 0x18, 0x24, 0x24, 0x18,
+	0x18, 0x24, 0x24, 0x18, 0xFC,
+	0x7C, 0x08, 0x04, 0x04, 0x08,
+	0x48, 0x54, 0x54, 0x54, 0x24,
+	0x04, 0x04, 0x3F, 0x44, 0x24,
+	0x3C, 0x40, 0x40, 0x20, 0x7C,
+	0x1C, 0x20, 0x40, 0x20, 0x1C,
+	0x3C, 0x40, 0x30, 0x40, 0x3C,
+	0x44, 0x28, 0x10, 0x28, 0x44,
+	0x4C, 0x90, 0x90, 0x90, 0x7C,
+	0x44, 0x64, 0x54, 0x4C, 0x44,
+	0x00, 0x08, 0x36, 0x41, 0x00,
+	0x00, 0x00, 0x77, 0x00, 0x00,
+	0x00, 0x41, 0x36, 0x08, 0x00,
+	0x02, 0x01, 0x02, 0x04, 0x02,
+	0x3C, 0x26, 0x23, 0x26, 0x3C,
+	0x1E, 0xA1, 0xA1, 0x61, 0x12,
+	0x3A, 0x40, 0x40, 0x20, 0x7A,
+	0x38, 0x54, 0x54, 0x55, 0x59,
+	0x21, 0x55, 0x55, 0x79, 0x41,
+	0x22, 0x54, 0x54, 0x78, 0x42, // a-umlaut
+	0x21, 0x55, 0x54, 0x78, 0x40,
+	0x20, 0x54, 0x55, 0x79, 0x40,
+	0x0C, 0x1E, 0x52, 0x72, 0x12,
+	0x39, 0x55, 0x55, 0x55, 0x59,
+	0x39, 0x54, 0x54, 0x54, 0x59,
+	0x39, 0x55, 0x54, 0x54, 0x58,
+	0x00, 0x00, 0x45, 0x7C, 0x41,
+	0x00, 0x02, 0x45, 0x7D, 0x42,
+	0x00, 0x01, 0x45, 0x7C, 0x40,
+	0x7D, 0x12, 0x11, 0x12, 0x7D, // A-umlaut
+	0xF0, 0x28, 0x25, 0x28, 0xF0,
+	0x7C, 0x54, 0x55, 0x45, 0x00,
+	0x20, 0x54, 0x54, 0x7C, 0x54,
+	0x7C, 0x0A, 0x09, 0x7F, 0x49,
+	0x32, 0x49, 0x49, 0x49, 0x32,
+	0x3A, 0x44, 0x44, 0x44, 0x3A, // o-umlaut
+	0x32, 0x4A, 0x48, 0x48, 0x30,
+	0x3A, 0x41, 0x41, 0x21, 0x7A,
+	0x3A, 0x42, 0x40, 0x20, 0x78,
+	0x00, 0x9D, 0xA0, 0xA0, 0x7D,
+	0x3D, 0x42, 0x42, 0x42, 0x3D, // O-umlaut
+	0x3D, 0x40, 0x40, 0x40, 0x3D,
+	0x3C, 0x24, 0xFF, 0x24, 0x24,
+	0x48, 0x7E, 0x49, 0x43, 0x66,
+	0x2B, 0x2F, 0xFC, 0x2F, 0x2B,
+	0xFF, 0x09, 0x29, 0xF6, 0x20,
+	0xC0, 0x88, 0x7E, 0x09, 0x03,
+	0x20, 0x54, 0x54, 0x79, 0x41,
+	0x00, 0x00, 0x44, 0x7D, 0x41,
+	0x30, 0x48, 0x48, 0x4A, 0x32,
+	0x38, 0x40, 0x40, 0x22, 0x7A,
+	0x00, 0x7A, 0x0A, 0x0A, 0x72,
+	0x7D, 0x0D, 0x19, 0x31, 0x7D,
+	0x26, 0x29, 0x29, 0x2F, 0x28,
+	0x26, 0x29, 0x29, 0x29, 0x26,
+	0x30, 0x48, 0x4D, 0x40, 0x20,
+	0x38, 0x08, 0x08, 0x08, 0x08,
+	0x08, 0x08, 0x08, 0x08, 0x38,
+	0x2F, 0x10, 0xC8, 0xAC, 0xBA,
+	0x2F, 0x10, 0x28, 0x34, 0xFA,
+	0x00, 0x00, 0x7B, 0x00, 0x00,
+	0x08, 0x14, 0x2A, 0x14, 0x22,
+	0x22, 0x14, 0x2A, 0x14, 0x08,
+	0x55, 0x00, 0x55, 0x00, 0x55, // #176 (25% block) missing in old code
+	0xAA, 0x55, 0xAA, 0x55, 0xAA, // 50% block
+	0xFF, 0x55, 0xFF, 0x55, 0xFF, // 75% block
+	0x00, 0x00, 0x00, 0xFF, 0x00,
+	0x10, 0x10, 0x10, 0xFF, 0x00,
+	0x14, 0x14, 0x14, 0xFF, 0x00,
+	0x10, 0x10, 0xFF, 0x00, 0xFF,
+	0x10, 0x10, 0xF0, 0x10, 0xF0,
+	0x14, 0x14, 0x14, 0xFC, 0x00,
+	0x14, 0x14, 0xF7, 0x00, 0xFF,
+	0x00, 0x00, 0xFF, 0x00, 0xFF,
+	0x14, 0x14, 0xF4, 0x04, 0xFC,
+	0x14, 0x14, 0x17, 0x10, 0x1F,
+	0x10, 0x10, 0x1F, 0x10, 0x1F,
+	0x14, 0x14, 0x14, 0x1F, 0x00,
+	0x10, 0x10, 0x10, 0xF0, 0x00,
+	0x00, 0x00, 0x00, 0x1F, 0x10,
+	0x10, 0x10, 0x10, 0x1F, 0x10,
+	0x10, 0x10, 0x10, 0xF0, 0x10,
+	0x00, 0x00, 0x00, 0xFF, 0x10,
+	0x10, 0x10, 0x10, 0x10, 0x10,
+	0x10, 0x10, 0x10, 0xFF, 0x10,
+	0x00, 0x00, 0x00, 0xFF, 0x14,
+	0x00, 0x00, 0xFF, 0x00, 0xFF,
+	0x00, 0x00, 0x1F, 0x10, 0x17,
+	0x00, 0x00, 0xFC, 0x04, 0xF4,
+	0x14, 0x14, 0x17, 0x10, 0x17,
+	0x14, 0x14, 0xF4, 0x04, 0xF4,
+	0x00, 0x00, 0xFF, 0x00, 0xF7,
+	0x14, 0x14, 0x14, 0x14, 0x14,
+	0x14, 0x14, 0xF7, 0x00, 0xF7,
+	0x14, 0x14, 0x14, 0x17, 0x14,
+	0x10, 0x10, 0x1F, 0x10, 0x1F,
+	0x14, 0x14, 0x14, 0xF4, 0x14,
+	0x10, 0x10, 0xF0, 0x10, 0xF0,
+	0x00, 0x00, 0x1F, 0x10, 0x1F,
+	0x00, 0x00, 0x00, 0x1F, 0x14,
+	0x00, 0x00, 0x00, 0xFC, 0x14,
+	0x00, 0x00, 0xF0, 0x10, 0xF0,
+	0x10, 0x10, 0xFF, 0x10, 0xFF,
+	0x14, 0x14, 0x14, 0xFF, 0x14,
+	0x10, 0x10, 0x10, 0x1F, 0x00,
+	0x00, 0x00, 0x00, 0xF0, 0x10,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
+	0xFF, 0xFF, 0xFF, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0xFF, 0xFF,
+	0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
+	0x38, 0x44, 0x44, 0x38, 0x44,
+	0xFC, 0x4A, 0x4A, 0x4A, 0x34, // sharp-s or beta
+	0x7E, 0x02, 0x02, 0x06, 0x06,
+	0x02, 0x7E, 0x02, 0x7E, 0x02,
+	0x63, 0x55, 0x49, 0x41, 0x63,
+	0x38, 0x44, 0x44, 0x3C, 0x04,
+	0x40, 0x7E, 0x20, 0x1E, 0x20,
+	0x06, 0x02, 0x7E, 0x02, 0x02,
+	0x99, 0xA5, 0xE7, 0xA5, 0x99,
+	0x1C, 0x2A, 0x49, 0x2A, 0x1C,
+	0x4C, 0x72, 0x01, 0x72, 0x4C,
+	0x30, 0x4A, 0x4D, 0x4D, 0x30,
+	0x30, 0x48, 0x78, 0x48, 0x30,
+	0xBC, 0x62, 0x5A, 0x46, 0x3D,
+	0x3E, 0x49, 0x49, 0x49, 0x00,
+	0x7E, 0x01, 0x01, 0x01, 0x7E,
+	0x2A, 0x2A, 0x2A, 0x2A, 0x2A,
+	0x44, 0x44, 0x5F, 0x44, 0x44,
+	0x40, 0x51, 0x4A, 0x44, 0x40,
+	0x40, 0x44, 0x4A, 0x51, 0x40,
+	0x00, 0x00, 0xFF, 0x01, 0x03,
+	0xE0, 0x80, 0xFF, 0x00, 0x00,
+	0x08, 0x08, 0x6B, 0x6B, 0x08,
+	0x36, 0x12, 0x36, 0x24, 0x36,
+	0x06, 0x0F, 0x09, 0x0F, 0x06,
+	0x00, 0x00, 0x18, 0x18, 0x00,
+	0x00, 0x00, 0x10, 0x10, 0x00,
+	0x30, 0x40, 0xFF, 0x01, 0x01,
+	0x00, 0x1F, 0x01, 0x01, 0x1E,
+	0x00, 0x19, 0x1D, 0x17, 0x12,
+	0x00, 0x3C, 0x3C, 0x3C, 0x3C,
+	0x00, 0x00, 0x00, 0x00, 0x00  // #255 NBSP
+};
+#endif // FONT5X7_H
diff --git a/source/sharp/license.txt b/source/sharp/license.txt
new file mode 100644
index 0000000..7492e93
--- /dev/null
+++ b/source/sharp/license.txt
@@ -0,0 +1,24 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2012 Adafruit Industries.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.