add U8glib library to Arduino1.x includes

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_bitmap.c

@@ -0,0 +1,177 @@
+/*
+
+  u8g_bitmap.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+void u8g_DrawHBitmap(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, const uint8_t *bitmap)
+{
+  while( cnt > 0 )
+  {
+    u8g_Draw8Pixel(u8g, x, y, 0, *bitmap);
+    bitmap++;
+    cnt--;
+    x+=8;
+  }
+}
+
+void u8g_DrawBitmap(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, u8g_uint_t h, const uint8_t *bitmap)
+{
+  if ( u8g_IsBBXIntersection(u8g, x, y, cnt*8, h) == 0 )
+    return;
+  while( h > 0 )
+  {
+    u8g_DrawHBitmap(u8g, x, y, cnt, bitmap);
+    bitmap += cnt;
+    y++;
+    h--;
+  }
+}
+
+
+void u8g_DrawHBitmapP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, const u8g_pgm_uint8_t *bitmap)
+{
+  while( cnt > 0 )
+  {
+    u8g_Draw8Pixel(u8g, x, y, 0, u8g_pgm_read(bitmap));
+    bitmap++;
+    cnt--;
+    x+=8;
+  }
+}
+
+void u8g_DrawBitmapP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t cnt, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap)
+{
+  if ( u8g_IsBBXIntersection(u8g, x, y, cnt*8, h) == 0 )
+    return;
+  while( h > 0 )
+  {
+    u8g_DrawHBitmapP(u8g, x, y, cnt, bitmap);
+    bitmap += cnt;
+    y++;
+    h--;
+  }
+}
+
+/*=========================================================================*/
+
+static void u8g_DrawHXBM(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, const uint8_t *bitmap)
+{
+  uint8_t d;
+  x+=7;
+  while( w >= 8 )
+  {
+    u8g_Draw8Pixel(u8g, x, y, 2, *bitmap);
+    bitmap++;
+    w-= 8;
+    x+=8;
+  }
+  if ( w > 0 )
+  {
+    d = *bitmap;
+    x -= 7;
+    do
+    {
+      if ( d & 1 )
+        u8g_DrawPixel(u8g, x, y);
+      x++;
+      w--;
+      d >>= 1;      
+    } while ( w > 0 );
+  }
+}
+
+void u8g_DrawXBM(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const uint8_t *bitmap)
+{
+  u8g_uint_t b;
+  b = w;
+  b += 7;
+  b >>= 3;
+  
+  if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 )
+    return;
+  
+  while( h > 0 )
+  {
+    u8g_DrawHXBM(u8g, x, y, w, bitmap);
+    bitmap += b;
+    y++;
+    h--;
+  }
+}
+
+static void u8g_DrawHXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, const u8g_pgm_uint8_t *bitmap)
+{
+  uint8_t d;
+  x+=7;
+  while( w >= 8 )
+  {
+    u8g_Draw8Pixel(u8g, x, y, 2, u8g_pgm_read(bitmap));
+    bitmap++;
+    w-= 8;
+    x+=8;
+  }
+  if ( w > 0 )
+  {
+    d = u8g_pgm_read(bitmap);
+    x -= 7;
+    do
+    {
+      if ( d & 1 )
+        u8g_DrawPixel(u8g, x, y);
+      x++;
+      w--;
+      d >>= 1;      
+    } while ( w > 0 );
+  }
+}
+
+void u8g_DrawXBMP(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, const u8g_pgm_uint8_t *bitmap)
+{
+  u8g_uint_t b;
+  b = w;
+  b += 7;
+  b >>= 3;
+  
+  if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 )
+    return;
+  while( h > 0 )
+  {
+    u8g_DrawHXBMP(u8g, x, y, w, bitmap);
+    bitmap += b;
+    y++;
+    h--;
+  }
+}

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_circle.c

@@ -0,0 +1,382 @@
+/*
+
+  u8g_circle.c
+
+  Utility to draw empty and filled circles.
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, bjthom@gmail.com
+  u8g_DrawCircle & u8g_DrawDisc by olikraus@gmail.com
+  
+  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.  
+  
+  Addition to the U8G Library 02/25/12
+  
+  
+*/
+
+#include "u8g.h"
+
+#ifdef OLD_CODE
+
+void circ_upperRight(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
+  u8g_DrawPixel(u8g, x0 + x, y0 - y);
+  u8g_DrawPixel(u8g, x0 + y, y0 - x);
+}
+		
+void circ_upperLeft(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
+  u8g_DrawPixel(u8g, x0 - x, y0 - y);
+  u8g_DrawPixel(u8g, x0 - y, y0 - x);
+}
+		
+void circ_lowerRight(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
+  u8g_DrawPixel(u8g, x0 + x, y0 + y);
+  u8g_DrawPixel(u8g, x0 + y, y0 + x);
+}
+		
+void circ_lowerLeft(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
+  u8g_DrawPixel(u8g, x0 - x, y0 + y);
+  u8g_DrawPixel(u8g, x0 - y, y0 + x);
+}
+			
+void circ_all(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0) {
+  circ_upperRight(u8g, x, y, x0, y0);
+  circ_upperLeft(u8g, x, y, x0, y0);
+  circ_lowerRight(u8g, x, y, x0, y0);
+  circ_lowerLeft(u8g, x, y, x0, y0);
+}
+
+void u8g_DrawEmpCirc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option)
+{
+  if ( u8g_IsBBXIntersection(u8g, x0-rad-1, y0-rad-1, 2*rad+1, 2*rad+1) == 0)
+    return;
+
+  int f = 1 - rad;
+  int ddF_x = 1;
+  int ddF_y = -2*rad;
+  uint8_t x = 0;
+  uint8_t y = rad;
+
+  void ( *circ_util )(u8g_t *, u8g_uint_t, u8g_uint_t, u8g_uint_t, u8g_uint_t);
+  
+  switch (option)
+  {
+	case U8G_CIRC_UPPER_RIGHT:
+		u8g_DrawPixel(u8g, x0, y0 - rad);
+		u8g_DrawPixel(u8g, x0 + rad, y0);
+		circ_util = circ_upperRight;
+		break;
+	case U8G_CIRC_UPPER_LEFT:
+		u8g_DrawPixel(u8g, x0, y0 - rad);
+		u8g_DrawPixel(u8g, x0 - rad, y0);
+		circ_util = circ_upperLeft;
+		break;
+	case U8G_CIRC_LOWER_RIGHT:
+		u8g_DrawPixel(u8g, x0, y0 + rad);
+		u8g_DrawPixel(u8g, x0 + rad, y0);
+		circ_util = circ_lowerRight;
+		break;
+	case U8G_CIRC_LOWER_LEFT:
+		u8g_DrawPixel(u8g, x0, y0 + rad);
+		u8g_DrawPixel(u8g, x0 - rad, y0);
+		circ_util = circ_lowerLeft;
+		break;
+        default:
+	case U8G_CIRC_ALL:
+		u8g_DrawPixel(u8g, x0, y0 + rad);
+		u8g_DrawPixel(u8g, x0, y0 - rad);
+		u8g_DrawPixel(u8g, x0 + rad, y0);
+		u8g_DrawPixel(u8g, x0 - rad, y0);
+		circ_util = circ_all;
+		break;
+  }
+  
+  while( x < y )
+  {
+    if(f >= 0) 
+    {
+      y--;
+      ddF_y += 2;
+      f += ddF_y;
+    }
+    x++;
+    ddF_x += 2;
+    f += ddF_x;
+    
+    circ_util(u8g, x, y, x0, y0);
+  }
+}
+
+
+void u8g_DrawFillCirc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option)
+{
+  if ( u8g_IsBBXIntersection(u8g, x0-rad-1, y0-rad-1, 2*rad+1, 2*rad+1) == 0)
+    return;
+
+  int f = 1 - rad;
+  int ddF_x = 1;
+  int ddF_y = -2*rad;
+  uint8_t x = 0;
+  uint8_t y = rad;
+  
+  // Draw vertical diameter at the horiz. center
+  // u8g_DrawVLine(u8g, x0, y0 - rad, 2*rad+1);
+
+  if (option == U8G_CIRC_UPPER_LEFT || option == U8G_CIRC_UPPER_RIGHT) {
+	u8g_DrawVLine(u8g, x0, y0 - rad, rad+1);
+  }
+  else if (option == U8G_CIRC_LOWER_LEFT || option == U8G_CIRC_LOWER_RIGHT) {
+	u8g_DrawVLine(u8g, x0, y0, rad+1);
+  }
+  else {
+	u8g_DrawVLine(u8g, x0, y0 - rad, 2*rad+1);
+  }
+  
+  while( x < y )
+  {
+    if(f >= 0) 
+    {
+      y--;
+      ddF_y += 2;
+      f += ddF_y;
+    }
+    x++;
+    ddF_x += 2;
+    f += ddF_x;
+    
+	//Draw vertical lines from one point to another
+	
+	switch (option)
+	{
+		case U8G_CIRC_UPPER_RIGHT:
+			u8g_DrawVLine(u8g, x0+x, y0-y, y+1);
+			u8g_DrawVLine(u8g, x0+y, y0-x, x+1);
+			break;
+		case U8G_CIRC_UPPER_LEFT:
+			u8g_DrawVLine(u8g, x0-x, y0-y, y+1);
+			u8g_DrawVLine(u8g, x0-y, y0-x, x+1);
+			break;
+		case U8G_CIRC_LOWER_RIGHT:
+			u8g_DrawVLine(u8g, x0+x, y0, y+1);
+			u8g_DrawVLine(u8g, x0+y, y0, x+1);
+			break;
+		case U8G_CIRC_LOWER_LEFT:
+			u8g_DrawVLine(u8g, x0-x, y0, y+1);
+			u8g_DrawVLine(u8g, x0-y, y0, x+1);
+			break;
+		case U8G_CIRC_ALL:
+			u8g_DrawVLine(u8g, x0+x, y0-y, 2*y+1);
+			u8g_DrawVLine(u8g, x0-x, y0-y, 2*y+1);
+			u8g_DrawVLine(u8g, x0+y, y0-x, 2*x+1);
+			u8g_DrawVLine(u8g, x0-y, y0-x, 2*x+1);
+			break;
+	}
+  }
+}
+
+#endif 
+
+/*=========================================================================*/
+
+static void u8g_draw_circle_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option) U8G_NOINLINE;
+
+static void u8g_draw_circle_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option)
+{
+    /* upper right */
+    if ( option & U8G_DRAW_UPPER_RIGHT )
+    {
+      u8g_DrawPixel(u8g, x0 + x, y0 - y);
+      u8g_DrawPixel(u8g, x0 + y, y0 - x);
+    }
+    
+    /* upper left */
+    if ( option & U8G_DRAW_UPPER_LEFT )
+    {
+      u8g_DrawPixel(u8g, x0 - x, y0 - y);
+      u8g_DrawPixel(u8g, x0 - y, y0 - x);
+    }
+    
+    /* lower right */
+    if ( option & U8G_DRAW_LOWER_RIGHT )
+    {
+      u8g_DrawPixel(u8g, x0 + x, y0 + y);
+      u8g_DrawPixel(u8g, x0 + y, y0 + x);
+    }
+    
+    /* lower left */
+    if ( option & U8G_DRAW_LOWER_LEFT )
+    {
+      u8g_DrawPixel(u8g, x0 - x, y0 + y);
+      u8g_DrawPixel(u8g, x0 - y, y0 + x);
+    }
+}
+
+void u8g_draw_circle(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option)
+{
+    u8g_int_t f;
+    u8g_int_t ddF_x;
+    u8g_int_t ddF_y;
+    u8g_uint_t x;
+    u8g_uint_t y;
+
+    f = 1;
+    f -= rad;
+    ddF_x = 1;
+    ddF_y = 0;
+    ddF_y -= rad;
+    ddF_y *= 2;
+    x = 0;
+    y = rad;
+
+    u8g_draw_circle_section(u8g, x, y, x0, y0, option);
+    
+    while ( x < y )
+    {
+      if (f >= 0) 
+      {
+        y--;
+        ddF_y += 2;
+        f += ddF_y;
+      }
+      x++;
+      ddF_x += 2;
+      f += ddF_x;
+
+      u8g_draw_circle_section(u8g, x, y, x0, y0, option);    
+    }
+}
+
+void u8g_DrawCircle(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option)
+{
+  /* check for bounding box */
+  {
+    u8g_uint_t radp, radp2;
+    
+    radp = rad;
+    radp++;
+    radp2 = radp;
+    radp2 *= 2;
+    
+    if ( u8g_IsBBXIntersection(u8g, x0-radp, y0-radp, radp2, radp2) == 0)
+      return;    
+  }
+  
+  /* draw circle */
+  u8g_draw_circle(u8g, x0, y0, rad, option);
+}
+
+static void u8g_draw_disc_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option) U8G_NOINLINE;
+
+static void u8g_draw_disc_section(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t x0, u8g_uint_t y0, uint8_t option)
+{
+    /* upper right */
+    if ( option & U8G_DRAW_UPPER_RIGHT )
+    {
+      u8g_DrawVLine(u8g, x0+x, y0-y, y+1);
+      u8g_DrawVLine(u8g, x0+y, y0-x, x+1);
+    }
+    
+    /* upper left */
+    if ( option & U8G_DRAW_UPPER_LEFT )
+    {
+      u8g_DrawVLine(u8g, x0-x, y0-y, y+1);
+      u8g_DrawVLine(u8g, x0-y, y0-x, x+1);
+    }
+    
+    /* lower right */
+    if ( option & U8G_DRAW_LOWER_RIGHT )
+    {
+      u8g_DrawVLine(u8g, x0+x, y0, y+1);
+      u8g_DrawVLine(u8g, x0+y, y0, x+1);
+    }
+    
+    /* lower left */
+    if ( option & U8G_DRAW_LOWER_LEFT )
+    {
+      u8g_DrawVLine(u8g, x0-x, y0, y+1);
+      u8g_DrawVLine(u8g, x0-y, y0, x+1);
+    }
+}
+
+void u8g_draw_disc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option)
+{
+  u8g_int_t f;
+  u8g_int_t ddF_x;
+  u8g_int_t ddF_y;
+  u8g_uint_t x;
+  u8g_uint_t y;
+
+  f = 1;
+  f -= rad;
+  ddF_x = 1;
+  ddF_y = 0;
+  ddF_y -= rad;
+  ddF_y *= 2;
+  x = 0;
+  y = rad;
+
+  u8g_draw_disc_section(u8g, x, y, x0, y0, option);
+  
+  while ( x < y )
+  {
+    if (f >= 0) 
+    {
+      y--;
+      ddF_y += 2;
+      f += ddF_y;
+    }
+    x++;
+    ddF_x += 2;
+    f += ddF_x;
+
+    u8g_draw_disc_section(u8g, x, y, x0, y0, option);    
+  }
+}
+
+void u8g_DrawDisc(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rad, uint8_t option)
+{
+  /* check for bounding box */
+  {
+    u8g_uint_t radp, radp2;
+    
+    radp = rad;
+    radp++;
+    radp2 = radp;
+    radp2 *= 2;
+    
+    if ( u8g_IsBBXIntersection(u8g, x0-radp, y0-radp, radp2, radp2) == 0)
+      return;    
+  }
+  
+  /* draw disc */
+  u8g_draw_disc(u8g, x0, y0, rad, option);
+}
+
+
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_clip.c

@@ -0,0 +1,156 @@
+/*
+
+  u8g_clip.c
+  
+  procedures for clipping
+  taken over from procs in u8g_pb.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+  Notes
+  
+  This is one of the most critical parts of u8glib. It must be fast, but still reliable.
+  Based on the intersection program (see tools folder), there is minimized version of
+  the condition for the intersaction test:
+    minimized version
+    ---1----0 1             b1 <= a2 && b1 > b2
+    -----1--0 1             b2 >= a1 && b1 > b2
+    ---1-1--- 1             b1 <= a2 && b2 >= a1
+  It includes the assumption, that a1 <= a2 is always true (correct, because
+  a1, a2 are the page dimensions.
+
+  The direct implementation of the above result is done in:
+  uint8_t u8g_is_intersection_boolean(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1)
+  However, this is slower than a decision tree version:  
+  static uint8_t u8g_is_intersection_decision_tree(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1) 
+  Also suprising is, that he the macro implementation is slower than the inlined version.
+  
+  The decision tree is based on the expansion of the truth table.
+  
+*/
+
+#include "u8g.h"
+
+#ifdef __GNUC__
+#define U8G_ALWAYS_INLINE __attribute__((always_inline))
+#else
+#define U8G_ALWAYS_INLINE
+ #endif 
+
+/*
+  intersection assumptions:
+    a1 <= a2 is always true    
+    
+    minimized version
+    ---1----0 1             b1 <= a2 && b1 > b2
+    -----1--0 1             b2 >= a1 && b1 > b2
+    ---1-1--- 1             b1 <= a2 && b2 >= a1
+  */
+
+#ifdef OLD_CODE_WHICH_IS_TOO_SLOW
+static uint8_t u8g_is_intersection_boolean(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1)
+{
+  uint8_t c1, c2, c3, tmp;
+  c1 = v0 <= a1;
+  c2 = v1 >= a0;
+  c3 = v0 > v1;
+  
+  tmp = c1;
+  c1 &= c2;
+  c2 &= c3;
+  c3 &= tmp;
+  c1 |= c2;
+  c1 |= c3;
+  return c1 & 1;
+}
+#endif
+
+#define U8G_IS_INTERSECTION_MACRO(a0,a1,v0,v1) ((uint8_t)( (v0) <= (a1) ) ? ( ( (v1) >= (a0) ) ? ( 1 ) : ( (v0) > (v1) ) ) : ( ( (v1) >= (a0) ) ? ( (v0) > (v1) ) : ( 0 ) ))
+
+static uint8_t u8g_is_intersection_decision_tree(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1)  U8G_ALWAYS_INLINE;
+static uint8_t u8g_is_intersection_decision_tree(u8g_uint_t a0, u8g_uint_t a1, u8g_uint_t v0, u8g_uint_t v1) 
+{
+  /* surprisingly the macro leads to larger code */
+  /* return U8G_IS_INTERSECTION_MACRO(a0,a1,v0,v1); */
+  if ( v0 <= a1 )
+  {
+    if ( v1 >= a0 )
+    {
+      return 1;
+    }
+    else
+    {
+      if ( v0 > v1 )
+      {
+	return 1;
+      }
+      else
+      {
+	return 0;
+      }
+    }
+  }
+  else
+  {
+    if ( v1 >= a0 )
+    {
+      if ( v0 > v1 )
+      {
+	return 1;
+      }
+      else
+      {
+	return 0;
+      }
+    }
+    else
+    {
+      return 0;
+    }
+  }
+}
+
+
+uint8_t u8g_IsBBXIntersection(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h)
+{
+  register u8g_uint_t tmp;
+  tmp = y;
+  tmp += h;
+  tmp--;
+  if ( u8g_is_intersection_decision_tree(u8g->current_page.y0, u8g->current_page.y1, y, tmp) == 0 )
+    return 0; 
+  
+  tmp = x;
+  tmp += w;
+  tmp--;
+  return u8g_is_intersection_decision_tree(u8g->current_page.x0, u8g->current_page.x1, x, tmp);
+}
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_api.c

@@ -0,0 +1,173 @@
+/*
+
+  u8g_com_api.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+uint8_t u8g_InitCom(u8g_t *u8g, u8g_dev_t *dev)
+{
+  return dev->com_fn(u8g, U8G_COM_MSG_INIT, 0, NULL);
+}
+
+void u8g_StopCom(u8g_t *u8g, u8g_dev_t *dev)
+{
+  dev->com_fn(u8g, U8G_COM_MSG_STOP, 0, NULL);
+}
+
+/* cs contains the chip number, which should be enabled */
+void u8g_SetChipSelect(u8g_t *u8g, u8g_dev_t *dev, uint8_t cs)
+{
+  dev->com_fn(u8g, U8G_COM_MSG_CHIP_SELECT, cs, NULL);
+}
+
+void u8g_SetResetLow(u8g_t *u8g, u8g_dev_t *dev)
+{
+  dev->com_fn(u8g, U8G_COM_MSG_RESET, 0, NULL);
+}
+
+void u8g_SetResetHigh(u8g_t *u8g, u8g_dev_t *dev)
+{
+  dev->com_fn(u8g, U8G_COM_MSG_RESET, 1, NULL);
+}
+
+
+void u8g_SetAddress(u8g_t *u8g, u8g_dev_t *dev, uint8_t address)
+{
+  dev->com_fn(u8g, U8G_COM_MSG_ADDRESS, address, NULL);
+}
+
+uint8_t u8g_WriteByte(u8g_t *u8g, u8g_dev_t *dev, uint8_t val)
+{
+  return dev->com_fn(u8g, U8G_COM_MSG_WRITE_BYTE, val, NULL);
+}
+
+uint8_t u8g_WriteSequence(u8g_t *u8g, u8g_dev_t *dev, uint8_t cnt, uint8_t *seq)
+{
+  return dev->com_fn(u8g, U8G_COM_MSG_WRITE_SEQ, cnt, seq);
+}
+
+uint8_t u8g_WriteSequenceP(u8g_t *u8g, u8g_dev_t *dev, uint8_t cnt, const uint8_t *seq)
+{
+  return dev->com_fn(u8g, U8G_COM_MSG_WRITE_SEQ_P, cnt, (void *)seq);
+}
+
+/*
+  sequence := { direct_value | escape_sequence }
+  direct_value := 0..254
+  escape_sequence := value_255 | sequence_end | delay | adr | cs | not_used 
+  value_255 := 255 255
+  sequence_end = 255 254
+  delay := 255 0..127
+  adr := 255 0x0e0 .. 0x0ef 
+  cs := 255 0x0d0 .. 0x0df 
+  not_used := 255 101..254
+
+#define U8G_ESC_DLY(x) 255, ((x) & 0x7f)
+#define U8G_ESC_CS(x) 255, (0xd0 | ((x)&0x0f))
+#define U8G_ESC_ADR(x) 255, (0xe0 | ((x)&0x0f))
+#define U8G_ESC_VCC(x) 255, (0xbe | ((x)&0x01))
+#define U8G_ESC_END 255, 254
+#define U8G_ESC_255 255, 255
+#define U8G_ESC_RST(x) 255, (0xc0 | ((x)&0x0f))
+
+*/
+uint8_t u8g_WriteEscSeqP(u8g_t *u8g, u8g_dev_t *dev, const uint8_t *esc_seq)
+{
+  uint8_t is_escape = 0;
+  uint8_t value;
+  for(;;)
+  {
+    value = u8g_pgm_read(esc_seq);
+    if ( is_escape == 0 )
+    {
+      if ( value != 255 )
+      {
+        if ( u8g_WriteByte(u8g, dev, value) == 0 )
+          return 0;
+      }
+      else
+      {
+        is_escape = 1;
+      }
+    }
+    else
+    {
+      if ( value == 255 )
+      {
+        if ( u8g_WriteByte(u8g, dev, value) == 0 )
+          return 0;
+      }
+      else if ( value == 254 )
+      {
+        break;
+      }
+      else if ( value >= 0x0f0 )
+      {
+        /* not yet used, do nothing */
+      }
+      else if ( value >= 0xe0  )
+      {
+        u8g_SetAddress(u8g, dev, value & 0x0f);
+      }
+      else if ( value >= 0xd0 )
+      {
+        u8g_SetChipSelect(u8g, dev, value & 0x0f);
+      }
+      else if ( value >= 0xc0 )
+      {
+        u8g_SetResetLow(u8g, dev);
+        value &= 0x0f;
+        value <<= 4;
+        value+=2;
+        u8g_Delay(value);
+        u8g_SetResetHigh(u8g, dev);
+        u8g_Delay(value);
+      }
+      else if ( value >= 0xbe )
+      {
+	/* not yet implemented */
+        /* u8g_SetVCC(u8g, dev, value & 0x01); */
+      }
+      else if ( value <= 127 )
+      {
+        u8g_Delay(value);
+      }
+      is_escape = 0;
+    }
+    esc_seq++;
+  }
+  return 1;
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_api_16gr.c

@@ -0,0 +1,94 @@
+/*
+
+  u8g_com_api_16gr.c
+  
+  Extension of the com api for devices with 16 graylevels (4 bit per pixel).
+  This should fit to the 8h and 16h architectures (pb8v1, pb8v2, pb16v1, pb16v2), 
+  mainly intended for SSD OLEDs
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+/* interpret b as a monochrome bit pattern, write value 15 for high bit and value 0 for a low bit */
+/* topbit (msb) is sent last */
+/* example: b = 0x083 will send 0xff, 0x00, 0x00, 0xf0 */
+uint8_t u8g_WriteByteBWTo16GrDevice(u8g_t *u8g, u8g_dev_t *dev, uint8_t b)
+{
+  static uint8_t buf[4];
+  static uint8_t map[4] = { 0, 0x00f, 0x0f0, 0x0ff };
+  buf [3] = map[b & 3];
+  b>>=2;
+  buf [2] = map[b & 3];
+  b>>=2;
+  buf [1] = map[b & 3];
+  b>>=2;
+  buf [0] = map[b & 3];
+  return dev->com_fn(u8g, U8G_COM_MSG_WRITE_SEQ, 4, buf);
+}
+
+uint8_t u8g_WriteSequenceBWTo16GrDevice(u8g_t *u8g, u8g_dev_t *dev, uint8_t cnt, uint8_t *ptr)
+{
+  do
+  {
+    if ( u8g_WriteByteBWTo16GrDevice(u8g, dev, *ptr++) == 0 )
+      return 0;
+    cnt--;
+  } while( cnt != 0 );
+  return 1;
+}
+
+/* interpret b as a 4L bit pattern, write values 0x000, 0x004, 0x008, 0x00c */
+uint8_t u8g_WriteByte4LTo16GrDevice(u8g_t *u8g, u8g_dev_t *dev, uint8_t b)
+{
+  //static uint8_t map[16] = { 0x000, 0x004, 0x008, 0x00c, 0x040, 0x044, 0x048, 0x04c, 0x080, 0x084, 0x088, 0x08c, 0x0c0, 0x0c4, 0x0c8, 0x0cc};
+  //static uint8_t map[16] = { 0x000, 0x004, 0x00a, 0x00f, 0x040, 0x044, 0x04a, 0x04f, 0x0a0, 0x0a4, 0x0aa, 0x0af, 0x0f0, 0x0f4, 0x0fa, 0x0ff};
+  static uint8_t map[16] = { 0x000, 0x040, 0x0a0, 0x0f0, 0x004, 0x044, 0x0a4, 0x0f4, 0x00a, 0x04a, 0x0aa, 0x0fa, 0x00f, 0x04f, 0x0af, 0x0ff};
+  uint8_t bb;
+  bb = b;
+  bb &= 15;
+  b>>=4;
+  dev->com_fn(u8g, U8G_COM_MSG_WRITE_BYTE, map[bb], NULL);
+  return dev->com_fn(u8g, U8G_COM_MSG_WRITE_BYTE, map[b], NULL);
+}
+
+uint8_t u8g_WriteSequence4LTo16GrDevice(u8g_t *u8g, u8g_dev_t *dev, uint8_t cnt, uint8_t *ptr)
+{
+  do
+  {
+    if ( u8g_WriteByte4LTo16GrDevice(u8g, dev, *ptr++) == 0 )
+      return 0;
+    cnt--;
+  } while( cnt != 0 );
+  return 1;
+}

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_common.c

@@ -0,0 +1,75 @@
+/*
+  
+  u8g_com_arduino_common.c
+  
+  shared procedures for the arduino communication procedures
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#if defined(ARDUINO)
+
+#if ARDUINO < 100 
+#include <WProgram.h> 
+#else 
+#include <Arduino.h> 
+#endif
+
+void u8g_com_arduino_digital_write(u8g_t *u8g, uint8_t pin_index, uint8_t value)
+{
+  uint8_t pin;
+  pin = u8g->pin_list[pin_index];
+  if ( pin != U8G_PIN_NONE )
+    digitalWrite(pin, value);
+}
+
+/* this procedure does not set the RW pin */
+void u8g_com_arduino_assign_pin_output_high(u8g_t *u8g)
+{
+  uint8_t i;
+  /* skip the RW pin, which is the last pin in the list */
+  for( i = 0; i < U8G_PIN_LIST_LEN-1; i++ )
+  {
+    if ( u8g->pin_list[i] != U8G_PIN_NONE )
+    {
+      pinMode(u8g->pin_list[i], OUTPUT);	
+      digitalWrite(u8g->pin_list[i], HIGH);
+    }
+  }
+}
+
+
+#endif
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_fast_parallel.c

@@ -0,0 +1,245 @@
+/*
+  
+  u8g_arduino_fast_parallel.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+  PIN_D0 8
+  PIN_D1 9
+  PIN_D2 10
+  PIN_D3 11
+  PIN_D4 4
+  PIN_D5 5
+  PIN_D6 6
+  PIN_D7 7
+
+  PIN_CS1 14
+  PIN_CS2 15
+  PIN_RW 16
+  PIN_DI 17
+  PIN_EN 18
+  
+  u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset)
+  u8g_Init8Bit(u8g, dev,  8,    9, 10, 11,   4,   5,   6,   7, 18, 14, 15, 17, 16, U8G_PIN_NONE)
+
+*/
+
+#include "u8g.h"
+
+#if  defined(ARDUINO)
+
+#if ARDUINO < 100 
+//#include <WProgram.h> 
+#include <wiring_private.h> 
+#include <pins_arduino.h> 
+#else 
+#include <Arduino.h> 
+#endif
+
+
+#define PIN_D0 8
+#define PIN_D1 9
+#define PIN_D2 10
+#define PIN_D3 11
+#define PIN_D4 4
+#define PIN_D5 5
+#define PIN_D6 6
+#define PIN_D7 7
+
+#define PIN_CS1 14
+#define PIN_CS2 15
+#define PIN_RW 16
+#define PIN_DI 17
+#define PIN_EN 18
+
+//#define PIN_RESET
+
+
+#if defined(__PIC32MX)
+/* CHIPKIT PIC32 */
+static volatile uint32_t *u8g_data_port[8];
+static uint32_t u8g_data_mask[8];
+#else
+static volatile uint8_t *u8g_data_port[8];
+static uint8_t u8g_data_mask[8];
+#endif
+
+
+
+static void u8g_com_arduino_fast_parallel_init(u8g_t *u8g)
+{
+  u8g_data_port[0] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0]));
+  u8g_data_mask[0] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D0]);
+  u8g_data_port[1] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1]));
+  u8g_data_mask[1] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D1]);
+  u8g_data_port[2] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2]));
+  u8g_data_mask[2] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D2]);
+  u8g_data_port[3] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3]));
+  u8g_data_mask[3] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D3]);
+  
+  u8g_data_port[4] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4]));
+  u8g_data_mask[4] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D4]);
+  u8g_data_port[5] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5]));
+  u8g_data_mask[5] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D5]);
+  u8g_data_port[6] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6]));
+  u8g_data_mask[6] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D6]);
+  u8g_data_port[7] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7]));
+  u8g_data_mask[7] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D7]);  
+}
+
+void u8g_com_arduino_fast_write_data_pin(uint8_t pin, uint8_t val)
+{
+  if ( val != 0 )
+    *u8g_data_port[pin] |= u8g_data_mask[pin];
+  else
+    *u8g_data_port[pin] &= ~u8g_data_mask[pin];
+}
+
+
+void u8g_com_arduino_fast_parallel_write(u8g_t *u8g, uint8_t val)
+{
+  u8g_com_arduino_fast_write_data_pin( 0, val&1 );
+  val >>= 1;
+  u8g_com_arduino_fast_write_data_pin( 1, val&1 );
+  val >>= 1;
+  u8g_com_arduino_fast_write_data_pin( 2, val&1 );
+  val >>= 1;
+  u8g_com_arduino_fast_write_data_pin( 3, val&1 );
+  val >>= 1;
+
+  u8g_com_arduino_fast_write_data_pin( 4, val&1 );
+  val >>= 1;
+  u8g_com_arduino_fast_write_data_pin( 5, val&1 );
+  val >>= 1;
+  u8g_com_arduino_fast_write_data_pin( 6, val&1 );
+  val >>= 1;
+  u8g_com_arduino_fast_write_data_pin( 7, val&1 );
+  val >>= 1;
+  
+  /* EN cycle time must be 1 micro second */
+  u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH);
+  u8g_MicroDelay(); /* delay by 1000ns, reference: ST7920: 140ns, SBN1661: 100ns */
+  u8g_com_arduino_digital_write(u8g, U8G_PI_EN, LOW);
+  u8g_10MicroDelay(); /* ST7920 commands: 72us */
+  u8g_10MicroDelay(); /* ST7920 commands: 72us */
+}
+
+
+uint8_t u8g_com_arduino_fast_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_com_arduino_fast_parallel_init(u8g);
+      /* setup the RW pin as output and force it to low */
+      if ( u8g->pin_list[U8G_PI_RW] != U8G_PIN_NONE )
+      {
+        pinMode(u8g->pin_list[U8G_PI_RW], OUTPUT);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RW, LOW);
+      }
+      /* set all pins (except RW pin) */
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      break;
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH);
+      }
+      else if ( arg_val == 1 )
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH);
+      }
+      else if ( arg_val == 2 )
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW);
+      }
+      else
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW);
+      }
+      break;
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_arduino_fast_parallel_write(u8g, arg_val);
+      break;
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_fast_parallel_write(u8g, *ptr++);
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_fast_parallel_write(u8g, u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val);
+      break;
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+      
+  }
+  return 1;
+}
+
+#else
+
+
+uint8_t u8g_com_arduino_fast_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_hw_spi.c

@@ -0,0 +1,191 @@
+/*
+  
+  u8g_com_arduino_hw_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#if defined(ARDUINO)
+
+#if defined(__AVR__)
+
+#include <avr/interrupt.h>
+#include <avr/io.h>
+
+#if ARDUINO < 100 
+#include <WProgram.h> 
+
+/* fixed pins */
+#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__) // Sanguino.cc board
+#define PIN_SCK         7
+#define PIN_MISO        6
+#define PIN_MOSI        5
+#define PIN_CS          4
+#else                                   // Arduino Board
+#define PIN_SCK 13
+#define PIN_MISO  12
+#define PIN_MOSI 11
+#define PIN_CS 10
+#endif // (__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__)
+
+#else 
+
+#include <Arduino.h> 
+
+/* use Arduino pin definitions */
+#define PIN_SCK SCK
+#define PIN_MISO  MISO
+#define PIN_MOSI MOSI
+#define PIN_CS SS
+
+#endif
+
+
+
+//static uint8_t u8g_spi_out(uint8_t data) U8G_NOINLINE;
+static uint8_t u8g_spi_out(uint8_t data)
+{
+  /* unsigned char x = 100; */
+  /* send data */
+  SPDR = data;
+  /* wait for transmission */
+  while (!(SPSR & (1<<SPIF))) 
+    ;
+  /* clear the SPIF flag by reading SPDR */
+  return  SPDR;
+}
+
+
+uint8_t u8g_com_arduino_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_STOP:
+      break;
+    
+    case U8G_COM_MSG_INIT:
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      pinMode(PIN_SCK, OUTPUT);
+      digitalWrite(PIN_SCK, LOW);
+      pinMode(PIN_MOSI, OUTPUT);
+      digitalWrite(PIN_MOSI, LOW);
+      /* pinMode(PIN_MISO, INPUT); */
+
+      pinMode(PIN_CS, OUTPUT);			/* system chip select for the atmega board */
+      digitalWrite(PIN_CS, HIGH);
+    
+
+
+      /*
+        SPR1 SPR0
+            0	0		fclk/4
+            0	1		fclk/16
+            1	0		fclk/64
+            1	1		fclk/128
+      */
+      SPCR = 0;
+      SPCR =  (1<<SPE) | (1<<MSTR)|(0<<SPR1)|(1<<SPR0)|(0<<CPOL)|(0<<CPHA);
+#ifdef U8G_HW_SPI_2X
+      SPSR = (1 << SPI2X);  /* double speed, issue 89 */
+#endif
+      
+      break;
+    
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_com_arduino_digital_write(u8g, U8G_PI_A0, arg_val);
+      break;
+
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
+      }
+      else
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
+      }
+      break;
+      
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_spi_out(arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_spi_out(*ptr++);
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_spi_out(u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+  }
+  return 1;
+}
+
+/* #elif defined(__18CXX) || defined(__PIC32MX) */
+
+#else /* __AVR__ */
+
+#endif /* __AVR__ */
+
+#else /* ARDUINO */
+
+uint8_t u8g_com_arduino_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_no_en_parallel.c

@@ -0,0 +1,221 @@
+/*
+  
+  u8g_arduino_no_en_parallel.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+  PIN_D0 8
+  PIN_D1 9
+  PIN_D2 10
+  PIN_D3 11
+  PIN_D4 4
+  PIN_D5 5
+  PIN_D6 6
+  PIN_D7 7
+
+  PIN_CS1 14
+  PIN_CS2 15
+  PIN_RW 16
+  PIN_DI 17
+  PIN_EN 18
+  
+  u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset)
+  u8g_Init8Bit(u8g, dev,  8,    9, 10, 11,   4,   5,   6,   7, 18, 14, 15, 17, 16, U8G_PIN_NONE)
+
+*/
+
+#include "u8g.h"
+
+#if  defined(ARDUINO)
+
+#if ARDUINO < 100 
+//#include <WProgram.h> 
+#include <wiring_private.h> 
+#include <pins_arduino.h> 
+#else 
+#include <Arduino.h> 
+#endif
+
+//#define PIN_RESET
+
+#if defined(__PIC32MX)
+/* CHIPKIT PIC32 */
+static volatile uint32_t *u8g_data_port[8];
+static uint32_t u8g_data_mask[8];
+#else
+static volatile uint8_t *u8g_data_port[8];
+static uint8_t u8g_data_mask[8];
+#endif
+
+
+
+static void u8g_com_arduino_no_en_parallel_init(u8g_t *u8g)
+{
+  u8g_data_port[0] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0]));
+  u8g_data_mask[0] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D0]);
+  u8g_data_port[1] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1]));
+  u8g_data_mask[1] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D1]);
+  u8g_data_port[2] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2]));
+  u8g_data_mask[2] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D2]);
+  u8g_data_port[3] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3]));
+  u8g_data_mask[3] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D3]);
+  
+  u8g_data_port[4] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4]));
+  u8g_data_mask[4] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D4]);
+  u8g_data_port[5] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5]));
+  u8g_data_mask[5] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D5]);
+  u8g_data_port[6] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6]));
+  u8g_data_mask[6] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D6]);
+  u8g_data_port[7] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7]));
+  u8g_data_mask[7] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D7]);  
+}
+
+void u8g_com_arduino_no_en_write_data_pin(uint8_t pin, uint8_t val)
+{
+  if ( val != 0 )
+    *u8g_data_port[pin] |= u8g_data_mask[pin];
+  else
+    *u8g_data_port[pin] &= ~u8g_data_mask[pin];
+}
+
+
+void u8g_com_arduino_no_en_parallel_write(u8g_t *u8g, uint8_t val)
+{
+  u8g_com_arduino_no_en_write_data_pin( 0, val&1 );
+  val >>= 1;
+  u8g_com_arduino_no_en_write_data_pin( 1, val&1 );
+  val >>= 1;
+  u8g_com_arduino_no_en_write_data_pin( 2, val&1 );
+  val >>= 1;
+  u8g_com_arduino_no_en_write_data_pin( 3, val&1 );
+  val >>= 1;
+
+  u8g_com_arduino_no_en_write_data_pin( 4, val&1 );
+  val >>= 1;
+  u8g_com_arduino_no_en_write_data_pin( 5, val&1 );
+  val >>= 1;
+  u8g_com_arduino_no_en_write_data_pin( 6, val&1 );
+  val >>= 1;
+  u8g_com_arduino_no_en_write_data_pin( 7, val&1 );
+  val >>= 1;
+  
+  /* EN cycle time must be 1 micro second, digitalWrite is slow enough to do this */
+  if ( u8g->pin_list[U8G_PI_CS_STATE] == 1 )
+  {
+    u8g_MicroDelay();
+    u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH);
+    u8g_MicroDelay();
+    u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW);
+    u8g_MicroDelay();
+  }
+  else if ( u8g->pin_list[U8G_PI_CS_STATE] == 2 )
+  {
+    u8g_MicroDelay();
+    u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH);
+    u8g_MicroDelay();
+    u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW);
+    u8g_MicroDelay();
+  }
+}
+
+
+uint8_t u8g_com_arduino_no_en_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_com_arduino_no_en_parallel_init(u8g);
+      /* setup the RW pin as output and force it to low */
+      if ( u8g->pin_list[U8G_PI_RW] != U8G_PIN_NONE )
+      {
+        pinMode(u8g->pin_list[U8G_PI_RW], OUTPUT);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RW, LOW);
+      }
+      /* set all pins (except RW pin) */
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      break;
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_CHIP_SELECT:
+      /*
+	0: nothing selected
+	1: CS1 will be used as enable line
+        2: CS2 will be used as enable line
+        this will be used in the u8g_com_arduino_no_en_parallel_write() procedure
+      */
+      u8g->pin_list[U8G_PI_CS_STATE] = arg_val;
+      break;
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_arduino_no_en_parallel_write(u8g, arg_val);
+      break;
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_no_en_parallel_write(u8g, *ptr++);
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_no_en_parallel_write(u8g, u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val);
+      break;
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+  }
+  return 1;
+}
+
+#else
+
+
+uint8_t u8g_com_arduino_no_en_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_parallel.c

@@ -0,0 +1,187 @@
+/*
+  
+  u8g_arduino_parallel.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+
+  PIN_D0 8
+  PIN_D1 9
+  PIN_D2 10
+  PIN_D3 11
+  PIN_D4 4
+  PIN_D5 5
+  PIN_D6 6
+  PIN_D7 7
+
+  PIN_CS1 14
+  PIN_CS2 15
+  PIN_RW 16
+  PIN_DI 17
+  PIN_EN 18
+  
+  u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset)
+  u8g_Init8Bit(u8g, dev,  8,    9, 10, 11,   4,   5,   6,   7, 18, 14, 15, 17, 16, U8G_PIN_NONE)
+
+*/
+
+#include "u8g.h"
+
+
+#if  defined(ARDUINO)
+
+#if ARDUINO < 100 
+#include <WProgram.h> 
+#else 
+#include <Arduino.h> 
+#endif
+
+
+
+
+
+
+void u8g_com_arduino_parallel_write(u8g_t *u8g, uint8_t val)
+{
+  u8g_com_arduino_digital_write(u8g, U8G_PI_D0, val&1);
+  val >>= 1;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_D1, val&1);
+  val >>= 1;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_D2, val&1);
+  val >>= 1;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_D3, val&1);
+  val >>= 1;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_D4, val&1);
+  val >>= 1;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_D5, val&1);
+  val >>= 1;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_D6, val&1);
+  val >>= 1;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_D7, val&1);
+  
+  /* EN cycle time must be 1 micro second, digitalWrite is slow enough to do this */
+  //u8g_Delay(1);
+  u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH);
+  //u8g_Delay(1);
+  u8g_MicroDelay(); /* delay by 1000ns, reference: ST7920: 140ns, SBN1661: 100ns */
+  u8g_com_arduino_digital_write(u8g, U8G_PI_EN, LOW);
+  u8g_10MicroDelay(); /* ST7920 commands: 72us */
+  //u8g_Delay(2);
+}
+
+
+uint8_t u8g_com_arduino_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      /* setup the RW pin as output and force it to low */
+      if ( u8g->pin_list[U8G_PI_RW] != U8G_PIN_NONE )
+      {
+        pinMode(u8g->pin_list[U8G_PI_RW], OUTPUT);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RW, LOW);
+      }
+      /* set all pins (except RW pin) */
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      break;
+    case U8G_COM_MSG_STOP:
+      break;
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH);
+      }
+      else if ( arg_val == 1 )
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH);
+      }
+      else if ( arg_val == 2 )
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW);
+      }
+      else
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW);
+      }
+      break;
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_arduino_parallel_write(u8g, arg_val);
+      break;
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_parallel_write(u8g, *ptr++);
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_parallel_write(u8g, u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val);
+      break;
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+      
+  }
+  return 1;
+}
+
+#else
+
+
+uint8_t u8g_com_arduino_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_port_d_wr.c

@@ -0,0 +1,168 @@
+/*
+  
+  u8g_arduino_port_d_wr.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+
+  Assumes PORTD for 8 bit data transfer.
+  EN is assumed to be a low active write signal (WR)
+
+  ILI9325D_320x240 from iteadstudio.com
+  RS=19, WR=18, CS=17, RST=16
+
+  
+  u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset)
+  u8g_Init8Bit(u8g, dev,  8,    9, 10, 11,   4,   5,   6,   7, 18, 14, 15, 17, 16, U8G_PIN_NONE)
+
+*/
+
+#include "u8g.h"
+
+
+#if  defined(ARDUINO) && defined(PORTD)
+
+#if ARDUINO < 100 
+#include <WProgram.h> 
+#else 
+#include <Arduino.h> 
+#endif
+
+
+
+
+
+
+static void u8g_com_arduino_port_d_8bit_wr(u8g_t *u8g, uint8_t val)
+{
+  PORTD = val;
+  
+  /* WR cycle time must be 1 micro second, digitalWrite is slow enough to do this */
+  u8g_com_arduino_digital_write(u8g, U8G_PI_EN, LOW);
+  u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH);
+}
+
+
+uint8_t u8g_com_arduino_port_d_wr_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+
+#ifdef UCSR0B
+      UCSR0B = 0;  // disable USART 0
+#endif
+      DDRD = 0x0ff;
+      PORTD = 0x0ff;
+
+      /* setup the RW pin as output and force it to low */
+      if ( u8g->pin_list[U8G_PI_RW] != U8G_PIN_NONE )
+      {
+        pinMode(u8g->pin_list[U8G_PI_RW], OUTPUT);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RW, HIGH);
+      }
+      /* set all pins (except RW pin) */
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_EN, HIGH);
+      break;
+    case U8G_COM_MSG_STOP:
+      break;
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH);
+      }
+      else if ( arg_val == 1 )
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, HIGH);
+      }
+      else if ( arg_val == 2 )
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, HIGH);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW);
+      }
+      else
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS1, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS2, LOW);
+      }
+      break;
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_arduino_port_d_8bit_wr(u8g, arg_val);
+      break;
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_port_d_8bit_wr(u8g, *ptr++);
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_port_d_8bit_wr(u8g, u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val);
+      break;
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+  }
+  return 1;
+}
+
+#else
+
+
+uint8_t u8g_com_arduino_port_d_wr_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif /* ARDUINO && PORTD */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_ssd_i2c.c

@@ -0,0 +1,201 @@
+/*
+  
+  u8g_com_arduino_ssd_i2c.c
+
+  com interface for arduino (AND atmega) and the SSDxxxx chip (SOLOMON) variant 
+  I2C protocol 
+  
+  ToDo: Rename this to u8g_com_avr_ssd_i2c.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+  Special pin usage:
+    U8G_PI_I2C_OPTION	additional options
+    U8G_PI_A0_STATE	used to store the last value of the command/data register selection
+    U8G_PI_SET_A0		1: Signal request to update I2C device with new A0_STATE, 0: Do nothing, A0_STATE matches I2C device
+    U8G_PI_SCL		clock line (NOT USED)
+    U8G_PI_SDA		data line (NOT USED)
+    
+    U8G_PI_RESET		reset line (currently disabled, see below)
+
+  Protocol:
+    SLA, Cmd/Data Selection, Arguments
+    The command/data register is selected by a special instruction byte, which is sent after SLA
+    
+    The continue bit is always 0 so that a (re)start is equired for the change from cmd to/data mode
+*/
+
+#include "u8g.h"
+
+#define I2C_SLA		(0x3c*2)
+//#define I2C_CMD_MODE	0x080
+#define I2C_CMD_MODE	0x000
+#define I2C_DATA_MODE	0x040
+
+
+uint8_t u8g_com_arduino_ssd_start_sequence(u8g_t *u8g)
+{
+  /* are we requested to set the a0 state? */
+  if ( u8g->pin_list[U8G_PI_SET_A0] == 0 )
+    return 1;	
+  
+  /* setup bus, might be a repeated start */
+  if ( u8g_i2c_start(I2C_SLA) == 0 )
+    return 0;
+  if ( u8g->pin_list[U8G_PI_A0_STATE] == 0 )
+  {
+    if ( u8g_i2c_send_byte(I2C_CMD_MODE) == 0 )
+      return 0;
+  }
+  else
+  {
+    if ( u8g_i2c_send_byte(I2C_DATA_MODE) == 0 )
+      return 0;
+  }
+  
+  
+  u8g->pin_list[U8G_PI_SET_A0] = 0;
+  return 1;
+}
+
+uint8_t u8g_com_arduino_ssd_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      //u8g_com_arduino_digital_write(u8g, U8G_PI_SCL, HIGH);
+      //u8g_com_arduino_digital_write(u8g, U8G_PI_SDA, HIGH);
+      //u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* inital RS state: unknown mode */
+    
+      u8g_i2c_init(u8g->pin_list[U8G_PI_I2C_OPTION]);
+
+      break;
+    
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_RESET:
+      /* Currently disabled, but it could be enable. Previous restrictions have been removed */
+      /* u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val); */
+      break;
+      
+    case U8G_COM_MSG_CHIP_SELECT:
+      u8g->pin_list[U8G_PI_A0_STATE] = 0;
+      u8g->pin_list[U8G_PI_SET_A0] = 1;		/* force a0 to set again, also forces start condition */
+      if ( arg_val == 0 )
+      {
+        /* disable chip, send stop condition */
+	u8g_i2c_stop();
+     }
+      else
+      {
+        /* enable, do nothing: any byte writing will trigger the i2c start */
+      }
+      break;
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      //u8g->pin_list[U8G_PI_SET_A0] = 1;
+      if ( u8g_com_arduino_ssd_start_sequence(u8g) == 0 )
+	return u8g_i2c_stop(), 0;
+      if ( u8g_i2c_send_byte(arg_val) == 0 )
+	return u8g_i2c_stop(), 0;
+      // u8g_i2c_stop();
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      //u8g->pin_list[U8G_PI_SET_A0] = 1;
+      if ( u8g_com_arduino_ssd_start_sequence(u8g) == 0 )
+	return u8g_i2c_stop(), 0;
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+	  if ( u8g_i2c_send_byte(*ptr++) == 0 )
+	    return u8g_i2c_stop(), 0;
+          arg_val--;
+        }
+      }
+      // u8g_i2c_stop();
+      break;
+
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      //u8g->pin_list[U8G_PI_SET_A0] = 1;
+      if ( u8g_com_arduino_ssd_start_sequence(u8g) == 0 )
+	return u8g_i2c_stop(), 0;
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+	  if ( u8g_i2c_send_byte(u8g_pgm_read(ptr)) == 0 )
+	    return 0;
+          ptr++;
+          arg_val--;
+        }
+      }
+      // u8g_i2c_stop();
+      break;
+      
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
+      u8g->pin_list[U8G_PI_SET_A0] = 1;		/* force a0 to set again */
+    
+#ifdef OLD_CODE    
+      if ( i2c_state != 0 )
+      {
+	u8g_i2c_stop();
+	i2c_state = 0;
+      }
+
+      if ( u8g_com_arduino_ssd_start_sequence(arg_val) == 0 )
+	return 0;
+    
+      /* setup bus, might be a repeated start */
+      /*
+      if ( u8g_i2c_start(I2C_SLA) == 0 )
+	return 0;
+      if ( arg_val == 0 )
+      {
+	i2c_state = 1;
+	
+	if ( u8g_i2c_send_byte(I2C_CMD_MODE) == 0 )
+	  return 0;
+      }
+      else
+      {
+	i2c_state = 2;
+	if ( u8g_i2c_send_byte(I2C_DATA_MODE) == 0 )
+	  return 0;
+      }
+      */
+#endif
+      break;
+  }
+  return 1;
+}

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_st7920_hw_spi.c

@@ -0,0 +1,220 @@
+/*
+  
+  u8g_com_arduino_st7920_hw_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+  A special HW SPI interface for ST7920 controller
+
+*/
+
+#include "u8g.h"
+
+#if defined(ARDUINO)
+
+#if ARDUINO < 100 
+#include <WProgram.h>    
+#include "wiring_private.h"
+#include "pins_arduino.h"
+
+#else 
+#include <Arduino.h> 
+#include "wiring_private.h"
+#endif
+
+#if defined(__AVR__)
+#define U8G_ARDUINO_ATMEGA_HW_SPI
+
+/* remove the definition for attiny */
+#if __AVR_ARCH__ == 2
+#undef U8G_ATMEGA_HW_SPI
+#endif
+#if __AVR_ARCH__ == 25
+#undef U8G_ATMEGA_HW_SPI
+#endif
+
+#endif
+
+
+#if defined(U8G_ARDUINO_ATMEGA_HW_SPI)
+
+#include <avr/interrupt.h>
+#include <avr/io.h>
+
+static uint8_t u8g_arduino_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE;
+static uint8_t u8g_arduino_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val)
+{
+  /* send data */
+  SPDR = val;
+  /* wait for transmission */
+  while (!(SPSR & (1<<SPIF))) 
+    ;
+  /* clear the SPIF flag by reading SPDR */
+  return  SPDR;
+}
+
+
+static void u8g_com_arduino_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val) U8G_NOINLINE;
+static void u8g_com_arduino_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val)
+{
+  uint8_t i;
+
+  if ( rs == 0 )
+  {
+    /* command */
+    u8g_arduino_st7920_hw_spi_shift_out(u8g, 0x0f8);
+  }
+  else if ( rs == 1 )
+  {
+    /* data */
+    u8g_arduino_st7920_hw_spi_shift_out(u8g, 0x0fa);
+  }
+  else
+  {
+    /* do nothing, keep same state */
+  }
+  
+  u8g_arduino_st7920_hw_spi_shift_out(u8g, val & 0x0f0);
+  u8g_arduino_st7920_hw_spi_shift_out(u8g, val << 4);
+
+  for( i = 0; i < 4; i++ )
+    u8g_10MicroDelay();
+}
+
+
+uint8_t u8g_com_arduino_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
+      
+      DDRB |= _BV(3);          /* D0, MOSI */
+      DDRB |= _BV(5);          /* SCK */
+      DDRB |= _BV(2);		/* slave select */
+    
+      PORTB &= ~_BV(3);        /* D0, MOSI = 0 */
+      PORTB &= ~_BV(5);        /* SCK = 0 */
+
+      /*
+        SPR1 SPR0
+            0	0		fclk/4
+            0	1		fclk/16 
+            1	0		fclk/64  
+            1	1		fclk/128
+      */
+      SPCR = 0;
+      
+      /* 20 Dez 2012: set CPOL and CPHA to 1 !!! */
+      SPCR =  (1<<SPE) | (1<<MSTR)|(0<<SPR1)|(0<<SPR0)|(1<<CPOL)|(1<<CPHA);
+#ifdef U8G_HW_SPI_2X
+      SPSR = (1 << SPI2X);  /* double speed, issue 89 */
+#endif
+      u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* inital RS state: command mode */
+      break;
+    
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+	u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+      
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable, note: the st7920 has an active high chip select */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
+      }
+      else
+      {
+        /* enable */
+        //u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
+      }
+      break;
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_arduino_st7920_write_byte_hw_spi(u8g,  u8g->pin_list[U8G_PI_A0_STATE], arg_val);
+      // u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+      //u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
+          // u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+          arg_val--;
+        }
+      }
+      break;
+
+      case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], u8g_pgm_read(ptr) );
+          // u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+      
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
+      break;
+  }
+  return 1;
+}
+
+#else
+
+uint8_t u8g_com_arduino_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+#endif
+
+#else /* ARDUINO */
+
+uint8_t u8g_com_arduino_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_st7920_spi.c

@@ -0,0 +1,295 @@
+/*
+  
+  u8g_com_arduino_st7920_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+  A special SPI interface for ST7920 controller
+
+*/
+
+#include "u8g.h"
+
+#if defined(ARDUINO)
+
+#if ARDUINO < 100 
+#include <WProgram.h>    
+#include "wiring_private.h"
+#include "pins_arduino.h"
+
+#else 
+#include <Arduino.h> 
+#include "wiring_private.h"
+#endif
+
+#if defined(__AVR__)
+
+uint8_t u8g_bitData, u8g_bitNotData;
+uint8_t u8g_bitClock, u8g_bitNotClock;
+volatile uint8_t *u8g_outData;
+volatile uint8_t *u8g_outClock;
+
+static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
+{
+  u8g_outData = portOutputRegister(digitalPinToPort(dataPin));
+  u8g_outClock = portOutputRegister(digitalPinToPort(clockPin));
+  u8g_bitData = digitalPinToBitMask(dataPin);
+  u8g_bitClock = digitalPinToBitMask(clockPin);
+
+  u8g_bitNotClock = u8g_bitClock;
+  u8g_bitNotClock ^= 0x0ff;
+
+  u8g_bitNotData = u8g_bitData;
+  u8g_bitNotData ^= 0x0ff;
+}
+
+static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) U8G_NOINLINE;
+static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
+{
+  uint8_t cnt = 8;
+  uint8_t bitData = u8g_bitData;
+  uint8_t bitNotData = u8g_bitNotData;
+  uint8_t bitClock = u8g_bitClock;
+  uint8_t bitNotClock = u8g_bitNotClock;
+  volatile uint8_t *outData = u8g_outData;
+  volatile uint8_t *outClock = u8g_outClock;
+  do
+  {
+    if ( val & 128 )
+      *outData |= bitData;
+    else
+      *outData &= bitNotData;
+
+    /*
+    *outClock |= bitClock;
+    val <<= 1;
+    cnt--;
+    *outClock &= bitNotClock;
+    */
+
+    val <<= 1;
+    *outClock &= bitNotClock;
+    cnt--;
+    // removed micro delays, because AVRs are too slow and the delay is not required
+    //u8g_MicroDelay();
+    *outClock |= bitClock;
+    //u8g_MicroDelay();
+  } while( cnt != 0 );
+}
+
+#elif defined(__18CXX) || defined(__PIC32MX)
+
+uint16_t dog_bitData, dog_bitNotData;
+uint16_t dog_bitClock, dog_bitNotClock;
+volatile uint32_t *dog_outData;
+volatile uint32_t *dog_outClock;
+volatile uint32_t dog_pic32_spi_tmp;
+
+static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
+{
+  dog_outData = portOutputRegister(digitalPinToPort(dataPin));
+  dog_outClock = portOutputRegister(digitalPinToPort(clockPin));
+  dog_bitData = digitalPinToBitMask(dataPin);
+  dog_bitClock = digitalPinToBitMask(clockPin);
+
+  dog_bitNotClock = dog_bitClock;
+  dog_bitNotClock ^= 0x0ffff;
+
+  dog_bitNotData = dog_bitData;
+  dog_bitNotData ^= 0x0ffff;
+}
+
+static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
+{
+  uint8_t cnt = 8;
+  do
+  {
+    if ( val & 128 )
+	*dog_outData |= dog_bitData;
+    else
+	*dog_outData &= dog_bitNotData;    
+    val <<= 1;
+    //u8g_MicroDelay();
+    //*dog_outClock |= dog_bitClock;
+    *dog_outClock &= dog_bitNotClock;
+    cnt--;
+    u8g_MicroDelay();
+    //*dog_outClock &= dog_bitNotClock;
+    *dog_outClock |= dog_bitClock;
+    u8g_MicroDelay();
+    
+  } while( cnt != 0 );
+}
+
+#else
+
+/* default interface, Arduino DUE (__arm__) */
+
+uint8_t u8g_data_pin;
+uint8_t u8g_clock_pin;
+
+static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
+{
+  u8g_data_pin = dataPin;
+  u8g_clock_pin = clockPin;
+}
+
+static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
+{
+  uint8_t cnt = 8;
+  do
+  {
+    if ( val & 128 )
+	digitalWrite(u8g_data_pin, HIGH);
+    else
+	digitalWrite(u8g_data_pin, LOW);
+    val <<= 1;
+    //u8g_MicroDelay();
+    digitalWrite(u8g_clock_pin, LOW);
+    cnt--;
+    u8g_MicroDelay();
+    digitalWrite(u8g_clock_pin, HIGH);
+    u8g_MicroDelay();    
+  } while( cnt != 0 );
+}
+
+#endif 
+
+
+
+
+static void u8g_com_arduino_st7920_write_byte(uint8_t rs, uint8_t val)
+{
+  uint8_t i;
+
+  if ( rs == 0 )
+  {
+    /* command */
+    u8g_com_arduino_do_shift_out_msb_first(0x0f8);
+  }
+  else if ( rs == 1 )
+  {
+    /* data */
+    u8g_com_arduino_do_shift_out_msb_first(0x0fa);
+  }
+  
+  u8g_com_arduino_do_shift_out_msb_first(val & 0x0f0);
+  u8g_com_arduino_do_shift_out_msb_first(val << 4);
+  
+  for( i = 0; i < 4; i++ )
+    u8g_10MicroDelay();
+    
+}
+
+
+
+uint8_t u8g_com_arduino_st7920_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
+      // u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, HIGH);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_MOSI, LOW);
+      u8g_com_arduino_init_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK]);
+      u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* inital RS state: command mode */
+      break;
+    
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+	u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+      
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable, note: the st7920 has an active high chip select */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
+      }
+      else
+      {
+        /* enable */
+        //u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, HIGH);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
+      }
+      break;
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_arduino_st7920_write_byte( u8g->pin_list[U8G_PI_A0_STATE], arg_val);
+      //u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+      //u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_st7920_write_byte(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
+          //u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+          arg_val--;
+        }
+      }
+      break;
+
+      case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_st7920_write_byte(u8g->pin_list[U8G_PI_A0_STATE], u8g_pgm_read(ptr) );
+          //u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+      
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
+      break;
+  }
+  return 1;
+}
+
+#else /* ARDUINO */
+
+uint8_t u8g_com_arduino_st7920_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_std_sw_spi.c

@@ -0,0 +1,144 @@
+/*
+  
+  u8g_arduino_std_sw_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+
+#if defined(ARDUINO)
+
+#if ARDUINO < 100 
+#include <WProgram.h>
+#else 
+#include <Arduino.h> 
+#endif
+
+void u8g_arduino_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val)
+{
+  uint8_t i = 8;
+  do
+  {
+    if ( val & 128 )
+      digitalWrite(dataPin, HIGH);
+    else
+      digitalWrite(dataPin, LOW);
+    val <<= 1;
+    u8g_MicroDelay();		/* 23 Sep 2012 */
+    //delay(1);
+    digitalWrite(clockPin, HIGH);
+    u8g_MicroDelay();		/* 23 Sep 2012 */
+    //delay(1);
+    digitalWrite(clockPin, LOW);		
+    u8g_MicroDelay();		/* 23 Sep 2012 */
+    //delay(1);
+    i--;
+  } while( i != 0 );
+}
+
+uint8_t u8g_com_arduino_std_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_MOSI, LOW);
+      break;
+    
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+      
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
+      }
+      else
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
+      }
+      break;
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], *ptr++);
+          arg_val--;
+        }
+      }
+      break;
+
+      case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+      
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_com_arduino_digital_write(u8g, U8G_PI_A0, arg_val);
+      break;
+  }
+  return 1;
+}
+
+#else /* ARDUINO */
+
+uint8_t u8g_com_arduino_std_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_sw_spi.c

@@ -0,0 +1,239 @@
+/*
+  
+  u8g_arduino_sw_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#if defined(ARDUINO)
+
+#if ARDUINO < 100 
+#include <WProgram.h>    
+#include "wiring_private.h"
+#include "pins_arduino.h"
+
+#else 
+#include <Arduino.h> 
+#include "wiring_private.h"
+#endif
+
+#if defined(__AVR__)
+
+uint8_t u8g_bitData, u8g_bitNotData;
+uint8_t u8g_bitClock, u8g_bitNotClock;
+volatile uint8_t *u8g_outData;
+volatile uint8_t *u8g_outClock;
+
+static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
+{
+  u8g_outData = portOutputRegister(digitalPinToPort(dataPin));
+  u8g_outClock = portOutputRegister(digitalPinToPort(clockPin));
+  u8g_bitData = digitalPinToBitMask(dataPin);
+  u8g_bitClock = digitalPinToBitMask(clockPin);
+
+  u8g_bitNotClock = u8g_bitClock;
+  u8g_bitNotClock ^= 0x0ff;
+
+  u8g_bitNotData = u8g_bitData;
+  u8g_bitNotData ^= 0x0ff;
+}
+
+static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val) U8G_NOINLINE;
+static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
+{
+  uint8_t cnt = 8;
+  uint8_t bitData = u8g_bitData;
+  uint8_t bitNotData = u8g_bitNotData;
+  uint8_t bitClock = u8g_bitClock;
+  uint8_t bitNotClock = u8g_bitNotClock;
+  volatile uint8_t *outData = u8g_outData;
+  volatile uint8_t *outClock = u8g_outClock;
+  do
+  {
+    if ( val & 128 )
+      *outData |= bitData;
+    else
+      *outData &= bitNotData;
+   
+    *outClock |= bitClock;
+    val <<= 1;
+    cnt--;
+    *outClock &= bitNotClock;
+  } while( cnt != 0 );
+}
+
+#elif defined(__18CXX) || defined(__PIC32MX)
+
+uint16_t dog_bitData, dog_bitNotData;
+uint16_t dog_bitClock, dog_bitNotClock;
+volatile uint32_t *dog_outData;
+volatile uint32_t *dog_outClock;
+volatile uint32_t dog_pic32_spi_tmp;
+
+static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
+{
+  dog_outData = portOutputRegister(digitalPinToPort(dataPin));
+  dog_outClock = portOutputRegister(digitalPinToPort(clockPin));
+  dog_bitData = digitalPinToBitMask(dataPin);
+  dog_bitClock = digitalPinToBitMask(clockPin);
+
+  dog_bitNotClock = dog_bitClock;
+  dog_bitNotClock ^= 0x0ffff;
+
+  dog_bitNotData = dog_bitData;
+  dog_bitNotData ^= 0x0ffff;
+}
+
+static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
+{
+  uint8_t cnt = 8;
+  do
+  {
+    if ( val & 128 )
+	*dog_outData |= dog_bitData;
+    else
+	*dog_outData &= dog_bitNotData;    
+    val <<= 1;
+    /*
+	There must be some delay here. However
+	fetching the adress dog_outClock is enough delay, so
+	do not place dog_outClock in a local variable. This will
+	break the procedure
+    */
+    *dog_outClock |= dog_bitClock;
+    cnt--;
+    *dog_outClock &= dog_bitNotClock;
+    /* 
+	little additional delay after clk pulse, done by 3x32bit reads 
+	from I/O. Optimized for PIC32 with 80 MHz.
+    */
+    dog_pic32_spi_tmp = *dog_outClock;
+    dog_pic32_spi_tmp = *dog_outClock;
+    dog_pic32_spi_tmp = *dog_outClock;
+  } while( cnt != 0 );
+}
+
+#else
+/* empty interface */
+
+static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
+{
+}
+
+static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
+{
+}
+
+#endif 
+
+
+uint8_t u8g_com_arduino_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
+      u8g_com_arduino_digital_write(u8g, U8G_PI_MOSI, LOW);
+      u8g_com_arduino_init_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK]);
+      break;
+    
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+      
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
+      }
+      else
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
+      }
+      break;
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_arduino_do_shift_out_msb_first( arg_val );
+      //u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_do_shift_out_msb_first(*ptr++);
+          // u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], *ptr++);
+          arg_val--;
+        }
+      }
+      break;
+
+      case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_arduino_do_shift_out_msb_first( u8g_pgm_read(ptr) );
+          //u8g_arduino_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+      
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_com_arduino_digital_write(u8g, U8G_PI_A0, arg_val);
+      break;
+  }
+  return 1;
+}
+
+#else /* ARDUINO */
+
+uint8_t u8g_com_arduino_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_arduino_t6963.c

@@ -0,0 +1,385 @@
+/*
+  
+  u8g_com_arduino_t6963.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+
+  PIN_D0 8
+  PIN_D1 9
+  PIN_D2 10
+  PIN_D3 11
+  PIN_D4 4
+  PIN_D5 5
+  PIN_D6 6
+  PIN_D7 7
+
+  PIN_CS 14
+  PIN_A0 15
+  PIN_RESET 16
+  PIN_WR 17
+  PIN_RD 18
+  
+  u8g_InitRW8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset)
+  u8g_InitRW8Bit(u8g, dev,  8,  9, 10, 11,  4,  5,  6,  7, 14, 15, 17, 18, 16)
+
+*/
+
+#include "u8g.h"
+
+#if  defined(ARDUINO)
+
+#if ARDUINO < 100 
+//#include <WProgram.h> 
+#include <wiring_private.h> 
+#include <pins_arduino.h> 
+#else 
+#include <Arduino.h> 
+#endif
+
+
+#if defined(__PIC32MX)
+/* CHIPKIT PIC32 */
+static volatile uint32_t *u8g_output_data_port[8];
+static volatile uint32_t *u8g_input_data_port[8];
+static volatile uint32_t *u8g_mode_port[8];
+static uint32_t u8g_data_mask[8];
+#else
+static volatile uint8_t *u8g_output_data_port[8];
+static volatile uint8_t *u8g_input_data_port[8];
+static volatile uint8_t *u8g_mode_port[8];
+static uint8_t u8g_data_mask[8];
+#endif
+
+
+
+static void u8g_com_arduino_t6963_init(u8g_t *u8g)
+{
+  u8g_output_data_port[0] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0]));
+  u8g_input_data_port[0] =  portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0]));
+  u8g_mode_port[0] =  portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D0]));
+  u8g_data_mask[0] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D0]);
+  
+  u8g_output_data_port[1] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1]));
+  u8g_input_data_port[1] =  portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1]));
+  u8g_mode_port[1] =  portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D1]));
+  u8g_data_mask[1] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D1]);
+  
+  u8g_output_data_port[2] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2]));
+  u8g_input_data_port[2] =  portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2]));
+  u8g_mode_port[2] =  portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D2]));
+  u8g_data_mask[2] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D2]);
+  
+  u8g_output_data_port[3] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3]));
+  u8g_input_data_port[3] =  portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3]));
+  u8g_mode_port[3] =  portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D3]));
+  u8g_data_mask[3] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D3]);
+  
+  u8g_output_data_port[4] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4]));
+  u8g_input_data_port[4] =  portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4]));
+  u8g_mode_port[4] =  portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D4]));
+  u8g_data_mask[4] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D4]);
+  
+  u8g_output_data_port[5] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5]));
+  u8g_input_data_port[5] =  portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5]));
+  u8g_mode_port[5] =  portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D5]));
+  u8g_data_mask[5] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D5]);
+  
+  u8g_output_data_port[6] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6]));
+  u8g_input_data_port[6] =  portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6]));
+  u8g_mode_port[6] =  portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D6]));
+  u8g_data_mask[6] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D6]);
+  
+  u8g_output_data_port[7] =  portOutputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7]));
+  u8g_input_data_port[7] =  portInputRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7]));
+  u8g_mode_port[7] =  portModeRegister(digitalPinToPort(u8g->pin_list[U8G_PI_D7]));
+  u8g_data_mask[7] =  digitalPinToBitMask(u8g->pin_list[U8G_PI_D7]);  
+}
+
+static void u8g_com_arduino_t6963_write_data_pin(uint8_t pin, uint8_t val)
+{
+  if ( val != 0 )
+    *u8g_output_data_port[pin] |= u8g_data_mask[pin];
+  else
+    *u8g_output_data_port[pin] &= ~u8g_data_mask[pin];
+}
+
+static void u8g_com_arduino_t6963_set_port_output(void)
+{
+  uint8_t i;
+  for( i = 0; i < 8; i++ )
+  {
+#if defined(__PIC32MX)
+/* CHIPKIT PIC32 */
+      *u8g_mode_port[i] |= u8g_data_mask[i]; 
+#elif defined(__AVR__)
+      *u8g_mode_port[i] |= u8g_data_mask[i]; 
+#else
+      /* TODO: use generic Arduino API */
+      *u8g_mode_port[i] |= u8g_data_mask[i]; 
+#endif
+
+  }
+}
+
+static void u8g_com_arduino_t6963_set_port_input(void)
+{
+  uint8_t i;
+  for( i = 0; i < 8; i++ )
+  {
+#if defined(__PIC32MX)
+/* CHIPKIT PIC32 */
+      *u8g_mode_port[i] &= ~u8g_data_mask[i]; 
+#elif defined(__AVR__)
+/* avr */
+      *u8g_mode_port[i] &= ~u8g_data_mask[i]; 
+      *u8g_output_data_port[i] &= ~u8g_data_mask[i]; 	// no pullup
+#else
+      /* TODO: use generic Arduino API */
+      *u8g_mode_port[i] &= ~u8g_data_mask[i]; 
+      *u8g_output_data_port[i] &= ~u8g_data_mask[i]; 	// no pullup
+#endif
+  }
+}
+
+
+static void u8g_com_arduino_t6963_write(u8g_t *u8g, uint8_t val)
+{
+  u8g_com_arduino_t6963_write_data_pin( 0, val&1 );
+  val >>= 1;
+  u8g_com_arduino_t6963_write_data_pin( 1, val&1 );
+  val >>= 1;
+  u8g_com_arduino_t6963_write_data_pin( 2, val&1 );
+  val >>= 1;
+  u8g_com_arduino_t6963_write_data_pin( 3, val&1 );
+  val >>= 1;
+
+  u8g_com_arduino_t6963_write_data_pin( 4, val&1 );
+  val >>= 1;
+  u8g_com_arduino_t6963_write_data_pin( 5, val&1 );
+  val >>= 1;
+  u8g_com_arduino_t6963_write_data_pin( 6, val&1 );
+  val >>= 1;
+  u8g_com_arduino_t6963_write_data_pin( 7, val&1 );
+  val >>= 1;
+  
+  u8g_com_arduino_digital_write(u8g, U8G_PI_WR, 0);
+  u8g_MicroDelay(); /* 80ns, reference: t6963 datasheet */
+  u8g_com_arduino_digital_write(u8g, U8G_PI_WR, 1);
+  u8g_MicroDelay(); /* 10ns, reference: t6963 datasheet */
+}
+
+static uint8_t u8g_com_arduino_t6963_read(u8g_t *u8g)
+{
+  uint8_t val = 0;
+  
+  u8g_com_arduino_digital_write(u8g, U8G_PI_RD, 0);
+  u8g_MicroDelay(); /* 150ns, reference: t6963 datasheet */
+  
+  /* only read bits 0, 1 and 3 */
+  if ( (*u8g_input_data_port[3] & u8g_data_mask[3]) != 0 )
+    val++;
+  val <<= 1;
+  val <<= 1;
+  if ( (*u8g_input_data_port[1] & u8g_data_mask[1]) != 0 )
+    val++;
+  val <<= 1;
+  if ( (*u8g_input_data_port[0] & u8g_data_mask[0]) != 0 )
+    val++;
+    
+  u8g_com_arduino_digital_write(u8g, U8G_PI_RD, 1);
+  u8g_MicroDelay(); /* 10ns, reference: t6963 datasheet */
+  
+  return val;
+}
+
+#define U8G_STATUS_TIMEOUT 50
+
+static uint8_t u8g_com_arduino_t6963_until_01_ok(u8g_t *u8g)
+{
+  long x;
+  
+  u8g_com_arduino_t6963_set_port_input();
+  x = millis();
+  x += U8G_STATUS_TIMEOUT;
+
+  for(;;)
+  {    
+    if ( (u8g_com_arduino_t6963_read(u8g) & 3) == 3 )
+      break;
+    if ( x < millis() )
+      return 0;
+  }
+  u8g_com_arduino_t6963_set_port_output();
+  return 1;
+}
+
+static uint8_t u8g_com_arduino_t6963_until_3_ok(u8g_t *u8g)
+{
+  long x;
+  
+  u8g_com_arduino_t6963_set_port_input();
+  x = millis();
+  x += U8G_STATUS_TIMEOUT;
+
+  for(;;)
+  {    
+    if ( (u8g_com_arduino_t6963_read(u8g) & 8) == 8 )
+      break;
+    if ( x < millis() )
+      return 0;
+  }
+  u8g_com_arduino_t6963_set_port_output();
+  return 1;
+}
+
+static uint8_t u8g_com_arduino_t6963_write_cmd(u8g_t *u8g, uint8_t val)
+{
+  u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 1);
+  if ( u8g_com_arduino_t6963_until_01_ok(u8g) == 0 )
+    return 0;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 1);
+  u8g_com_arduino_t6963_write(u8g, val);
+  return 1;  
+}
+
+static uint8_t u8g_com_arduino_t6963_write_data(u8g_t *u8g, uint8_t val)
+{
+  u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 1);
+  if ( u8g_com_arduino_t6963_until_01_ok(u8g) == 0 )
+    return 0;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 0);
+  u8g_com_arduino_t6963_write(u8g, val);
+  return 1;  
+}
+
+static uint8_t u8g_com_arduino_t6963_write_auto_data(u8g_t *u8g, uint8_t val)
+{
+  u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 1);
+  if ( u8g_com_arduino_t6963_until_3_ok(u8g) == 0 )
+    return 0;
+  u8g_com_arduino_digital_write(u8g, U8G_PI_A0, 0);
+  u8g_com_arduino_t6963_write(u8g, val);
+  return 1;  
+}
+
+
+uint8_t u8g_com_arduino_t6963_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g->pin_list[U8G_PI_A0_STATE] = 0;
+      u8g_com_arduino_t6963_init(u8g);
+      /* setup the RW (equal to WR) pin as output and force it to high */
+      if ( u8g->pin_list[U8G_PI_WR] != U8G_PIN_NONE )
+      {
+        pinMode(u8g->pin_list[U8G_PI_WR], OUTPUT);
+        u8g_com_arduino_digital_write(u8g, U8G_PI_WR, HIGH);
+      }
+      /* set all pins (except WR pin) */
+      u8g_com_arduino_assign_pin_output_high(u8g);
+      break;
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable, active low chip select */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
+      }
+      else
+      {
+        /* enable */
+        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
+      }
+      break;
+    case U8G_COM_MSG_WRITE_BYTE:
+      if ( u8g->pin_list[U8G_PI_A0_STATE] == 0 )
+      {
+	u8g_com_arduino_t6963_write_data(u8g, arg_val);
+      }
+      else
+      {
+	u8g_com_arduino_t6963_write_cmd(u8g, arg_val);
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+	u8g_com_arduino_t6963_write_cmd(u8g, 0x0b0);	/* auto write */
+        while( arg_val > 0 )
+        {
+          if ( u8g_com_arduino_t6963_write_auto_data(u8g, *ptr++) == 0 )
+	    break;
+          arg_val--;
+        }
+	u8g_com_arduino_t6963_write_cmd(u8g, 0x0b2);	/* auto reset */
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+	u8g_com_arduino_t6963_write_cmd(u8g, 0x0b0);	/* auto write */
+        while( arg_val > 0 )
+        {
+          if ( u8g_com_arduino_t6963_write_auto_data(u8g, u8g_pgm_read(ptr)) == 0 )
+	    break;
+          ptr++;
+          arg_val--;
+        }
+	u8g_com_arduino_t6963_write_cmd(u8g, 0x0b2);	/* auto reset */
+      }
+      break;
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 1) or data mode (arg_val = 0) */
+      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
+      //u8g_com_arduino_digital_write(u8g, U8G_PI_DI, arg_val);
+      break;
+    case U8G_COM_MSG_RESET:
+      if ( u8g->pin_list[U8G_PI_RESET] != U8G_PIN_NONE )
+        u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
+      break;
+      
+  }
+  return 1;
+}
+
+#else
+
+
+uint8_t u8g_com_arduino_t6963_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_atmega_hw_spi.c

@@ -0,0 +1,174 @@
+/*
+  
+  u8g_com_atmega_hw_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+  
+  Assumes, that 
+    MOSI is at PORTB, Pin 3
+  and
+    SCK is at PORTB, Pin 5
+
+*/
+
+#include "u8g.h"
+
+
+#if defined(__AVR__)
+#define U8G_ATMEGA_HW_SPI
+
+/* remove the definition for attiny */
+#if __AVR_ARCH__ == 2
+#undef U8G_ATMEGA_HW_SPI
+#endif
+#if __AVR_ARCH__ == 25
+#undef U8G_ATMEGA_HW_SPI
+#endif
+#endif
+
+
+#if defined(U8G_ATMEGA_HW_SPI)
+
+#include <avr/interrupt.h>
+#include <avr/io.h>
+
+
+static uint8_t u8g_atmega_spi_out(uint8_t data)
+{
+  /* unsigned char x = 100; */
+  /* send data */
+  SPDR = data;
+  /* wait for transmission */
+  while (!(SPSR & (1<<SPIF))) 
+    ;
+  /* clear the SPIF flag by reading SPDR */
+  return  SPDR;
+}
+
+
+uint8_t u8g_com_atmega_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_STOP:
+      break;
+    
+    case U8G_COM_MSG_INIT:
+
+      u8g_SetPIOutput(u8g, U8G_PI_CS);
+      u8g_SetPIOutput(u8g, U8G_PI_A0);
+      
+      DDRB |= _BV(3);          /* D0, MOSI */
+      DDRB |= _BV(5);          /* SCK */
+      DDRB |= _BV(2);		/* slave select */
+    
+      PORTB &= ~_BV(3);        /* D0, MOSI = 0 */
+      PORTB &= ~_BV(5);        /* SCK = 0 */
+      u8g_SetPILevel(u8g, U8G_PI_CS, 1);
+
+      /*
+        SPR1 SPR0
+            0	0		fclk/4    x
+            0	1		fclk/16
+            1	0		fclk/64      
+            1	1		fclk/128
+      */
+      SPCR = 0;
+      SPCR =  (1<<SPE) | (1<<MSTR)|(0<<SPR1)|(0<<SPR0)|(0<<CPOL)|(0<<CPHA);
+#ifdef U8G_HW_SPI_2X
+      SPSR = (1 << SPI2X);  /* double speed, issue 89 */
+#endif
+
+      break;
+    
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_SetPILevel(u8g, U8G_PI_A0, arg_val);
+      break;
+
+    case U8G_COM_MSG_CHIP_SELECT:
+      
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_SetPILevel(u8g, U8G_PI_CS, 1);
+      }
+      else
+      {
+        PORTB &= ~_BV(5);        /* SCK = 0 */
+        /* enable */
+        u8g_SetPILevel(u8g, U8G_PI_CS, 0); /* CS = 0 (low active) */
+      }
+      
+      break;
+      
+    case U8G_COM_MSG_RESET:
+      u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_atmega_spi_out(arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_atmega_spi_out(*ptr++);
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_atmega_spi_out(u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+  }
+  return 1;
+}
+
+#else
+
+uint8_t u8g_com_atmega_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_atmega_parallel.c

@@ -0,0 +1,183 @@
+/*
+  
+  u8g_atmega_parallel.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+
+  PIN_D0 8
+  PIN_D1 9
+  PIN_D2 10
+  PIN_D3 11
+  PIN_D4 4
+  PIN_D5 5
+  PIN_D6 6
+  PIN_D7 7
+
+  PIN_CS1 14
+  PIN_CS2 15
+  PIN_RW 16
+  PIN_DI 17
+  PIN_EN 18
+  
+  u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset)
+  u8g_Init8Bit(u8g, dev,  8,    9, 10, 11,   4,   5,   6,   7, 18, 14, 15, 17, 16, U8G_PIN_NONE)
+
+*/
+
+#include "u8g.h"
+
+#if defined(__AVR__)
+
+static void u8g_com_atmega_parallel_write(u8g_t *u8g, uint8_t val) U8G_NOINLINE;
+static void u8g_com_atmega_parallel_write(u8g_t *u8g, uint8_t val)
+{
+
+  u8g_SetPILevel(u8g, U8G_PI_D0, val&1);
+  val >>= 1;
+  u8g_SetPILevel(u8g, U8G_PI_D1, val&1);
+  val >>= 1;
+  u8g_SetPILevel(u8g, U8G_PI_D2, val&1);
+  val >>= 1;
+  u8g_SetPILevel(u8g, U8G_PI_D3, val&1);
+  val >>= 1;
+  u8g_SetPILevel(u8g, U8G_PI_D4, val&1);
+  val >>= 1;
+  u8g_SetPILevel(u8g, U8G_PI_D5, val&1);
+  val >>= 1;
+  u8g_SetPILevel(u8g, U8G_PI_D6, val&1);
+  val >>= 1;
+  u8g_SetPILevel(u8g, U8G_PI_D7, val&1);
+  
+  /* EN cycle time must be 1 micro second  */
+  u8g_SetPILevel(u8g, U8G_PI_EN, 1);
+  u8g_MicroDelay(); /* delay by 1000ns, reference: ST7920: 140ns, SBN1661: 100ns */
+  u8g_SetPILevel(u8g, U8G_PI_EN, 0);
+  u8g_10MicroDelay(); /* ST7920 commands: 72us */
+  u8g_10MicroDelay(); /* ST7920 commands: 72us */
+}
+
+
+uint8_t u8g_com_atmega_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      /* setup the RW pin as output and force it to low */
+      u8g_SetPIOutput(u8g, U8G_PI_RW);
+      u8g_SetPILevel(u8g, U8G_PI_RW, 0);
+
+      u8g_SetPIOutput(u8g, U8G_PI_D0);
+      u8g_SetPIOutput(u8g, U8G_PI_D1);
+      u8g_SetPIOutput(u8g, U8G_PI_D2);
+      u8g_SetPIOutput(u8g, U8G_PI_D3);
+      u8g_SetPIOutput(u8g, U8G_PI_D4);
+      u8g_SetPIOutput(u8g, U8G_PI_D5);
+      u8g_SetPIOutput(u8g, U8G_PI_D6);
+      u8g_SetPIOutput(u8g, U8G_PI_D7);
+      u8g_SetPIOutput(u8g, U8G_PI_EN);
+      u8g_SetPIOutput(u8g, U8G_PI_CS1);
+      u8g_SetPIOutput(u8g, U8G_PI_CS2);
+      u8g_SetPIOutput(u8g, U8G_PI_DI);
+      u8g_SetPILevel(u8g, U8G_PI_CS1, 1);
+      u8g_SetPILevel(u8g, U8G_PI_CS2, 1);
+
+      break;
+    case U8G_COM_MSG_STOP:
+      break;
+    case U8G_COM_MSG_CHIP_SELECT:
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_SetPILevel(u8g, U8G_PI_CS1, 1);
+        u8g_SetPILevel(u8g, U8G_PI_CS2, 1);
+      }
+      else if ( arg_val == 1 )
+      {
+        /* enable */
+        u8g_SetPILevel(u8g, U8G_PI_CS1, 0);
+        u8g_SetPILevel(u8g, U8G_PI_CS2, 1);
+      }
+      else if ( arg_val == 2 )
+      {
+        /* enable */
+        u8g_SetPILevel(u8g, U8G_PI_CS1, 1);
+        u8g_SetPILevel(u8g, U8G_PI_CS2, 0);
+      }
+      else
+      {
+        /* enable */
+        u8g_SetPILevel(u8g, U8G_PI_CS1, 0);
+        u8g_SetPILevel(u8g, U8G_PI_CS2, 0);
+      }
+      break;
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_atmega_parallel_write(u8g, arg_val);
+      break;
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_atmega_parallel_write(u8g, *ptr++);
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_atmega_parallel_write(u8g, u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_SetPILevel(u8g, U8G_PI_DI, arg_val);
+      break;
+    case U8G_COM_MSG_RESET:
+      u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
+      break;
+  }
+  return 1;
+}
+
+#else
+
+uint8_t u8g_com_atmega_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+#endif /* ARDUINO */
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_atmega_st7920_hw_spi.c

@@ -0,0 +1,205 @@
+/*
+  
+  u8g_com_atmega_st7920_hw_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+  A special SPI interface for ST7920 controller with HW SPI Support
+
+  Assumes, that 
+    MOSI is at PORTB, Pin 3
+  and
+    SCK is at PORTB, Pin 5
+
+
+*/
+
+#include "u8g.h"
+
+#if defined(__AVR__)
+#define U8G_ATMEGA_HW_SPI
+
+/* remove the definition for attiny */
+#if __AVR_ARCH__ == 2
+#undef U8G_ATMEGA_HW_SPI
+#endif
+#if __AVR_ARCH__ == 25
+#undef U8G_ATMEGA_HW_SPI
+#endif
+
+#endif
+
+#if defined(U8G_ATMEGA_HW_SPI)
+
+#include <avr/interrupt.h>
+#include <avr/io.h>
+
+static uint8_t u8g_atmega_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE;
+static uint8_t u8g_atmega_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val)
+{
+  /* send data */
+  SPDR = val;
+  /* wait for transmission */
+  while (!(SPSR & (1<<SPIF))) 
+    ;
+  /* clear the SPIF flag by reading SPDR */
+  return  SPDR;
+}
+
+
+static void u8g_com_atmega_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val) U8G_NOINLINE;
+static void u8g_com_atmega_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val)
+{
+  uint8_t i;
+
+  if ( rs == 0 )
+  {
+    /* command */
+    u8g_atmega_st7920_hw_spi_shift_out(u8g, 0x0f8);
+  }
+  else if ( rs == 1 )
+  {
+    /* data */
+    u8g_atmega_st7920_hw_spi_shift_out(u8g, 0x0fa);
+  }
+  
+  u8g_atmega_st7920_hw_spi_shift_out(u8g, val & 0x0f0);
+  u8g_atmega_st7920_hw_spi_shift_out(u8g, val << 4);
+
+  for( i = 0; i < 4; i++ )
+    u8g_10MicroDelay();
+}
+
+
+uint8_t u8g_com_atmega_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_SetPIOutput(u8g, U8G_PI_CS);
+      //u8g_SetPIOutput(u8g, U8G_PI_A0);
+      
+      DDRB |= _BV(3);          /* D0, MOSI */
+      DDRB |= _BV(5);          /* SCK */
+      DDRB |= _BV(2);		/* slave select */
+    
+      PORTB &= ~_BV(3);        /* D0, MOSI = 0 */
+      PORTB &= ~_BV(5);        /* SCK = 0 */
+      u8g_SetPILevel(u8g, U8G_PI_CS, 1);
+
+      /*
+        SPR1 SPR0
+            0	0		fclk/4
+            0	1		fclk/16 
+            1	0		fclk/64  
+            1	1		fclk/128
+      */
+      SPCR = 0;
+      
+      /* maybe set CPOL and CPHA to 1 */
+      /* 20 Dez 2012: did set CPOL and CPHA to 1 in Arduino variant! */
+      SPCR =  (1<<SPE) | (1<<MSTR)|(0<<SPR1)|(0<<SPR0)|(0<<CPOL)|(0<<CPHA);
+#ifdef U8G_HW_SPI_2X
+      SPSR = (1 << SPI2X);  /* double speed, issue 89 */
+#endif
+      u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* inital RS state: command mode */
+      break;
+    
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_RESET:
+      u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
+      break;
+    
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
+      break;
+
+    case U8G_COM_MSG_CHIP_SELECT:      
+      if ( arg_val == 0 )
+      {
+        /* disable, note: the st7920 has an active high chip select */
+        u8g_SetPILevel(u8g, U8G_PI_CS, 0);
+      }
+      else
+      {
+        /* u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); */
+        /* enable */
+        u8g_SetPILevel(u8g, U8G_PI_CS, 1); /* CS = 1 (high active) */
+      }
+      break;
+      
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_atmega_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], arg_val);
+      //u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_atmega_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
+	  //u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+          arg_val--;
+        }
+      }
+      break;
+
+      case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_atmega_st7920_write_byte_hw_spi(u8g, u8g->pin_list[U8G_PI_A0_STATE], u8g_pgm_read(ptr));
+	  //u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+  }
+  return 1;
+}
+
+#else
+
+
+uint8_t u8g_com_atmega_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+
+#endif
+
+ 

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_atmega_st7920_spi.c

@@ -0,0 +1,170 @@
+/*
+  
+  u8g_com_atmega_st7920_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+  A special SPI interface for ST7920 controller
+
+*/
+
+#include "u8g.h"
+
+#if defined(__AVR__)
+
+static void u8g_atmega_st7920_sw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE;
+static void u8g_atmega_st7920_sw_spi_shift_out(u8g_t *u8g, uint8_t val)
+{
+  uint8_t i = 8;
+  do
+  {
+    u8g_SetPILevel(u8g, U8G_PI_MOSI, val & 128 );
+    val <<= 1;
+    u8g_SetPILevel(u8g, U8G_PI_SCK, 1 );
+    u8g_MicroDelay();		/* 15 Aug 2012: added for high speed uC */
+    u8g_SetPILevel(u8g, U8G_PI_SCK, 0 );
+    u8g_MicroDelay();		/* 15 Aug 2012: added for high speed uC */
+    i--;
+  } while( i != 0 );
+}
+
+static void u8g_com_atmega_st7920_write_byte(u8g_t *u8g, uint8_t rs, uint8_t val) U8G_NOINLINE;
+static void u8g_com_atmega_st7920_write_byte(u8g_t *u8g, uint8_t rs, uint8_t val)
+{
+  uint8_t i;
+  
+  if ( rs == 0 )
+  {
+    /* command */
+    u8g_atmega_st7920_sw_spi_shift_out(u8g, 0x0f8);
+  }
+  else if ( rs == 1 )
+  {
+    /* data */
+    u8g_atmega_st7920_sw_spi_shift_out(u8g, 0x0fa);
+  }
+  
+  u8g_atmega_st7920_sw_spi_shift_out(u8g, val & 0x0f0);
+  u8g_atmega_st7920_sw_spi_shift_out(u8g, val << 4);
+
+  for( i = 0; i < 4; i++ )
+    u8g_10MicroDelay();
+}
+
+
+uint8_t u8g_com_atmega_st7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_SetPIOutput(u8g, U8G_PI_SCK);
+      u8g_SetPIOutput(u8g, U8G_PI_MOSI);
+      /* u8g_SetPIOutput(u8g, U8G_PI_A0); */
+      u8g_SetPIOutput(u8g, U8G_PI_CS);
+      u8g_SetPIOutput(u8g, U8G_PI_RESET);
+      
+      u8g_SetPILevel(u8g, U8G_PI_SCK, 0 );
+      u8g_SetPILevel(u8g, U8G_PI_MOSI, 0 );
+      u8g_SetPILevel(u8g, U8G_PI_CS, 0 );
+      /* u8g_SetPILevel(u8g, U8G_PI_A0, 0); */
+    
+      u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* inital RS state: command mode */
+      break;
+    
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_RESET:
+      u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
+      break;
+    
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
+      break;
+
+    case U8G_COM_MSG_CHIP_SELECT:      
+      if ( arg_val == 0 )
+      {
+        /* disable, note: the st7920 has an active high chip select */
+        u8g_SetPILevel(u8g, U8G_PI_CS, 0);
+      }
+      else
+      {
+        /* u8g_SetPILevel(u8g, U8G_PI_SCK, 0 ); */
+        /* enable */
+        u8g_SetPILevel(u8g, U8G_PI_CS, 1); /* CS = 1 (high active) */
+      }
+      break;
+      
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_com_atmega_st7920_write_byte(u8g, u8g->pin_list[U8G_PI_A0_STATE], arg_val);
+      u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_atmega_st7920_write_byte(u8g, u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
+	  u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+          arg_val--;
+        }
+      }
+      break;
+
+      case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_com_atmega_st7920_write_byte(u8g, u8g->pin_list[U8G_PI_A0_STATE], u8g_pgm_read(ptr));
+	  u8g->pin_list[U8G_PI_A0_STATE] = 2; 
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+  }
+  return 1;
+}
+
+#else
+
+
+uint8_t u8g_com_atmega_st7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+
+#endif
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_atmega_sw_spi.c

@@ -0,0 +1,141 @@
+/*
+  
+  u8g_com_atmega_sw_spi.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+#if defined(__AVR__)
+
+static void u8g_atmega_sw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE;
+static void u8g_atmega_sw_spi_shift_out(u8g_t *u8g, uint8_t val)
+{
+  uint8_t i = 8;
+  do
+  {
+    u8g_SetPILevel(u8g, U8G_PI_MOSI, val & 128 );
+    val <<= 1;
+    u8g_SetPILevel(u8g, U8G_PI_SCK, 1 );
+    u8g_MicroDelay();		/* 15 Aug 2012: added for high speed uC */
+    u8g_SetPILevel(u8g, U8G_PI_SCK, 0 );
+    u8g_MicroDelay();		/* 15 Aug 2012: added for high speed uC */
+    i--;
+  } while( i != 0 );
+}
+
+uint8_t u8g_com_atmega_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      u8g_SetPIOutput(u8g, U8G_PI_SCK);
+      u8g_SetPIOutput(u8g, U8G_PI_MOSI);
+      u8g_SetPIOutput(u8g, U8G_PI_A0);
+      u8g_SetPIOutput(u8g, U8G_PI_CS);
+      u8g_SetPIOutput(u8g, U8G_PI_RESET);
+      
+      u8g_SetPILevel(u8g, U8G_PI_SCK, 0 );
+      u8g_SetPILevel(u8g, U8G_PI_MOSI, 0 );
+      u8g_SetPILevel(u8g, U8G_PI_CS, 1 );
+      u8g_SetPILevel(u8g, U8G_PI_A0, 0);
+      break;
+    
+    case U8G_COM_MSG_STOP:
+      break;
+
+    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
+      u8g_SetPILevel(u8g, U8G_PI_A0, arg_val);
+      break;
+
+    case U8G_COM_MSG_CHIP_SELECT:
+      
+      if ( arg_val == 0 )
+      {
+        /* disable */
+        u8g_SetPILevel(u8g, U8G_PI_CS, 1);
+      }
+      else
+      {
+        u8g_SetPILevel(u8g, U8G_PI_SCK, 0 );
+        /* enable */
+        u8g_SetPILevel(u8g, U8G_PI_CS, 0); /* CS = 0 (low active) */
+      }
+      break;
+      
+    case U8G_COM_MSG_RESET:
+      u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
+      break;
+    
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      u8g_atmega_sw_spi_shift_out(u8g, arg_val);
+      break;
+    
+    case U8G_COM_MSG_WRITE_SEQ:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_atmega_sw_spi_shift_out(u8g, *ptr++);
+          arg_val--;
+        }
+      }
+      break;
+
+      case U8G_COM_MSG_WRITE_SEQ_P:
+      {
+        register uint8_t *ptr = arg_ptr;
+        while( arg_val > 0 )
+        {
+          u8g_atmega_sw_spi_shift_out(u8g, u8g_pgm_read(ptr));
+          ptr++;
+          arg_val--;
+        }
+      }
+      break;
+  }
+  return 1;
+}
+
+#else
+
+
+uint8_t u8g_com_atmega_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  return 1;
+}
+
+
+#endif
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_i2c.c

@@ -0,0 +1,249 @@
+/*
+  
+  u8g_com_i2c.c
+
+  generic i2c interface
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+static uint8_t u8g_i2c_err_code;
+
+/*
+  position values
+    1: start condition
+    2: sla transfer
+*/
+static uint8_t u8g_i2c_err_pos;
+
+
+void u8g_i2c_clear_error(void)
+{
+  u8g_i2c_err_code = U8G_I2C_ERR_NONE;
+  u8g_i2c_err_pos = 0;
+}
+
+uint8_t  u8g_i2c_get_error(void)
+{
+  return u8g_i2c_err_code;
+}
+
+uint8_t u8g_i2c_get_err_pos(void)
+{
+  return u8g_i2c_err_pos;
+}
+
+static void u8g_i2c_set_error(uint8_t code, uint8_t pos)
+{
+  if ( u8g_i2c_err_code > 0 )
+    return;
+  u8g_i2c_err_code |= code;
+  u8g_i2c_err_pos = pos;
+}
+
+
+
+#if defined(__AVR__)
+#define U8G_ATMEGA_HW_TWI
+
+/* remove the definition for attiny */
+#if __AVR_ARCH__ == 2
+#undef U8G_ATMEGA_HW_TWI
+#endif
+#if __AVR_ARCH__ == 25
+#undef U8G_ATMEGA_HW_TWI
+#endif
+#endif
+
+#if defined(U8G_ATMEGA_HW_TWI)
+
+#include <avr/io.h>
+#include <util/twi.h>
+
+
+
+void u8g_i2c_init(uint8_t options)
+{
+  /*
+  TWBR: bit rate register
+  TWSR: status register (contains preselector bits)
+
+  prescalar
+    0		1
+    1		4
+    2		16
+    3		64
+
+  f = F_CPU/(16+2*TWBR*prescalar)
+  
+  F_CPU = 16MHz
+    TWBR = 152;
+    TWSR = 0;
+	--> 50KHz
+
+    TWBR = 72;
+    TWSR = 0;
+	--> 100KHz
+
+    F_CPU/(2*100000)-8  --> calculate TWBR value for 100KHz
+*/
+  TWSR = 0;
+  TWBR = F_CPU/(2*100000)-8;
+  u8g_i2c_clear_error();
+}
+
+uint8_t u8g_i2c_wait(uint8_t mask, uint8_t pos)
+{
+  volatile uint16_t cnt = 2000;	/* timout value should be > 280 for 50KHz Bus and 16 Mhz CPU, however the start condition might need longer */
+  while( !(TWCR & mask) )
+  {
+      if ( cnt == 0 )
+      {
+	u8g_i2c_set_error(U8G_I2C_ERR_TIMEOUT, pos);
+	return 0; /* error */
+      }
+      cnt--;
+    }
+  return 1;	/* all ok */
+}
+
+/* sla includes all 8 bits (with r/w bit), assums master transmit */
+uint8_t u8g_i2c_start(uint8_t sla)
+{
+  register uint8_t status;
+  
+  /* send start */
+  TWCR = _BV(TWINT) |  _BV(TWSTA)  |  _BV(TWEN);
+   
+  /* wait */
+  if ( u8g_i2c_wait(_BV(TWINT), 1) == 0 )
+    return 0;
+  
+  status = TW_STATUS;
+ 
+  /* check status after start */  
+  if ( status != TW_START && status != TW_REP_START )
+  {
+    u8g_i2c_set_error(U8G_I2C_ERR_BUS, 1);
+    return 0;
+  }
+
+  /* set slave address */  
+  TWDR = sla;
+  
+  /* enable sla transfer */
+  TWCR = _BV(TWINT)  |  _BV(TWEN);
+
+  /* wait */
+  if ( u8g_i2c_wait(_BV(TWINT), 2) == 0 )
+    return 0;
+  status = TW_STATUS;
+
+  /* check status after sla */  
+  if ( status != TW_MT_SLA_ACK )
+  {
+    u8g_i2c_set_error(U8G_I2C_ERR_BUS, 2);
+    return 0;
+  }
+
+   return 1;
+}
+
+uint8_t u8g_i2c_send_byte(uint8_t data)
+{
+  register uint8_t status;
+  TWDR = data;
+  TWCR = _BV(TWINT)  |  _BV(TWEN);
+  if ( u8g_i2c_wait(_BV(TWINT), 3) == 0 )
+    return 0;
+  status = TW_STATUS;
+  
+  if ( status != TW_MT_DATA_ACK )
+  {
+    u8g_i2c_set_error(U8G_I2C_ERR_BUS, 3);
+    return 0;
+  }
+  
+  return 1;  
+}
+
+void u8g_i2c_stop(void)
+{
+  /* write stop */
+  TWCR = _BV(TWINT) | _BV(TWEN) | _BV(TWSTO);
+
+  /* no error is checked for the stop condition */  
+  u8g_i2c_wait(_BV(TWSTO), 4);
+  
+}
+
+/*
+void twi_send(uint8_t adr, uint8_t data1, uint8_t data2)
+{
+  u8g_i2c_start(adr<<1);
+  u8g_i2c_send_byte(data1);
+  u8g_i2c_send_byte(data2);
+  u8g_i2c_stop();
+}
+*/
+
+#else
+
+/* empty interface */
+
+void u8g_i2c_init(uint8_t options)
+{
+  u8g_i2c_clear_error();
+}
+
+uint8_t u8g_i2c_wait(uint8_t mask, uint8_t pos)
+{
+  return 1;
+}
+
+uint8_t u8g_i2c_start(uint8_t sla)
+{
+  return 1;
+}
+uint8_t u8g_i2c_send_byte(uint8_t data)
+{
+  return 1;
+}
+
+void u8g_i2c_stop(void)
+{
+}
+
+
+#endif
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_io.c

@@ -0,0 +1,218 @@
+/*
+  
+  u8g_com_io.c
+  
+  abstraction layer for low level i/o 
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+#if defined(__AVR__)
+
+#include <avr/interrupt.h>
+#include <avr/io.h>
+
+typedef volatile uint8_t * IO_PTR;
+
+/* create internal pin number */
+uint8_t u8g_Pin(uint8_t port, uint8_t bitpos)
+{
+  port <<= 3;
+  port += bitpos;
+  return port;
+}
+
+const IO_PTR u8g_avr_ddr_P[] PROGMEM = {
+#ifdef DDRA
+  &DDRA,
+#else
+  0,
+#endif
+  &DDRB,
+#ifdef DDRC
+  &DDRC,
+#ifdef DDRD
+  &DDRD,
+#ifdef DDRE
+  &DDRE,
+#ifdef DDRF
+  &DDRF,
+#ifdef DDRG
+  &DDRG,
+#ifdef DDRH
+  &DDRH,
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+};
+
+
+const IO_PTR u8g_avr_port_P[] PROGMEM = {
+#ifdef PORTA
+  &PORTA,
+#else
+  0,
+#endif
+  &PORTB,
+#ifdef PORTC
+  &PORTC,
+#ifdef PORTD
+  &PORTD,
+#ifdef PORTE
+  &PORTE,
+#ifdef PORTF
+  &PORTF,
+#ifdef PORTG
+  &PORTG,
+#ifdef PORTH
+  &PORTH,
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+};
+
+const IO_PTR u8g_avr_pin_P[] PROGMEM = {
+#ifdef PINA
+  &PINA,
+#else
+  0,
+#endif
+  &PINB,
+#ifdef PINC
+  &PINC,
+#ifdef PIND
+  &PIND,
+#ifdef PINE
+  &PINE,
+#ifdef PINF
+  &PINF,
+#ifdef PING
+  &PING,
+#ifdef PINH
+  &PINH,
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+};
+
+static volatile uint8_t *u8g_get_avr_io_ptr(const IO_PTR *base, uint8_t offset)
+{
+  volatile uint8_t * tmp;
+  base += offset;
+  memcpy_P(&tmp, base, sizeof(volatile uint8_t * PROGMEM));
+  return tmp; 
+}
+
+/* set direction to output of the specified pin (internal pin number) */
+void u8g_SetPinOutput(uint8_t internal_pin_number)
+{
+  *u8g_get_avr_io_ptr(u8g_avr_ddr_P, internal_pin_number>>3) |= _BV(internal_pin_number&7);
+}
+
+void u8g_SetPinInput(uint8_t internal_pin_number)
+{
+  *u8g_get_avr_io_ptr(u8g_avr_ddr_P, internal_pin_number>>3) &= ~_BV(internal_pin_number&7);
+}
+
+void u8g_SetPinLevel(uint8_t internal_pin_number, uint8_t level)
+{
+  volatile uint8_t * tmp = u8g_get_avr_io_ptr(u8g_avr_port_P, internal_pin_number>>3);
+  
+  if ( level == 0 )
+    *tmp &= ~_BV(internal_pin_number&7);
+  else
+    *tmp |= _BV(internal_pin_number&7);
+}
+
+uint8_t u8g_GetPinLevel(uint8_t internal_pin_number)
+{
+  volatile uint8_t * tmp = u8g_get_avr_io_ptr(u8g_avr_pin_P, internal_pin_number>>3);
+  if ( ((*tmp) & _BV(internal_pin_number&7))  != 0 )
+    return 1;
+  return 0;
+}
+
+#else
+
+uint8_t u8g_Pin(uint8_t port, uint8_t bitpos)
+{
+  port <<= 3;
+  port += bitpos;
+  return port;
+}
+
+void u8g_SetPinOutput(uint8_t internal_pin_number)
+{
+}
+
+void u8g_SetPinInput(uint8_t internal_pin_number)
+{
+}
+
+void u8g_SetPinLevel(uint8_t internal_pin_number, uint8_t level)
+{
+}
+
+uint8_t u8g_GetPinLevel(uint8_t internal_pin_number)
+{
+  return 0;
+}
+
+#endif
+
+
+void u8g_SetPIOutput(u8g_t *u8g, uint8_t pi)
+{
+  uint8_t pin;
+  pin = u8g->pin_list[pi];
+  if ( pin != U8G_PIN_NONE )
+    u8g_SetPinOutput(pin);
+}
+
+void u8g_SetPILevel(u8g_t *u8g, uint8_t pi, uint8_t level)
+{
+  uint8_t pin;
+  pin = u8g->pin_list[pi];
+  if ( pin != U8G_PIN_NONE )
+    u8g_SetPinLevel(pin, level);
+}

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_com_null.c

@@ -0,0 +1,63 @@
+/*
+
+  u8g_com_null.c
+ 
+  communication null device
+
+  Universal 8bit Graphics Library
+ 
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+uint8_t u8g_com_null_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
+{
+  switch(msg)
+  {
+    case U8G_COM_MSG_INIT:
+      break;
+    case U8G_COM_MSG_STOP:
+      break;
+
+   
+    case U8G_COM_MSG_CHIP_SELECT:
+      /* arg_val contains the chip number, which should be enabled */
+      break;
+
+
+    case U8G_COM_MSG_WRITE_BYTE:
+      break;
+    case U8G_COM_MSG_WRITE_SEQ:
+      break;
+  }
+  return 1;
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_cursor.c

@@ -0,0 +1,99 @@
+/*
+
+  u8g_cursor.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+void u8g_SetCursorFont(u8g_t *u8g, const u8g_pgm_uint8_t *cursor_font)
+{
+  u8g->cursor_font = cursor_font;
+}
+
+void u8g_SetCursorStyle(u8g_t *u8g, uint8_t encoding)
+{
+  u8g->cursor_encoding = encoding;
+}
+
+void u8g_SetCursorColor(u8g_t *u8g, uint8_t fg, uint8_t bg)
+{
+  u8g->cursor_bg_color = bg;
+  u8g->cursor_fg_color = fg;
+}
+
+void u8g_SetCursorPos(u8g_t *u8g, u8g_uint_t cursor_x, u8g_uint_t cursor_y)
+{
+  u8g->cursor_x = cursor_x;
+  u8g->cursor_y = cursor_y;
+}
+
+void u8g_EnableCursor(u8g_t *u8g)
+{
+    u8g->cursor_fn = u8g_DrawCursor;
+}
+
+void u8g_DisableCursor(u8g_t *u8g)
+{
+    u8g->cursor_fn = (u8g_draw_cursor_fn)0;
+}
+
+void u8g_DrawCursor(u8g_t *u8g)
+{
+  const u8g_pgm_uint8_t *font;
+  uint8_t color;
+  uint8_t encoding = u8g->cursor_encoding;
+  
+  /* get current values */
+  color = u8g_GetColorIndex(u8g);
+  font = u8g->font;
+  
+  /* draw cursor */
+  u8g->font = u8g->cursor_font;  
+  encoding++;
+  u8g_SetColorIndex(u8g, u8g->cursor_bg_color); 
+  /* 27. Jan 2013: replaced call to u8g_DrawGlyph with call to u8g_draw_glyph */
+  /* required, because y adjustment should not happen to the cursor fonts */
+  u8g_draw_glyph(u8g, u8g->cursor_x, u8g->cursor_y, encoding);
+  encoding--;
+  u8g_SetColorIndex(u8g, u8g->cursor_fg_color); 
+  /* 27. Jan 2013: replaced call to u8g_DrawGlyph with call to u8g_draw_glyph */
+  /* required, because y adjustment should not happen to the cursor fonts */
+  /* u8g_DrawGlyph(u8g, u8g->cursor_x, u8g->cursor_y, encoding); */
+  u8g_draw_glyph(u8g, u8g->cursor_x, u8g->cursor_y, encoding);
+  
+  /* restore previous values */
+  u8g->font = font;
+  u8g_SetColorIndex(u8g, color); 
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_delay.c

@@ -0,0 +1,215 @@
+/*
+
+  u8g_delay.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+/*==== Part 1: Derive suitable delay procedure ====*/
+
+#if defined(ARDUINO)
+#  if defined(__AVR__)
+#    define USE_AVR_DELAY
+#  elif defined(__PIC32MX)
+#    define USE_PIC32_DELAY
+#  elif defined(__arm__)		/* Arduino Due */
+#    define USE_ARDUINO_DELAY
+#  else
+#    define USE_ARDUINO_DELAY
+#  endif
+#elif defined(__AVR__)
+#  define USE_AVR_DELAY
+#elif defined(__18CXX)
+#  define USE_PIC18_DELAY
+#else
+#  define USE_DUMMY_DELAY
+#endif
+
+
+
+/*==== Part 2: Definition of the delay procedures ====*/
+
+/*== AVR Delay ==*/
+
+#if defined(USE_AVR_DELAY)
+#include <avr/interrupt.h>
+#include <avr/io.h>
+#include <util/delay.h>
+
+/*
+  Delay by the provided number of milliseconds.
+  Thus, a 16 bit value will allow a delay of 0..65 seconds
+  Makes use of the _delay_loop_2
+  
+  _delay_loop_2 will do a delay of n * 4 prozessor cycles.
+  with f = F_CPU cycles per second,
+  n = f / (1000 * 4 )
+  with f = 16000000 the result is 4000
+  with f = 1000000 the result is 250
+  
+  the millisec loop, gcc requires the following overhead:
+  - movev 1
+  - subwi 2x2
+  - bne i 2
+  ==> 7 cycles
+  ==> must be devided by 4, rounded up 7/4 = 2
+*/
+void u8g_Delay(uint16_t val)
+{
+  /* old version did a call to the arduino lib: delay(val); */
+  while( val != 0 )
+  {
+    _delay_loop_2( (F_CPU / 4000 ) -2);
+    val--;
+  }
+}
+
+/* delay by one micro second */
+void u8g_MicroDelay(void)
+{
+#if (F_CPU / 4000000 ) > 0 
+  _delay_loop_2( (F_CPU / 4000000 ) );
+#endif
+}
+
+/* delay by 10 micro seconds */
+void u8g_10MicroDelay(void)
+{
+#if (F_CPU / 400000 ) > 0 
+  _delay_loop_2( (F_CPU / 400000 ) );
+#endif
+}
+
+#endif 
+
+
+/*== Delay for PIC18 (not tested) ==*/
+
+#if defined(USE_PIC18_DELAY)
+#include <delays.h>
+#define GetSystemClock()		(64000000ul)      // Hz
+#define GetInstructionClock()	(GetSystemClock()/4)
+
+void u8g_Delay(uint16_t val)
+{/*
+	unsigned int _iTemp = (val);
+	while(_iTemp--)		
+		Delay1KTCYx((GetInstructionClock()+999999)/1000000);
+		*/
+}
+void u8g_MicroDelay(void)
+{
+  /* not implemented */
+}
+void u8g_10MicroDelay(void)
+{
+  /* not implemented */
+}
+#endif
+
+
+/*== Arduino Delay ==*/
+#if defined(USE_ARDUINO_DELAY)
+void u8g_Delay(uint16_t val)
+{
+	delay(val);
+}
+void u8g_MicroDelay(void)
+{
+	delayMicroseconds(1);
+}
+void u8g_10MicroDelay(void)
+{
+	delayMicroseconds(10);
+}
+#endif
+
+#if defined(USE_PIC32_DELAY)
+/* 
+  Assume chipkit here with F_CPU correctly defined
+  The problem was, that u8g_Delay() is called within the constructor.
+  It seems that the chipkit is not fully setup at this time, so a
+  call to delay() will not work. So here is my own implementation.
+
+*/
+#define CPU_COUNTS_PER_SECOND (F_CPU/2UL)
+#define TICKS_PER_MILLISECOND  (CPU_COUNTS_PER_SECOND/1000UL)
+#include "plib.h"
+void u8g_Delay(uint16_t val)
+{
+	uint32_t d;
+	uint32_t s;
+	d = val;
+	d *= TICKS_PER_MILLISECOND;
+	s = ReadCoreTimer();
+	while ( (uint32_t)(ReadCoreTimer() - s) < d )
+		;
+} 
+
+void u8g_MicroDelay(void)
+{
+	uint32_t d;
+	uint32_t s;
+	d = TICKS_PER_MILLISECOND/1000;
+	s = ReadCoreTimer();
+	while ( (uint32_t)(ReadCoreTimer() - s) < d )
+		;
+} 
+
+void u8g_10MicroDelay(void)
+{
+	uint32_t d;
+	uint32_t s;
+	d = TICKS_PER_MILLISECOND/100;
+	s = ReadCoreTimer();
+	while ( (uint32_t)(ReadCoreTimer() - s) < d )
+		;
+} 
+
+#endif
+
+/*== Any other systems: Dummy Delay ==*/
+#if defined(USE_DUMMY_DELAY)
+void u8g_Delay(uint16_t val)
+{
+	/* do not know how to delay... */
+}
+void u8g_MicroDelay(void)
+{
+}
+void u8g_10MicroDelay(void)
+{
+}
+#endif

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_flipdisc_2x7.c

@@ -0,0 +1,92 @@
+/*
+
+  u8g_dev_flipdisc.c
+  
+  1-Bit (BW) Driver for flip disc matrix
+  2x 7 pixel height
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 28
+#define HEIGHT 14
+#define PAGE_HEIGHT 14
+
+/*
+  Write data to the flip disc matrix.
+  This procedure must be implemented by the user.
+  Arguments:
+    id:	Id for the matrix. Currently always 0.
+    page: 	A page has a height of 14 pixel. For a matrix with HEIGHT == 14 this will be always 0
+    width: 	The width of the flip disc matrix. Always equal to WIDTH
+    row1: 	first data line (7 pixel per byte)
+    row2: 	first data line (7 pixel per byte)
+*/
+void writeFlipDiscMatrix(uint8_t id, uint8_t page, uint8_t width, uint8_t *row1, uint8_t *row2);
+
+
+
+void (*u8g_write_flip_disc_matrix)(uint8_t id, uint8_t page, uint8_t width, uint8_t *row1, uint8_t *row2);
+
+void u8g_SetFlipDiscCallback(u8g_t *u8g, void (*cb)(uint8_t id, uint8_t page, uint8_t width, uint8_t *row1, uint8_t *row2))
+{
+  u8g_write_flip_disc_matrix = cb;
+}
+
+uint8_t u8g_dev_flipdisc_2x7_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+	/* current page: pb->p.page */
+	/* ptr to the buffer: pb->buf */
+	
+	(*u8g_write_flip_disc_matrix)(0, pb->p.page, WIDTH, pb->buf, pb->buf+WIDTH);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      return 1;
+  }
+  return u8g_dev_pb14v1_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_flipdisc_2x7_bw_buf[WIDTH*2] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_flipdisc_2x7_bw_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_flipdisc_2x7_bw_buf}; 
+u8g_dev_t u8g_dev_flipdisc_2x7 = { u8g_dev_flipdisc_2x7_bw_fn, &u8g_dev_flipdisc_2x7_bw_pb, u8g_com_null_fn };

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_gprof.c

@@ -0,0 +1,130 @@
+/*
+
+  u8g_dev_gprof.c
+
+  Device for performance measurement with gprof.
+  Does not write any data, but uses a buffer.
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+uint8_t u8g_dev_gprof_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+
+uint8_t u8g_pb_dev_gprof_buf[WIDTH];
+u8g_pb_t u8g_pb_dev_gprof = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0},  WIDTH, u8g_pb_dev_gprof_buf };
+
+u8g_dev_t u8g_dev_gprof = { u8g_dev_gprof_fn, &u8g_pb_dev_gprof, NULL };
+
+uint8_t u8g_dev_gprof_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      /*
+      {
+        uint8_t i, j;
+        uint8_t page_height;
+        page_height = pb->p.page_y1;
+        page_height -= pb->p.page_y0;
+        page_height++;
+        for( j = 0; j < page_height; j++ )
+        {
+          printf("%02d ", j);
+          for( i = 0; i < WIDTH; i++ )
+          {
+            if ( (u8g_pb_dev_stdout_buf[i] & (1<<j)) != 0 )
+              printf("#");
+            else
+              printf(".");
+          }
+          printf("\n");
+        }
+      }
+      */
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+      {
+        //printf("\n");
+        return 0;
+      }
+      u8g_pb_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+       {
+        u8g_dev_arg_bbx_t *bbx = (u8g_dev_arg_bbx_t *)arg;
+        u8g_uint_t x2, y2;
+
+        y2 = bbx->y;
+        y2 += bbx->h;
+        y2--;
+        
+        if ( u8g_pb_IsYIntersection(pb, bbx->y, y2) == 0 )
+          return 0;
+        
+        /* maybe this one can be skiped... probability is very high to have an intersection, so it would be ok to always return 1 */
+        x2 = bbx->x;
+        x2 += bbx->w;
+        x2--;
+        
+        if ( u8g_pb_IsXIntersection(pb, bbx->x, x2) == 0 )
+          return 0;
+      }
+      return 1;
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ili9325d_320x240.c

@@ -0,0 +1,326 @@
+/*
+
+  u8g_dev_ili9325d_320x240.c
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+  Color format
+    Red: 5 Bit
+    Green: 6 Bit
+    Blue: 5 Bit
+  
+    
+*/
+
+#include "u8g.h"
+
+#define WIDTH 240
+
+#if defined(U8G_16BIT)
+#define HEIGHT 320
+#else
+/* if the user tries to compile the 8Bit version of the lib, then restrict the height to something which fits to 8Bit */
+#define HEIGHT 240
+#endif
+#define PAGE_HEIGHT 4
+
+
+/*
+  reference board for this device:
+    http://iteadstudio.com/store/index.php?main_page=product_info&cPath=57_58&products_id=55
+  documentation:
+    http://iteadstudio.com/Downloadfile/ITDB02_material.rar
+  datasheet
+    http://www.newhavendisplay.com/app_notes/ILI9325D.pdf
+  other libs
+    http://henningkarlsen.com/electronics/library.php
+  init sequence
+    http://code.google.com/p/itdb02/, ITDB02.cpp, iteadstudio.com
+*/
+
+static const uint8_t u8g_dev_ili9325d_320x240_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  
+  //U8G_ESC_ADR(0),  0x000, 0x0E5,               /* only used for none D version: set SRAM internal timing */
+  //U8G_ESC_ADR(1),  0x078, 0x0f0,             
+  U8G_ESC_ADR(0),  0x000, 0x001,               /* Driver Output Control, bits 8 & 10 */
+  U8G_ESC_ADR(1),  0x001, 0x000,           
+  U8G_ESC_ADR(0),  0x000, 0x002,               /* LCD Driving Wave Control, bit 9: Set line inversion */
+  U8G_ESC_ADR(1),  0x002, 0x000,               /* ITDB02 none D verion: 0x007, 0x000 */        
+  U8G_ESC_ADR(0),  0x000, 0x003,               /* Entry Mode, GRAM write direction and BGR=1 */
+  U8G_ESC_ADR(1),  0x010, 0x030,           
+  U8G_ESC_ADR(0),  0x000, 0x004,               /* Resize register */
+  U8G_ESC_ADR(1),  0x000, 0x000,           
+  U8G_ESC_ADR(0),  0x000, 0x008,               /* Display Control 2: set the back porch and front porch */
+  U8G_ESC_ADR(1),  0x002, 0x007,           
+  
+  U8G_ESC_ADR(0),  0x000, 0x009,               /* Display Control 3 */
+  U8G_ESC_ADR(1),  0x000, 0x000,           
+
+  U8G_ESC_ADR(0),  0x000, 0x00a,               /* Display Control 4: FMARK */
+  U8G_ESC_ADR(1),  0x000, 0x000,           
+  U8G_ESC_ADR(0),  0x000, 0x00c,               /* RGB Display Interface Control 1 */
+  U8G_ESC_ADR(1),  0x000, 0x000,           
+  U8G_ESC_ADR(0),  0x000, 0x00d,               /* Frame Maker Position */
+  U8G_ESC_ADR(1),  0x000, 0x000,           
+  U8G_ESC_ADR(0),  0x000, 0x00f,                /* RGB Display Interface Control 2 */
+  U8G_ESC_ADR(1),  0x000, 0x000,  
+  U8G_ESC_ADR(0),  0x000, 0x010,               /* Power Control 1: SAP, BT[3:0], AP, DSTB, SLP, STB */
+  U8G_ESC_ADR(1),  0x000, 0x000,  
+  U8G_ESC_ADR(0),  0x000, 0x011,               /* Power Control 2: DC1[2:0], DC0[2:0], VC[2:0] */
+  U8G_ESC_ADR(1),  0x000, 0x007,  
+  U8G_ESC_ADR(0),  0x000, 0x012,               /* Power Control 3: VREG1OUT voltage */
+  U8G_ESC_ADR(1),  0x000, 0x000,  
+  U8G_ESC_ADR(0),  0x000, 0x013,               /* Power Control 4: VDV[4:0] for VCOM amplitude */
+  U8G_ESC_ADR(1),  0x000, 0x000,  
+  U8G_ESC_ADR(0),  0x000, 0x007,               /* Display Control 1: Operate, but do not display */
+  U8G_ESC_ADR(1),  0x000, 0x001,   
+  
+  U8G_ESC_DLY(100),         /* delay 100 ms */  /*  ITDB02 none D verion:  50ms */
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+  U8G_ESC_ADR(0),  0x000, 0x010,               /* Power Control 1: SAP, BT[3:0], AP, DSTB, SLP, STB */
+  U8G_ESC_ADR(1),  0x016, 0x090,               /*  ITDB02 none D verion:  0x010, 0x090 */
+  U8G_ESC_ADR(0),  0x000, 0x011,               /* Power Control 2: SAP, BT[3:0], AP, DSTB, SLP, STB */
+  U8G_ESC_ADR(1),  0x002, 0x027,
+
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  U8G_ESC_ADR(0),  0x000, 0x012,               /* Power Control 3: VCI: External, VCI*1.80 */
+  U8G_ESC_ADR(1),  0x000, 0x00d,               /*  ITDB02 none D verion:  0x000, 0x01f */
+
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  U8G_ESC_ADR(0),  0x000, 0x013,               /* Power Control 4: VDV[4:0] for VCOM amplitude */
+  U8G_ESC_ADR(1),  0x012, 0x000,               /*  ITDB02 none D verion:  0x015, 0x000 */
+  U8G_ESC_ADR(0),  0x000, 0x029,               /* Power Control 7 */
+  U8G_ESC_ADR(1),  0x000, 0x00a,               /*  ITDB02 none D verion:  0x000, 0x027 */
+  U8G_ESC_ADR(0),  0x000, 0x02b,               /* Frame Rate: 83 */
+  U8G_ESC_ADR(1),  0x000, 0x00d,
+
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  U8G_ESC_ADR(0),  0x000, 0x020,               /* Horizontal GRAM Address Set */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x021,               /* Vertical GRAM Address Set */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+
+  /* gamma control */
+  U8G_ESC_ADR(0),  0x000, 0x030,               
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x031,
+  U8G_ESC_ADR(1),  0x004, 0x004,
+  U8G_ESC_ADR(0),  0x000, 0x032,
+  U8G_ESC_ADR(1),  0x000, 0x003,
+  U8G_ESC_ADR(0),  0x000, 0x035,               
+  U8G_ESC_ADR(1),  0x004, 0x005,
+  U8G_ESC_ADR(0),  0x000, 0x036,               
+  U8G_ESC_ADR(1),  0x008, 0x008,
+  U8G_ESC_ADR(0),  0x000, 0x037,               
+  U8G_ESC_ADR(1),  0x004, 0x007,
+  U8G_ESC_ADR(0),  0x000, 0x038,               
+  U8G_ESC_ADR(1),  0x003, 0x003,
+  U8G_ESC_ADR(0),  0x000, 0x039,               
+  U8G_ESC_ADR(1),  0x007, 0x007,
+  U8G_ESC_ADR(0),  0x000, 0x03c,               
+  U8G_ESC_ADR(1),  0x005, 0x004,
+  U8G_ESC_ADR(0),  0x000, 0x03d,               
+  U8G_ESC_ADR(1),  0x008, 0x008,
+  
+  U8G_ESC_ADR(0),  0x000, 0x050,               /* Horizontal GRAM Start Address */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x051,               /* Horizontal GRAM End Address: 239 */
+  U8G_ESC_ADR(1),  0x000, 0x0EF,
+  U8G_ESC_ADR(0),  0x000, 0x052,               /* Vertical GRAM Start Address */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x053,               /* Vertical GRAM End Address: 319 */
+  U8G_ESC_ADR(1),  0x001, 0x03F,
+  
+  U8G_ESC_ADR(0),  0x000, 0x060,               /* Driver Output Control 2 */
+  U8G_ESC_ADR(1),  0x0a7, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x061,               /* Base Image Display Control: NDL,VLE, REV */
+  U8G_ESC_ADR(1),  0x000, 0x001,
+  U8G_ESC_ADR(0),  0x000, 0x06a,               /* Vertical Scroll Control */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+
+  U8G_ESC_ADR(0),  0x000, 0x080,               /* Partial Image 1 Display Position */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x081,               /* Partial Image 1 RAM Start Address */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x082,               /* Partial Image 1 RAM End Address */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x083,               /* Partial Image 2 Display Position */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x084,               /* Partial Image 2 RAM Start Address */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x085,               /* Partial Image 2 RAM End Address */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+
+  U8G_ESC_ADR(0),  0x000, 0x090,               /* Panel Interface Control 1 */
+  U8G_ESC_ADR(1),  0x000, 0x010,
+  U8G_ESC_ADR(0),  0x000, 0x092,               /* Panel Interface Control 2 */
+  U8G_ESC_ADR(1),  0x000, 0x000,        /* 0x006, 0x000 */
+
+  U8G_ESC_ADR(0),  0x000, 0x007,               /* Display Control 1: Operate, display ON */
+  U8G_ESC_ADR(1),  0x001, 0x033,   
+
+  U8G_ESC_DLY(10),               /* delay 10 ms */
+  
+  /* write test pattern */  
+  U8G_ESC_ADR(0),  0x000, 0x020,               /* Horizontal GRAM Address Set */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x021,               /* Vertical GRAM Address Set */
+  U8G_ESC_ADR(1),  0x000, 0x010,
+  U8G_ESC_ADR(0),  0x000, 0x022,               /* Write Data to GRAM */
+  U8G_ESC_ADR(1),  0x0fe, 0x0fe,
+  0x000, 0x000,
+  0x0fe, 0x0fe,
+  0x000, 0x000,
+  0x0fe, 0x0fe,
+  0x000, 0x000,
+  0x0fe, 0x0fe,
+  0x000, 0x000,
+  0x0fe, 0x0fe,
+  0x000, 0x000,
+  0x0fe, 0x0fe,
+  0x000, 0x000,
+  0x0fe, 0x0fe,
+  0x000, 0x000,
+  0x0fe, 0x0fe,
+  0x000, 0x000,
+  0x0fe, 0x0fe,
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+static const uint8_t u8g_dev_ili9325d_320x240_page_seq[] PROGMEM = {
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_ADR(0),  0x000, 0x020,               /* Horizontal GRAM Address Set */
+  U8G_ESC_ADR(1),  0x000, 0x000,
+  U8G_ESC_ADR(0),  0x000, 0x021,               /* Vertical GRAM Address Set */
+  U8G_ESC_ADR(1), 
+  U8G_ESC_END                /* end of sequence */
+};
+
+/* convert the internal RGB 332 to 65K high byte */
+static uint8_t u8g_dev_ili9325d_get_65K_high_byte(uint8_t color)
+{
+  uint8_t h;
+  h = color;
+  h &= 0x0e0;
+  h |= h>>3;
+  h &= 0x0f8;
+  color>>=2;
+  color &= 7;
+  h |= color;
+  return h;  
+}
+
+/* convert the internal RGB 332 to 65K high byte */
+static uint8_t u8g_dev_ili9325d_get_65K_low_byte(uint8_t color)
+{
+  uint8_t l;
+  l = color;
+  l <<= 3;
+  color &= 3;
+  color <<= 1;
+  l |= color;
+  return l;  
+}
+
+
+uint8_t u8g_dev_ili9325d_320x240_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      //for(;;)
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_ili9325d_320x240_init_seq);
+    
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t i;
+        uint16_t y, j;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        for( i = 0; i < pb->p.page_height; i ++ )
+        {
+          u8g_WriteEscSeqP(u8g, dev, u8g_dev_ili9325d_320x240_page_seq);
+          u8g_WriteByte(u8g, dev, y >> 8 );      /* display ram (cursor) address high byte */
+          u8g_WriteByte(u8g, dev, y & 255 );      /* display ram (cursor) address low byte */
+
+          u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0 );  
+          u8g_WriteByte(u8g, dev, 0x022 );      /* start gram data */  
+          
+          u8g_SetAddress(u8g, dev, 1);           /* data mode */
+          
+          for( j = 0; j < pb->width; j++ )
+          {
+            u8g_WriteByte(u8g, dev, u8g_dev_ili9325d_get_65K_high_byte(*ptr) );  
+            u8g_WriteByte(u8g, dev, u8g_dev_ili9325d_get_65K_low_byte(*ptr) );  
+              
+            ptr++;
+          }
+          y++;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h8_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_ili9325d_320x240_8h8_buf[WIDTH*PAGE_HEIGHT] U8G_NOCOMMON ; 
+u8g_pb_t u8g_ili9325d_320x240_8h8_pb U8G_NOCOMMON = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0},  WIDTH, u8g_ili9325d_320x240_8h8_buf}; 
+u8g_dev_t u8g_dev_ili9325d_320x240_8bit U8G_NOCOMMON = { u8g_dev_ili9325d_320x240_fn, &u8g_ili9325d_320x240_8h8_pb, u8g_com_arduino_port_d_wr_fn };
+//u8g_dev_t u8g_dev_ili9325d_320x240_8bit = { u8g_dev_ili9325d_320x240_fn, &u8g_ili9325d_320x240_8h8_pb, u8g_com_arduino_parallel_fn };
+
+//U8G_PB_DEV(u8g_dev_ili9325d_320x240_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ili9325d_320x240_fn, U8G_COM_PARALLEL);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ks0108_128x64.c

@@ -0,0 +1,110 @@
+/*
+
+  u8g_dev_ks0108_128x64.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+
+  ADDRESS = 0   (Command Mode)
+    0x03f       Display On
+    0x0c0       Start Display at line 0
+    0x040 | y   write to y address (y:0..63)
+    0x0b8 | x   write to page [0..7]
+
+
+  u8g_Init8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset)
+  u8g_Init8Bit(u8g, dev,  8,    9, 10, 11,   4,   5,   6,   7, 18, 14, 15, 17, 16, U8G_PIN_NONE)
+  
+*/
+
+#include "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+static const uint8_t u8g_dev_ks0108_128x64_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip 1 */
+  0x03f,		                /* display on */
+  0x0c0,		                /* start at line 0 */
+  U8G_ESC_DLY(20),         /* delay 20 ms */
+  U8G_ESC_CS(2),             /* enable chip 2 */
+  0x03f,		                /* display on */
+  0x0c0,		                /* start at line 0 */
+  U8G_ESC_DLY(20),         /* delay 20 ms */
+  U8G_ESC_CS(0),             /* disable all chips */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+uint8_t u8g_dev_ks0108_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ks0108_128x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* command mode */
+        u8g_SetChipSelect(u8g, dev, 2);
+        u8g_WriteByte(u8g, dev, 0x0b8 | pb->p.page); /* select current page (KS0108b) */
+        u8g_WriteByte(u8g, dev, 0x040 );		/* set address 0 */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        u8g_WriteSequence(u8g, dev, 64, pb->buf);
+        u8g_SetChipSelect(u8g, dev, 0);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* command mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        u8g_WriteByte(u8g, dev, 0x0b8 | pb->p.page); /* select current page (KS0108b) */
+        u8g_WriteByte(u8g, dev, 0x040 );		/* set address 0 */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        u8g_WriteSequence(u8g, dev, 64, 64+(uint8_t *)pb->buf);
+        u8g_SetChipSelect(u8g, dev, 0);
+        
+      }
+      break;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_ks0108_128x64, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ks0108_128x64_fn, U8G_COM_PARALLEL);
+U8G_PB_DEV(u8g_dev_ks0108_128x64_fast, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ks0108_128x64_fn, U8G_COM_FAST_PARALLEL);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_lc7981_160x80.c

@@ -0,0 +1,147 @@
+/*
+
+  u8g_dev_lc7981_160x80.c
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 160
+#define HEIGHT 80
+#define PAGE_HEIGHT 8
+
+
+/*
+  code ideas: 
+  https://github.com/vsergeev/embedded-drivers/tree/master/avr-lc7981
+  data sheets:
+  http://www.lcd-module.de/eng/pdf/zubehoer/lc7981.pdf
+  http://www.lcd-module.de/pdf/grafik/w160-6.pdf
+*/
+
+static const uint8_t u8g_dev_lc7981_160x80_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(1),           /* instruction mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x000,                                /* mode register */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x032,                                /* display on (bit 5), master mode on (bit 4), graphics mode on (bit 1)*/
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x001,                                /* character/bits per pixel pitch */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x007,                                /* 8 bits per pixel */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x002,                                /* number of chars/byte width of the screen */
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8-1,                         /* 8 bits per pixel */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x003,                                /* time division */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x07f,                                /*  */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x008,                                /* display start low */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /*  */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x009,                                /* display start high */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /*  */
+    
+  U8G_ESC_DLY(10),               /* delay 10 ms */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_lc7981_160x80_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_lc7981_160x80_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint16_t disp_ram_adr;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        disp_ram_adr = WIDTH/8;
+        disp_ram_adr *= y;
+        for( i = 0; i < 8; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00a );      /* display ram (cursor) address low byte */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr & 0x0ff );  
+
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00b );      /* display ram (cursor) address hight byte */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr >> 8 );  
+          
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00c );      /* write data */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          disp_ram_adr += WIDTH/8;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h1f_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_lc7981_160x80_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_lc7981_160x80_fn, U8G_COM_FAST_PARALLEL);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_lc7981_240x128.c

@@ -0,0 +1,145 @@
+/*
+
+  u8g_dev_lc7981_240x128.c
+  
+  Hitachi Display SP14N002
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 240
+#define HEIGHT 128
+#define PAGE_HEIGHT 8
+
+
+/*
+  http://www.mark-products.com/graphics.htm#240x128%20Pixel%20Format
+*/
+
+static const uint8_t u8g_dev_lc7981_240x128_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(1),           /* instruction mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x000,                                /* mode register */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x032,                                /* display on (bit 5), master mode on (bit 4), graphics mode on (bit 1)*/
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x001,                                /* character/bits per pixel pitch */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x007,                                /* 8 bits per pixel */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x002,                                /* number of chars/byte width of the screen */
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8-1,                         /* 8 bits per pixel */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x003,                                /* time division */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x07f,                                /*  */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x008,                                /* display start low */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /*  */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x009,                                /* display start high */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /*  */
+    
+  U8G_ESC_DLY(10),               /* delay 10 ms */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_lc7981_240x128_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_lc7981_240x128_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint16_t disp_ram_adr;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        disp_ram_adr = WIDTH/8;
+        disp_ram_adr *= y;
+        for( i = 0; i < 8; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00a );      /* display ram (cursor) address low byte */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr & 0x0ff );  
+
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00b );      /* display ram (cursor) address hight byte */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr >> 8 );  
+          
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00c );      /* write data */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          disp_ram_adr += WIDTH/8;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h1f_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_lc7981_240x128_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_lc7981_240x128_fn, U8G_COM_FAST_PARALLEL);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_lc7981_240x64.c

@@ -0,0 +1,145 @@
+/*
+
+  u8g_dev_lc7981_240x64.c
+  
+  Tested with Nan Ya LM_J6_003_
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 240
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+
+/*
+  http://www.mark-products.com/graphics.htm#240x64%20Pixel%20Format
+*/
+
+static const uint8_t u8g_dev_lc7981_240x64_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(1),           /* instruction mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x000,                                /* mode register */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x032,                                /* display on (bit 5), master mode on (bit 4), graphics mode on (bit 1)*/
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x001,                                /* character/bits per pixel pitch */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x007,                                /* 8 bits per pixel */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x002,                                /* number of chars/byte width of the screen */
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8-1,                         /* 8 bits per pixel */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x003,                                /* time division */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x07f,                                /*  */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x008,                                /* display start low */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /*  */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x009,                                /* display start high */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /*  */
+    
+  U8G_ESC_DLY(10),               /* delay 10 ms */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_lc7981_240x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_lc7981_240x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint16_t disp_ram_adr;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        disp_ram_adr = WIDTH/8;
+        disp_ram_adr *= y;
+        for( i = 0; i < 8; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00a );      /* display ram (cursor) address low byte */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr & 0x0ff );  
+
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00b );      /* display ram (cursor) address hight byte */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr >> 8 );  
+          
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00c );      /* write data */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          disp_ram_adr += WIDTH/8;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h1f_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_lc7981_240x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_lc7981_240x64_fn, U8G_COM_FAST_PARALLEL);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_lc7981_320x64.c

@@ -0,0 +1,145 @@
+/*
+
+  u8g_dev_lc7981_320x64.c
+
+  Note: Requires 16 bit mode (Must be enabled in u8g.h)
+  
+  Tested with Varitronix MGLS32064-03.pdf
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 320
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+
+/*
+  http://www.gaw.ru/pdf/lcd/lcm/Varitronix/graf/MGLS32064-03.pdf
+*/
+
+static const uint8_t u8g_dev_lc7981_320x64_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(1),           /* instruction mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x000,                                /* mode register */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x032,                                /* display on (bit 5), master mode on (bit 4), graphics mode on (bit 1)*/
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x001,                                /* character/bits per pixel pitch */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x007,                                /* 8 bits per pixel */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x002,                                /* number of chars/byte width of the screen */
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8-1,                         /* 8 bits per pixel */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x003,                                /* time division */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x07f,                                /*  */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x008,                                /* display start low */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /*  */
+
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x009,                                /* display start high */
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /*  */
+    
+  U8G_ESC_DLY(10),               /* delay 10 ms */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_lc7981_320x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_lc7981_320x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint16_t disp_ram_adr;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        disp_ram_adr = WIDTH/8;
+        disp_ram_adr *= y;
+        for( i = 0; i < 8; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00a );      /* display ram (cursor) address low byte */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr & 0x0ff );  
+
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00b );      /* display ram (cursor) address hight byte */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr >> 8 );  
+          
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x00c );      /* write data */
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          disp_ram_adr += WIDTH/8;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h1f_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_lc7981_320x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_lc7981_320x64_fn, U8G_COM_FAST_PARALLEL);

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_null.c

@@ -0,0 +1,67 @@
+/*
+
+  u8g_dev_null.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+uint8_t u8g_dev_null(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:                /* most often used command */
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return 1;
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+  }
+  return 1;
+}

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_pcd8544_84x48.c

@@ -0,0 +1,110 @@
+/*
+
+  u8g_dev_pcd8544_84x48.c
+  
+  Display: Nokia 84x48
+  
+  Status: Tested with PCF8812 Display
+  
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 84
+#define HEIGHT 48
+#define PAGE_HEIGHT 8
+
+
+static const uint8_t u8g_dev_pcd8544_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x021,		/* activate chip (PD=0), horizontal increment (V=0), enter extended command set (H=1) */
+  0x006,		/* temp. control: b10 = 2 */
+  0x013,		/* bias system 1:48 */
+  0x0c0,		/* medium Vop */
+  0x020,		/* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00c,		/* display on, normal operation */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00d,		                /* display on, invert */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00c,		                /* display on, normal */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_pcd8544_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_pcd8544_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_SetAddress(u8g, dev, 0);           /* command mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        u8g_WriteByte(u8g, dev, 0x020 );		/* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+        u8g_WriteByte(u8g, dev, 0x080 );                        /* set X address */
+        u8g_WriteByte(u8g, dev, 0x040 | pb->p.page); /* set Y address */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      /* the contrast adjustment does not work, needs to be analysed */
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_WriteByte(u8g, dev, 0x021);        /* command mode, extended function set */
+      u8g_WriteByte(u8g, dev, 0x080 | ( (*(uint8_t *)arg) >> 1 ) );
+      u8g_SetChipSelect(u8g, dev, 0);
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+
+U8G_PB_DEV(u8g_dev_pcd8544_84x48_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_pcd8544_fn, U8G_COM_SW_SPI);
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_pcf8812_96x65.c

@@ -0,0 +1,123 @@
+/*
+
+  u8g_dev_pcf8812_96x65.c
+  
+  Display: Nokia 96x65
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+
+  
+  om6206        comaptible to pcf8812 ?
+  
+  Status: Tested 
+
+
+  Display                                               Controller              Seen in
+  LPH7366 (9 pins, 84x48)                       PCD8544                Nokia 5110 / 5120 / 5130 / 5160 / 6110 / 6150 
+  LPH7677 (8 pins, 84x48)                       PCD8544                         Nokia 3210
+  LPH7779 (8 pins, 84x48)                       PCD8544                         Nokia 3310 / 3315 / 3330 / 3110, also 3410?
+  ???                                                          PCD8544                          Nokia 5110 / 6110
+  LPH7690 ?  (96x65)                                 PCF8455/OM6202          Nokia 3410
+  LPH7690 ? (96x65?)                               SED1565/S1D15605        Nokia 7110 / 3510?
+  LPH7690                                                     ???                                     Nokia 6210
+
+
+  
+*/
+
+#include "u8g.h"
+
+#define WIDTH 96
+#define HEIGHT 65
+#define PAGE_HEIGHT 8
+
+
+static const uint8_t u8g_dev_pcf8812_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x021,		                /* activate chip (PD=0), horizontal increment (V=0), enter extended command set (H=1) */
+  0x006,		                /* temp. control: b10 = 2 */
+  0x013,		                /* bias system 1:48 */
+  0x080 | 0x040,		/* medium Vop */
+  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00c,		                /* display on, normal operation */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00d,		                /* display on, invert */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00c,		                /* display on, normal */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_pcf8812_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_pcf8812_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_SetAddress(u8g, dev, 0);           /* command mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        u8g_WriteByte(u8g, dev, 0x020 );		/* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+        u8g_WriteByte(u8g, dev, 0x080 );                        /* set X address */
+        u8g_WriteByte(u8g, dev, 0x040 | pb->p.page); /* set Y address */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      /* the contrast adjustment does not work, needs to be analysed */
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_WriteByte(u8g, dev, 0x021);        /* command mode, extended function set */
+      u8g_WriteByte(u8g, dev, 0x080 | ( (*(uint8_t *)arg) >> 1 ) );
+      u8g_SetChipSelect(u8g, dev, 0);
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+/* u8g_com_arduino_sw_spi_fn does not work, too fast??? */
+U8G_PB_DEV(u8g_dev_pcf8812_96x65_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_pcf8812_fn, U8G_COM_SW_SPI);

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_sbn1661_122x32.c

@@ -0,0 +1,107 @@
+/*
+
+  u8g_dev_sbn1661_122x32.c
+  
+  WG12232 display with 2xSBN1661 / SED1520 controller (122x32 display)
+  At the moment only available in the Arduino Environment
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 122
+#define HEIGHT 32
+#define PAGE_HEIGHT 8
+
+
+static const uint8_t u8g_dev_sbn1661_122x32_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip 1 */
+  0x0af,				/* display on */
+  0x0c0,				/* display start at line 0 */
+  0x0a0,				/* a0: ADC forward, a1: ADC reverse */
+  0x0a9,				/* a8: 1/16, a9: 1/32 duty */
+  U8G_ESC_CS(2),             /* enable chip 2 */
+  0x0af,				/* display on */
+  0x0c0,				/* display start at line 0 */
+  0x0a0,				/* a0: ADC forward, a1: ADC reverse */
+  0x0a9,				/* a8: 1/16, a9: 1/32 duty */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  
+  
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_sbn1661_122x32_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_sbn1661_122x32_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	
+        u8g_SetAddress(u8g, dev, 0);           /* command mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        u8g_WriteByte(u8g, dev, 0x0b8 | pb->p.page); /* select current page (SBN1661/SED1520) */
+        u8g_WriteByte(u8g, dev, 0x000 ); /* set X address */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        u8g_WriteSequence(u8g, dev, WIDTH/2, pb->buf);
+	
+        u8g_SetAddress(u8g, dev, 0);           /* command mode */
+        u8g_SetChipSelect(u8g, dev, 2);
+        u8g_WriteByte(u8g, dev, 0x0b8 | pb->p.page); /* select current page (SBN1661/SED1520) */
+        u8g_WriteByte(u8g, dev, 0x000 ); /* set X address */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        u8g_WriteSequence(u8g, dev, WIDTH/2, WIDTH/2+(uint8_t *)pb->buf);
+	
+        u8g_SetChipSelect(u8g, dev, 0);
+	
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      break;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+/* u8g_com_arduino_sw_spi_fn does not work, too fast??? */
+U8G_PB_DEV(u8g_dev_sbn1661_122x32 , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_sbn1661_122x32_fn, u8g_com_arduino_no_en_parallel_fn);

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1306_128x32.c

@@ -0,0 +1,247 @@
+/*
+
+  u8g_dev_ssd1306_128x32.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+  
+  23 Feb 2013: Fixed, Issue 147
+
+*/
+
+
+#include "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 32
+#define PAGE_HEIGHT 8
+
+
+/* init sequence adafruit 128x32 OLED (NOT TESTED) */
+static const uint8_t u8g_dev_ssd1306_128x32_adafruit1_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),        /* disable chip */
+  U8G_ESC_ADR(0),       /* instruction mode */
+  U8G_ESC_RST(1),       /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),        /* enable chip */
+
+  0x0ae,				/* display off, sleep mode */
+  0x0d5, 0x080,			/* clock divide ratio (0x00=1) and oscillator frequency (0x8) */
+  0x0a8, 0x03f,			/* */
+
+  0x0d3, 0x000,			/*  */
+
+  0x040,				/* start line */
+  
+  0x08d, 0x010,			/* [1] charge pump setting (p62): 0x014 enable, 0x010 disable */
+
+  0x020, 0x000,			/* */
+  0x0a1,				/* segment remap a0/a1*/
+  0x0c8,				/* c0: scan dir normal, c8: reverse */
+  0x0da, 0x012,			/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */
+  0x081, 0x09f,			/* [1] set contrast control */
+  0x0d9, 0x022,			/* [1] pre-charge period 0x022/f1*/
+  0x0db, 0x040,			/* vcomh deselect level */
+  
+  0x02e,				/* 2012-05-27: Deactivate scroll */ 
+  0x0a4,				/* output ram to display */
+  0x0a6,				/* none inverted normal display mode */
+  0x0af,				/* display on */
+
+  U8G_ESC_CS(0),        /* disable chip */
+  U8G_ESC_END           /* end of sequence */
+};
+
+
+/* init sequence adafruit 128x32 OLED (NOT TESTED) */
+static const uint8_t u8g_dev_ssd1306_128x32_adafruit2_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),        /* disable chip */
+  U8G_ESC_ADR(0),       /* instruction mode */
+  U8G_ESC_RST(1),       /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),        /* enable chip */
+
+  0x0ae,				/* display off, sleep mode */
+  0x0d5, 0x080,			/* clock divide ratio (0x00=1) and oscillator frequency (0x8) */
+  0x0a8, 0x03f,			/* */
+
+  0x0d3, 0x000,			/*  */
+
+  0x040,				/* start line */
+  
+  0x08d, 0x014,			/* [2] charge pump setting (p62): 0x014 enable, 0x010 disable */
+
+  0x020, 0x000,			/* */
+  0x0a1,				/* segment remap a0/a1*/
+  0x0c8,				/* c0: scan dir normal, c8: reverse */
+  0x0da, 0x012,			/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */
+  0x081, 0x0cf,			/* [2] set contrast control */
+  0x0d9, 0x0f1,			/* [2] pre-charge period 0x022/f1*/
+  0x0db, 0x040,			/* vcomh deselect level */
+  
+  0x02e,				/* 2012-05-27: Deactivate scroll */ 
+  0x0a4,				/* output ram to display */
+  0x0a6,				/* none inverted normal display mode */
+  0x0af,				/* display on */
+
+  U8G_ESC_CS(0),        /* disable chip */
+  U8G_ESC_END           /* end of sequence */
+};
+
+
+/* init sequence adafruit 128x32 OLED (TESTED - WORKING 23.02.13), like adafruit3, but with page addressing mode */
+static const uint8_t u8g_dev_ssd1306_128x32_adafruit3_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),        /* disable chip */
+  U8G_ESC_ADR(0),       /* instruction mode */
+  U8G_ESC_RST(1),		/* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),        /* enable chip */
+
+  0x0ae,				/* display off, sleep mode */
+  0x0d5, 0x080,			/* clock divide ratio (0x00=1) and oscillator frequency (0x8) */
+  0x0a8, 0x01f,			/* Feb 23, 2013: 128x32 OLED: 0x01f,  128x64 OLED 0x03f */
+
+  0x0d3, 0x000,			/*  */
+
+  0x040,				/* start line */
+  
+  0x08d, 0x014,			/* [2] charge pump setting (p62): 0x014 enable, 0x010 disable */ 
+
+  0x020, 0x002,			/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5), Feb 23, 2013: 128x32 OLED: 0x002,  128x64 OLED 0x012 */
+  0x0a1,				/* segment remap a0/a1*/
+  0x0c8,				/* c0: scan dir normal, c8: reverse */
+  0x0da, 0x002,			/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */
+  0x081, 0x0cf,			/* [2] set contrast control */
+  0x0d9, 0x0f1,			/* [2] pre-charge period 0x022/f1*/
+  0x0db, 0x040,			/* vcomh deselect level */
+  
+  0x02e,				/* 2012-05-27: Deactivate scroll */ 
+  0x0a4,				/* output ram to display */
+  0x0a6,				/* none inverted normal display mode */
+  0x0af,				/* display on */
+
+  U8G_ESC_CS(0),        /* disable chip */
+  U8G_ESC_END           /* end of sequence */
+};
+
+
+/* init sequence Univision datasheet (NOT TESTED) */
+static const uint8_t u8g_dev_ssd1306_128x32_univision_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),        /* disable chip */
+  U8G_ESC_ADR(0),       /* instruction mode */
+  U8G_ESC_RST(1),       /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),        /* enable chip */
+
+  0x0ae,				/* display off, sleep mode */
+  0x0d5, 0x080,			/* clock divide ratio (0x00=1) and oscillator frequency (0x8) */
+  0x0a8, 0x03f,			/* multiplex ratio */
+  0x0d3, 0x000,			/* display offset */
+  0x040,				/* start line */
+  0x08d, 0x010,			/* charge pump setting (p62): 0x014 enable, 0x010 disable */
+  0x0a1,				/* segment remap a0/a1*/
+  0x0c8,				/* c0: scan dir normal, c8: reverse */
+  0x0da, 0x012,			/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */
+  0x081, 0x09f,			/* set contrast control */
+  0x0d9, 0x022,			/* pre-charge period */
+  0x0db, 0x040,			/* vcomh deselect level */
+  0x022, 0x000,			/* page addressing mode WRONG: 3 byte cmd! */
+  0x0a4,				/* output ram to display */
+  0x0a6,				/* none inverted normal display mode */
+  0x0af,				/* display on */
+  U8G_ESC_CS(0),        /* disable chip */
+  U8G_ESC_END           /* end of sequence */
+};
+
+
+/* select one init sequence here */
+//define u8g_dev_ssd1306_128x32_init_seq u8g_dev_ssd1306_128x32_univision_init_seq
+//define u8g_dev_ssd1306_128x32_init_seq u8g_dev_ssd1306_128x32_adafruit1_init_seq
+//define u8g_dev_ssd1306_128x32_init_seq u8g_dev_ssd1306_128x32_adafruit2_init_seq
+#define u8g_dev_ssd1306_128x32_init_seq u8g_dev_ssd1306_128x32_adafruit3_init_seq
+
+
+static const uint8_t u8g_dev_ssd1306_128x32_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),       /* instruction mode */
+  U8G_ESC_CS(1),        /* enable chip */
+  0x010,				/* set upper 4 bit of the col adr. to 0 */
+  0x000,				/* set lower 4 bit of the col adr. to 4  */
+  U8G_ESC_END           /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ae,		/* display off */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_ssd1306_128x32_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x32_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x32_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page);	/* select current page (SSD1306) */
+        u8g_SetAddress(u8g, dev, 1);					/* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+}
+  
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_ssd1306_128x32_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x32_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1306_128x32_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x32_fn, U8G_COM_HW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1306_128x32_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x32_fn, U8G_COM_SSD_I2C);
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1306_128x64.c

@@ -0,0 +1,237 @@
+/*
+
+  u8g_dev_ssd1306_128x64.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+/* init sequence adafruit 128x64 OLED (NOT TESTED) */
+static const uint8_t u8g_dev_ssd1306_128x64_adafruit1_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+
+  0x0ae,				/* display off, sleep mode */
+  0x0d5, 0x080,		/* clock divide ratio (0x00=1) and oscillator frequency (0x8) */
+  0x0a8, 0x03f,		/* */
+
+  0x0d3, 0x000,		/*  */
+
+  0x040,				/* start line */
+  
+  0x08d, 0x010,		/* [1] charge pump setting (p62): 0x014 enable, 0x010 disable */
+
+  0x020, 0x000,		/* */
+  0x0a1,				/* segment remap a0/a1*/
+  0x0c8,				/* c0: scan dir normal, c8: reverse */
+  0x0da, 0x012,		/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */
+  0x081, 0x09f,		/* [1] set contrast control */
+  0x0d9, 0x022,		/* [1] pre-charge period 0x022/f1*/
+  0x0db, 0x040,		/* vcomh deselect level */
+  
+  0x02e,				/* 2012-05-27: Deactivate scroll */ 
+  0x0a4,				/* output ram to display */
+  0x0a6,				/* none inverted normal display mode */
+  0x0af,				/* display on */
+
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+/* init sequence adafruit 128x64 OLED (NOT TESTED) */
+static const uint8_t u8g_dev_ssd1306_128x64_adafruit2_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+
+  0x0ae,				/* display off, sleep mode */
+  0x0d5, 0x080,		/* clock divide ratio (0x00=1) and oscillator frequency (0x8) */
+  0x0a8, 0x03f,		/* */
+
+  0x0d3, 0x000,		/*  */
+
+  0x040,				/* start line */
+  
+  0x08d, 0x014,		/* [2] charge pump setting (p62): 0x014 enable, 0x010 disable */
+
+  0x020, 0x000,		/* */
+  0x0a1,				/* segment remap a0/a1*/
+  0x0c8,				/* c0: scan dir normal, c8: reverse */
+  0x0da, 0x012,		/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */
+  0x081, 0x0cf,		/* [2] set contrast control */
+  0x0d9, 0x0f1,		/* [2] pre-charge period 0x022/f1*/
+  0x0db, 0x040,		/* vcomh deselect level */
+  
+  0x02e,				/* 2012-05-27: Deactivate scroll */ 
+  0x0a4,				/* output ram to display */
+  0x0a6,				/* none inverted normal display mode */
+  0x0af,				/* display on */
+
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+/* init sequence adafruit 128x64 OLED (NOT TESTED), like adafruit3, but with page addressing mode */
+static const uint8_t u8g_dev_ssd1306_128x64_adafruit3_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+
+  0x0ae,				/* display off, sleep mode */
+  0x0d5, 0x080,		/* clock divide ratio (0x00=1) and oscillator frequency (0x8) */
+  0x0a8, 0x03f,		/* */
+
+  0x0d3, 0x000,		/*  */
+
+  0x040,				/* start line */
+  
+  0x08d, 0x014,		/* [2] charge pump setting (p62): 0x014 enable, 0x010 disable */
+
+  0x020, 0x002,		/* 2012-05-27: page addressing mode */
+  0x0a1,				/* segment remap a0/a1*/
+  0x0c8,				/* c0: scan dir normal, c8: reverse */
+  0x0da, 0x012,		/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */
+  0x081, 0x0cf,		/* [2] set contrast control */
+  0x0d9, 0x0f1,		/* [2] pre-charge period 0x022/f1*/
+  0x0db, 0x040,		/* vcomh deselect level */
+  
+  0x02e,				/* 2012-05-27: Deactivate scroll */ 
+  0x0a4,				/* output ram to display */
+  0x0a6,				/* none inverted normal display mode */
+  0x0af,				/* display on */
+
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+/* init sequence Univision datasheet (NOT TESTED) */
+static const uint8_t u8g_dev_ssd1306_128x64_univision_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+
+  0x0ae,				/* display off, sleep mode */
+  0x0d5, 0x080,		/* clock divide ratio (0x00=1) and oscillator frequency (0x8) */
+  0x0a8, 0x03f,		/* multiplex ratio */
+  0x0d3, 0x000,		/* display offset */
+  0x040,				/* start line */
+  0x08d, 0x010,		/* charge pump setting (p62): 0x014 enable, 0x010 disable */
+  0x0a1,				/* segment remap a0/a1*/
+  0x0c8,				/* c0: scan dir normal, c8: reverse */
+  0x0da, 0x012,		/* com pin HW config, sequential com pin config (bit 4), disable left/right remap (bit 5) */
+  0x081, 0x09f,		/* set contrast control */
+  0x0d9, 0x022,		/* pre-charge period */
+  0x0db, 0x040,		/* vcomh deselect level */
+  0x022, 0x000,		/* page addressing mode WRONG: 3 byte cmd! */
+  0x0a4,				/* output ram to display */
+  0x0a6,				/* none inverted normal display mode */
+  0x0af,				/* display on */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+/* select one init sequence here */
+//#define u8g_dev_ssd1306_128x64_init_seq u8g_dev_ssd1306_128x64_univision_init_seq
+//#define u8g_dev_ssd1306_128x64_init_seq u8g_dev_ssd1306_128x64_adafruit1_init_seq
+//#define u8g_dev_ssd1306_128x64_init_seq u8g_dev_ssd1306_128x64_adafruit2_init_seq
+#define u8g_dev_ssd1306_128x64_init_seq u8g_dev_ssd1306_128x64_adafruit3_init_seq
+
+
+static const uint8_t u8g_dev_ssd1306_128x64_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 4  */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ae,		/* display off */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_ssd1306_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x64_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (SSD1306) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_ssd1306_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x64_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1306_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x64_fn, U8G_COM_HW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1306_128x64_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_128x64_fn, U8G_COM_SSD_I2C);

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1309_128x64.c

@@ -0,0 +1,144 @@
+/*
+
+  u8g_dev_ssd1309_128x64.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+
+/* ssd1309 ini sequence*/
+static const uint8_t u8g_dev_ssd1309_128x64_init_seq[] PROGMEM={
+	U8G_ESC_CS(0),             /* disable chip */
+	U8G_ESC_ADR(0),           /* instruction mode */
+	U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+	U8G_ESC_CS(1),             /* enable chip */
+	
+	0xfd,0x12,		/*Command Lock */
+	0xae,			/*Set Display Off */
+	0xd5,0xa0,		/*set Display Clock Divide Ratio/Oscillator Frequency */
+	0xa8,0x3f,		/*Set Multiplex Ratio */
+	0x3d,0x00,		/*Set Display Offset*/
+	0x40,			/*Set Display Start Line*/
+	0xa1,			/*Set Segment Re-Map*/
+	0xc8,			/*Set COM Output Scan Direction*/
+	0xda,0x12,		/*Set COM Pins Hardware Configuration*/
+	0x81,0xdf,		/*Set Current Control */
+	0xd9,0x82,		/*Set Pre-Charge Period */
+	0xdb,0x34,		/*Set VCOMH Deselect Level */
+	0xa4,			/*Set Entire Display On/Off */
+	0xa6,			/*Set Normal/Inverse Display*/
+	U8G_ESC_VCC(1),	/*Power up VCC & Stabilized */
+	U8G_ESC_DLY(50),
+	0xaf,			/*Set Display On */
+	U8G_ESC_DLY(50),
+	U8G_ESC_CS(0),             /* disable chip */
+	U8G_ESC_END                /* end of sequence */
+};
+
+/* select one init sequence here */
+  #define u8g_dev_ssd1309_128x64_init_seq u8g_dev_ssd1309_128x64_init_seq
+  
+  
+ static const uint8_t u8g_dev_ssd1309_128x64_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 4  */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ae,		/* display off */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_ssd1309_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1309_128x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1309_128x64_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (SSD1306) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1; 
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_ssd1309_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1309_128x64_fn, U8G_COM_HW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1309_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1309_128x64_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1309_128x64_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1309_128x64_fn, U8G_COM_SSD_I2C);
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1322_nhd31oled_bw.c

@@ -0,0 +1,334 @@
+/*
+
+  u8g_dev_ssd1322_nhd31oled_bw.c
+  
+  1-Bit (BW) Driver for SSD1322 Controller (OLED Display)
+  Tested with NHD-3.12-25664
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+  SSD130x       Monochrom OLED Controller
+  SSD131x       Character OLED Controller
+  SSD132x       Graylevel OLED Controller
+  SSD1331       Color OLED Controller       
+
+*/
+
+#include "u8g.h"
+
+/* width must be multiple of 8, largest value is 248 unless u8g 16 bit mode is enabled */
+#if defined(U8G_16BIT)
+#define WIDTH 256
+#else
+#define WIDTH 248
+#endif
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+/* 
+  http://www.newhavendisplay.com/app_notes/OLED_25664.txt 
+  http://www.newhavendisplay.com/forum/viewtopic.php?f=15&t=3758
+*/
+
+static const uint8_t u8g_dev_ssd1322_1bit_nhd_312_init_seq[] PROGMEM = {
+  U8G_ESC_DLY(10),              /* delay 10 ms */
+  U8G_ESC_CS(0),                 /* disable chip */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_RST(1),               /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),                /* enable chip */
+  
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0fd,					/* lock command */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x012,					/* unlock */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0ae,                               	 /* display off, sleep mode */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b3, 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x091,                    /* set display clock divide ratio/oscillator frequency (set clock as 80 frames/sec) */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0ca, 					/* multiplex ratio */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x03f,                    		/* 1/64 Duty (0x0F~0x3F) */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a2, 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x000,                     		/* display offset, shift mapping ram counter */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a1, 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x000,                     		/* display start line */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a0, 					/* Set Re-Map / Dual COM Line Mode */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x014, 					/* was 0x014 */                     		
+  0x011, 					/* was 0x011 */	
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0ab, 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x001,                     		/* Enable Internal VDD Regulator */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b4, 					/* Display Enhancement A */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x0a0,                     		
+  0x005|0x0fd,                     		
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0c1,					/* contrast */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x09f,                     		
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0c7,					/* Set Scale Factor of Segment Output Current Control */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x00f,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b9,                               	 /* linear gray scale */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b1,					/* Phase 1 (Reset) & Phase 2 (Pre-Charge) Period Adjustment */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x0e2,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0d1, 					/* Display Enhancement B */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x082|0x020,                     		
+  0x020,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0bb,					/* precharge  voltage */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x01f,                     		
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b6,					/* precharge period */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x008,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0be,					/* vcomh */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x007,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a6,                               	 /* normal display */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a9,                               	 /* exit partial display */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0af,                               	 /* display on */
+
+
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd1322_1bit_nhd_312_prepare_page_seq[] PROGMEM = {
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x015,       /* column address... */
+  U8G_ESC_ADR(1),               /* data mode */
+  0x01c,       /* start at column 0 */
+  0x05b,       /* end column */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  0x075,       /* row address... */
+  U8G_ESC_ADR(1),               /* data mode */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static void u8g_dev_ssd1322_1bit_prepare_row(u8g_t *u8g, u8g_dev_t *dev, uint8_t delta_row)
+{
+  uint8_t row = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  row *= ((u8g_pb_t *)(dev->dev_mem))->p.page_height;
+  row += delta_row;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_1bit_nhd_312_prepare_page_seq);
+  
+  u8g_WriteByte(u8g, dev, row);       /* start at the selected row */
+  u8g_WriteByte(u8g, dev, row+1);       /* end within the selected row */  
+  
+  u8g_SetAddress(u8g, dev, 0);          /* instruction mode mode */
+  u8g_WriteByte(u8g, dev, 0x05c);       /* write to ram */  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ae,		/* display off */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+uint8_t u8g_dev_ssd1322_nhd31oled_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_1bit_nhd_312_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+	uint8_t i;
+	u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	uint8_t *p = pb->buf;
+	u8g_uint_t cnt;
+	cnt = pb->width;
+	cnt >>= 3;
+
+	for( i = 0; i < pb->p.page_height; i++ )
+	{
+	  u8g_dev_ssd1322_1bit_prepare_row(u8g, dev, i);  /* this will also enable chip select */
+#if !defined(U8G_16BIT)
+	  u8g_WriteByte(u8g, dev, 0x0ff);
+	  u8g_WriteByte(u8g, dev, 0x0ff);
+#endif
+	  u8g_WriteSequenceBWTo16GrDevice(u8g, dev, cnt, p);
+#if !defined(U8G_16BIT)
+	  u8g_WriteByte(u8g, dev, 0x0ff);
+	  u8g_WriteByte(u8g, dev, 0x0ff);
+#endif
+	  u8g_SetChipSelect(u8g, dev, 0);        
+	  p+=cnt;
+	}
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_SetAddress(u8g, dev, 1);          /* data mode */
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      break;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg);
+}
+
+
+uint8_t u8g_dev_ssd1322_nhd31oled_2x_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_1bit_nhd_312_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+	uint8_t i;
+	u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	uint8_t *p = pb->buf;
+	u8g_uint_t cnt;
+	cnt = pb->width;
+	cnt >>= 3;
+
+	for( i = 0; i < pb->p.page_height; i++ )
+	{
+	  u8g_dev_ssd1322_1bit_prepare_row(u8g, dev, i);		/* this will also enable chip select */
+#if !defined(U8G_16BIT)
+	  u8g_WriteByte(u8g, dev, 0x0ff);
+	  u8g_WriteByte(u8g, dev, 0x0ff);
+#endif
+	  u8g_WriteSequenceBWTo16GrDevice(u8g, dev, cnt, p);
+#if !defined(U8G_16BIT)
+	  u8g_WriteByte(u8g, dev, 0x0ff);
+	  u8g_WriteByte(u8g, dev, 0x0ff);
+#endif
+	  u8g_SetChipSelect(u8g, dev, 0);        
+	  p+=cnt;
+	}
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_SetAddress(u8g, dev, 1);          /* data mode */
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      break;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg);
+}
+
+
+U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_bw_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_bw_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_bw_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_bw_fn, U8G_COM_HW_SPI);
+
+#define DWIDTH (WIDTH*2)
+uint8_t u8g_dev_ssd1322_nhd31oled_2x_bw_buf[DWIDTH] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_ssd1322_nhd31oled_2x_bw_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1322_nhd31oled_2x_bw_buf}; 
+u8g_dev_t u8g_dev_ssd1322_nhd31oled_2x_bw_sw_spi = { u8g_dev_ssd1322_nhd31oled_2x_bw_fn, &u8g_dev_ssd1322_nhd31oled_2x_bw_pb, U8G_COM_SW_SPI };
+u8g_dev_t u8g_dev_ssd1322_nhd31oled_2x_bw_hw_spi = { u8g_dev_ssd1322_nhd31oled_2x_bw_fn, &u8g_dev_ssd1322_nhd31oled_2x_bw_pb, U8G_COM_HW_SPI };
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1322_nhd31oled_gr.c

@@ -0,0 +1,333 @@
+/*
+
+  u8g_dev_ssd1322_nhd31oled_gr.c
+  
+  2-Bit (4L) Driver for SSD1322 Controller (OLED Display)
+  Tested with NHD-3.12-25664
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+  SSD130x       Monochrom OLED Controller
+  SSD131x       Character OLED Controller
+  SSD132x       Graylevel OLED Controller
+  SSD1331       Color OLED Controller       
+
+*/
+
+#include "u8g.h"
+
+/* width must be multiple of 8, largest value is 248 unless u8g 16 bit mode is enabled */
+#if defined(U8G_16BIT)
+#define WIDTH 256
+#else
+#define WIDTH 248
+#endif
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+/* 
+  http://www.newhavendisplay.com/app_notes/OLED_25664.txt 
+  http://www.newhavendisplay.com/forum/viewtopic.php?f=15&t=3758
+*/
+
+static const uint8_t u8g_dev_ssd1322_2bit_nhd_312_init_seq[] PROGMEM = {
+  U8G_ESC_DLY(10),              /* delay 10 ms */
+  U8G_ESC_CS(0),                 /* disable chip */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_RST(1),               /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),                /* enable chip */
+  
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0fd,					/* lock command */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x012,					/* unlock */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0ae,                               	 /* display off, sleep mode */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b3, 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x091,                    /* set display clock divide ratio/oscillator frequency (set clock as 80 frames/sec) */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0ca, 					/* multiplex ratio */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x03f,                    		/* 1/64 Duty (0x0F~0x3F) */
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a2, 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x000,                     		/* display offset, shift mapping ram counter */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a1, 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x000,                     		/* display start line */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a0, 					/* Set Re-Map / Dual COM Line Mode */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x014, 					/* was 0x014 */                     		
+  0x011, 					/* was 0x011 */	
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0ab, 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x001,                     		/* Enable Internal VDD Regulator */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b4, 					/* Display Enhancement A */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x0a0,                     		
+  0x005|0x0fd,                     		
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0c1,					/* contrast */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x09f,                     		
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0c7,					/* Set Scale Factor of Segment Output Current Control */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x00f,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b9,                               	 /* linear gray scale */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b1,					/* Phase 1 (Reset) & Phase 2 (Pre-Charge) Period Adjustment */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x0e2,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0d1, 					/* Display Enhancement B */
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x082|0x020,                     		
+  0x020,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0bb,					/* precharge  voltage */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x01f,                     		
+  
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0b6,					/* precharge period */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x008,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0be,					/* vcomh */ 
+  U8G_ESC_ADR(1),               	/* data mode */
+  0x007,                     		
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a6,                               	 /* normal display */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0a9,                               	 /* exit partial display */
+
+  U8G_ESC_ADR(0),               	/* instruction mode */
+  0x0af,                               	 /* display on */
+
+
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd1322_2bit_nhd_312_prepare_page_seq[] PROGMEM = {
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x015,       /* column address... */
+  U8G_ESC_ADR(1),               /* data mode */
+  0x01c,       /* start at column 0 */
+  0x05b,       /* end column */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  0x075,       /* row address... */
+  U8G_ESC_ADR(1),               /* data mode */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static void u8g_dev_ssd1322_2bit_prepare_row(u8g_t *u8g, u8g_dev_t *dev, uint8_t delta_row)
+{
+  uint8_t row = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  row *= ((u8g_pb_t *)(dev->dev_mem))->p.page_height;
+  row += delta_row;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_2bit_nhd_312_prepare_page_seq);
+  
+  u8g_WriteByte(u8g, dev, row);       /* start at the selected row */
+  u8g_WriteByte(u8g, dev, row+1);       /* end within the selected row */  
+  
+  u8g_SetAddress(u8g, dev, 0);          /* instruction mode mode */
+  u8g_WriteByte(u8g, dev, 0x05c);       /* write to ram */  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ae,		/* display off */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_ssd1322_nhd31oled_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_2bit_nhd_312_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+	uint8_t i;
+	u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	uint8_t *p = pb->buf;
+	u8g_uint_t cnt;
+	cnt = pb->width;
+	cnt >>= 2;
+
+	for( i = 0; i < pb->p.page_height; i++ )
+	{
+	  u8g_dev_ssd1322_2bit_prepare_row(u8g, dev, i);  /* this will also enable chip select */
+#if !defined(U8G_16BIT)
+	  u8g_WriteByte(u8g, dev, 0x00);
+	  u8g_WriteByte(u8g, dev, 0x00);
+#endif
+	  u8g_WriteSequence4LTo16GrDevice(u8g, dev, cnt, p);
+#if !defined(U8G_16BIT)
+	  u8g_WriteByte(u8g, dev, 0x00);
+	  u8g_WriteByte(u8g, dev, 0x00);
+#endif
+	  u8g_SetChipSelect(u8g, dev, 0);        
+	  p+=cnt;
+	}
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_SetAddress(u8g, dev, 1);          /* data mode */
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      break;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8h2_base_fn(u8g, dev, msg, arg);
+}
+
+
+uint8_t u8g_dev_ssd1322_nhd31oled_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1322_2bit_nhd_312_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+	uint8_t i;
+	u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	uint8_t *p = pb->buf;
+	u8g_uint_t cnt;
+	cnt = pb->width;
+	cnt >>= 3;
+
+	for( i = 0; i < pb->p.page_height; i++ )
+	{
+	  u8g_dev_ssd1322_2bit_prepare_row(u8g, dev, i);		/* this will also enable chip select */
+#if !defined(U8G_16BIT)
+	  u8g_WriteByte(u8g, dev, 0x00);
+	  u8g_WriteByte(u8g, dev, 0x00);
+#endif
+	  u8g_WriteSequence4LTo16GrDevice(u8g, dev, cnt, p);
+#if !defined(U8G_16BIT)
+	  u8g_WriteByte(u8g, dev, 0x00);
+	  u8g_WriteByte(u8g, dev, 0x00);
+#endif
+	  u8g_SetChipSelect(u8g, dev, 0);        
+	  p+=cnt;
+	}
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_SetAddress(u8g, dev, 1);          /* data mode */
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      break;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb16h2_base_fn(u8g, dev, msg, arg);
+}
+
+
+U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_gr_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_gr_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_gr_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_gr_fn, U8G_COM_HW_SPI);
+
+#define DWIDTH (WIDTH*2)
+uint8_t u8g_dev_ssd1322_nhd31oled_2x_gr_buf[DWIDTH] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_ssd1322_nhd31oled_2x_gr_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1322_nhd31oled_2x_gr_buf}; 
+u8g_dev_t u8g_dev_ssd1322_nhd31oled_2x_gr_sw_spi = { u8g_dev_ssd1322_nhd31oled_2x_gr_fn, &u8g_dev_ssd1322_nhd31oled_2x_gr_pb, U8G_COM_SW_SPI };
+u8g_dev_t u8g_dev_ssd1322_nhd31oled_2x_gr_hw_spi = { u8g_dev_ssd1322_nhd31oled_2x_gr_fn, &u8g_dev_ssd1322_nhd31oled_2x_gr_pb, U8G_COM_HW_SPI };
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1325_nhd27oled_bw.c

@@ -0,0 +1,263 @@
+/*
+
+  u8g_dev_ssd1325_nhd27oled_bw.c
+  
+  1-Bit (BW) Driver for SSD1325 Controller (OLED Display)
+  Tested with NHD-2.7-12864UCY3
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+  SSD130x       Monochrom OLED Controller
+  SSD131x       Character OLED Controller
+  SSD132x       Graylevel OLED Controller
+  SSD1331       Color OLED Controller       
+
+*/
+
+#ifdef OBSOLETE_CODE
+
+#include "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+/* http://www.newhavendisplay.com/app_notes/OLED_2_7_12864.txt */
+static const uint8_t u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_init_seq[] PROGMEM = {
+  U8G_ESC_DLY(10),              /* delay 10 ms */
+  U8G_ESC_CS(0),                 /* disable chip */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_RST(1),               /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x0ae,                                /* display off, sleep mode */
+  0x0b3, 0x091,                    /* set display clock divide ratio/oscillator frequency (set clock as 135 frames/sec) */
+  0x0a8, 0x03f,                     /* multiplex ratio: 0x03f * 1/64 duty */
+  0x0a2, 0x04c,                     /* display offset, shift mapping ram counter */
+  0x0a1, 0x000,                     /* display start line */
+  0x0ad, 0x002,                     /* master configuration: disable embedded DC-DC, enable internal VCOMH */
+  0x0a0, 0x056,                     /* remap configuration, vertical address increment, enable nibble remap (upper nibble is left) */
+  0x086,                                /* full current range (0x084, 0x085, 0x086) */
+  0x0b8,                                /* set gray scale table */
+      0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076,
+  0x081, 0x070,                    /* contrast, brightness, 0..128, Newhaven: 0x040 */
+  0x0b2, 0x051,                    /* frame frequency (row period) */
+  0x0b1, 0x055,                    /* phase length */
+  0x0bc, 0x010,                    /* pre-charge voltage level */
+  0x0b4, 0x002,                    /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0b0, 0x028,                    /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0be, 0x01c,                     /* VCOMH voltage */
+  0x0bf, 0x002|0x00d,           /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0a5,                                 /* all pixel on */
+  0x0af,                                  /* display on */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  0x0a4,                                 /* normal display mode */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_prepare_page_seq[] PROGMEM = {
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x015,       /* column address... */
+  0x000,       /* start at column 0 */
+  0x03f,       /* end at column 63 (which is y == 127), because there are two pixel in one column */
+  0x075,       /* row address... */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+static void u8g_dev_ssd1325_1bit_prepare_page(u8g_t *u8g, u8g_dev_t *dev)
+{
+  uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_prepare_page_seq);
+  
+  page <<= 3;
+  u8g_WriteByte(u8g, dev, page);       /* start at the selected page */
+  page += 7;
+  u8g_WriteByte(u8g, dev, page);       /* end within the selected page */  
+  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+static void u8g_dev_ssd1325_1bit_2x_prepare_page(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd)
+{
+  uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_prepare_page_seq);
+  
+  page <<= 1;
+  page += is_odd;
+  
+  page <<= 3;
+  u8g_WriteByte(u8g, dev, page);       /* start at the selected page */
+  page += 7;
+  u8g_WriteByte(u8g, dev, page);       /* end within the selected page */  
+  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+/* assumes row autoincrement and activated nibble remap */
+#ifdef OLD
+static  void _OLD_u8g_dev_ssd1325_1bit_write_16_pixel(u8g_t *u8g, u8g_dev_t *dev, uint8_t left, uint8_t right)
+{
+  uint8_t d, cnt;
+  cnt = 8;
+  do
+  {
+    d = 0;
+    if ( left & 1 )
+      d |= 0x0f0;
+    if ( right & 1 )
+      d |= 0x00f;
+    u8g_WriteByte(u8g, dev, d);
+    left >>= 1;
+    right >>= 1;
+    cnt--;
+  }while ( cnt > 0 );
+}
+#endif
+
+static  void u8g_dev_ssd1325_1bit_write_16_pixel(u8g_t *u8g, u8g_dev_t *dev, uint8_t left, uint8_t right)
+{
+  uint8_t d, cnt;
+  static uint8_t buf[8];
+  cnt = 8;
+  do
+  {
+    d = 0;
+    if ( left & 128 )
+      d |= 0x0f0;
+    if ( right & 128 )
+      d |= 0x00f;
+    cnt--;
+    buf[cnt] = d;
+    left <<= 1;
+    right <<= 1;
+  }while ( cnt > 0 );
+  u8g_WriteSequence(u8g, dev, 8, buf);
+}
+
+static void u8g_dev_ssd1325_1bit_write_buffer(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd)
+{
+  uint8_t cnt, left, right;
+  uint8_t *ptr;
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  
+  ptr = pb->buf;
+  cnt = pb->width;
+  if ( is_odd )
+    ptr += cnt;
+  cnt >>= 1;
+  do
+  {
+    left = *ptr++;
+    right = *ptr++;
+    u8g_dev_ssd1325_1bit_write_16_pixel(u8g, dev, left, right);
+    cnt--;
+  } while( cnt > 0 );
+}
+
+uint8_t u8g_dev_ssd1325_nhd27oled_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_dev_ssd1325_1bit_prepare_page(u8g, dev);
+        u8g_dev_ssd1325_1bit_write_buffer(u8g, dev, 0);
+        u8g_SetChipSelect(u8g, dev, 0);        
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      break;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_ssd1325_nhd27oled_2x_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_1bit_nhd_27_12864ucy3_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_dev_ssd1325_1bit_2x_prepare_page(u8g, dev, 0);
+        u8g_dev_ssd1325_1bit_write_buffer(u8g, dev, 0);
+        u8g_dev_ssd1325_1bit_2x_prepare_page(u8g, dev, 1);
+        u8g_dev_ssd1325_1bit_write_buffer(u8g, dev, 1);
+        u8g_SetChipSelect(u8g, dev, 0);        
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      break;
+  }
+  return u8g_dev_pb16v1_base_fn(u8g, dev, msg, arg);
+}
+
+/* disabled, see bw_new.c */
+/*
+U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_HW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_parallel , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_FAST_PARALLEL);
+*/
+
+/*
+uint8_t u8g_dev_ssd1325_nhd27oled_2x_bw_buf[WIDTH*2] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_ssd1325_nhd27oled_2x_bw_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1325_nhd27oled_2x_bw_buf}; 
+u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_sw_spi = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_SW_SPI };
+u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_hw_spi = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_HW_SPI };
+u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_parallel = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_FAST_PARALLEL };
+*/
+
+#endif
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1325_nhd27oled_bw_new.c

@@ -0,0 +1,232 @@
+/*
+
+  u8g_dev_ssd1325_nhd27oled_bw.c
+  
+  1-Bit (BW) Driver for SSD1325 Controller (OLED Display)
+  Horizontal architecture, completly rewritten
+  Tested with NHD-2.7-12864UCY3
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+  SSD130x       Monochrom OLED Controller
+  SSD131x       Character OLED Controller
+  SSD132x       Graylevel OLED Controller
+  SSD1331       Color OLED Controller       
+
+*/
+
+#include "u8g.h"
+
+/* width must be multiple of 8, largest value is 248 unless u8g 16 bit mode is enabled */
+#define WIDTH 128
+#define HEIGHT 64
+
+/* http://www.newhavendisplay.com/app_notes/OLED_2_7_12864.txt */
+static const uint8_t u8g_dev_ssd1325_nhd_27_12864_init_seq[] PROGMEM = {
+  U8G_ESC_DLY(10),              /* delay 10 ms */
+  U8G_ESC_CS(0),                 /* disable chip */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_RST(1),               /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x0ae,                                /* display off, sleep mode */
+  0x0b3, 0x091,                    /* set display clock divide ratio/oscillator frequency (set clock as 135 frames/sec) */
+  0x0a8, 0x03f,                     /* multiplex ratio: 0x03f * 1/64 duty */
+  0x0a2, 0x04c,                     /* display offset, shift mapping ram counter */
+  0x0a1, 0x000,                     /* display start line */
+  0x0ad, 0x002,                     /* master configuration: disable embedded DC-DC, enable internal VCOMH */
+  0x0a0, 0x052,                     /* remap configuration, horizontal address increment (bit 2 = 0), enable nibble remap (upper nibble is left, bit 1 = 1) */
+  0x086,                                /* full current range (0x084, 0x085, 0x086) */
+  0x0b8,                                /* set gray scale table */
+      0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076,
+  
+  0x081, 0x070,                    /* contrast, brightness, 0..128, Newhaven: 0x040 */
+  0x0b2, 0x051,                    /* frame frequency (row period) */
+  0x0b1, 0x055,                    /* phase length */
+  0x0bc, 0x010,                    /* pre-charge voltage level */
+  0x0b4, 0x002,                    /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0b0, 0x028,                    /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0be, 0x01c,                     /* VCOMH voltage */
+  0x0bf, 0x002|0x00d,           /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0a4,                                 /* normal display mode */
+  0x0af,                                  /* display on */
+  U8G_ESC_DLY(50),             /* delay 50 ms */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd1325_prepare_row_seq[] PROGMEM = {
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x015,       /* column address... */
+  0x000,       /* start at column 0 */
+  0x03f,       /* end at column 63 (which is y == 127), because there are two pixel in one column */
+  0x075,       /* row address... */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static void u8g_dev_ssd1325_prepare_row(u8g_t *u8g, u8g_dev_t *dev, uint8_t delta_row)
+{
+  uint8_t row = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  row *= ((u8g_pb_t *)(dev->dev_mem))->p.page_height;
+  row += delta_row;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_prepare_row_seq);
+  
+  u8g_WriteByte(u8g, dev, row);       /* start at the selected row */
+  u8g_WriteByte(u8g, dev, row+1);       /* end within the selected row */  
+  
+  //u8g_SetAddress(u8g, dev, 0);          /* instruction mode mode */
+  //u8g_WriteByte(u8g, dev, 0x05c);       /* write to ram */  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ae,		/* display off */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+static uint8_t u8g_dev_ssd1325_nhd27oled_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    //case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+    //  return u8g_pb_IsIntersection((u8g_pb_t *)(dev->dev_mem), (u8g_dev_arg_bbx_t *)arg);
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_nhd_27_12864_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+	uint8_t i;
+	u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	uint8_t *p = pb->buf;
+	u8g_uint_t cnt;
+	cnt = pb->width;
+	cnt >>= 3;
+
+	for( i = 0; i < pb->p.page_height; i++ )
+	{
+	  u8g_dev_ssd1325_prepare_row(u8g, dev, i);		/* this will also enable chip select */
+	  u8g_WriteSequenceBWTo16GrDevice(u8g, dev, cnt, p);
+	  u8g_SetChipSelect(u8g, dev, 0);        
+	  p+=cnt;
+	}
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      break;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg);
+}
+
+static uint8_t u8g_dev_ssd1325_nhd27oled_2x_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_nhd_27_12864_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+	uint8_t i;
+	u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	uint8_t *p = pb->buf;
+	u8g_uint_t cnt;
+	cnt = pb->width;
+	cnt >>= 3;
+
+	for( i = 0; i < pb->p.page_height; i++ )
+	{
+	  u8g_dev_ssd1325_prepare_row(u8g, dev, i);		/* this will also enable chip select */
+	  u8g_WriteSequenceBWTo16GrDevice(u8g, dev, cnt, p);
+	  u8g_SetChipSelect(u8g, dev, 0);        
+	  p+=cnt;
+	}
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      break;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg);
+}
+
+
+
+U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_sw_spi , WIDTH, HEIGHT, 8, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_hw_spi , WIDTH, HEIGHT, 8, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_HW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_bw_parallel , WIDTH, HEIGHT, 8, u8g_dev_ssd1325_nhd27oled_bw_fn, U8G_COM_FAST_PARALLEL);
+
+uint8_t u8g_dev_ssd1325_nhd27oled_2x_bw_buf[WIDTH*2] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_ssd1325_nhd27oled_2x_bw_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1325_nhd27oled_2x_bw_buf}; 
+u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_sw_spi = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_SW_SPI };
+u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_hw_spi = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_HW_SPI };
+u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_bw_parallel = { u8g_dev_ssd1325_nhd27oled_2x_bw_fn, &u8g_dev_ssd1325_nhd27oled_2x_bw_pb, U8G_COM_FAST_PARALLEL };
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1325_nhd27oled_gr.c

@@ -0,0 +1,255 @@
+/*
+
+  u8g_dev_ssd1325_nhd27oled_gr.c
+  
+  2-Bit (gray level) Driver for SSD1325 Controller (OLED Display)
+  Tested with NHD-2.7-12864UCY3
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+  SSD130x       Monochrom OLED Controller
+  SSD131x       Character OLED Controller
+  SSD132x       Graylevel OLED Controller
+  SSD1331       Color OLED Controller       
+
+*/
+
+#ifdef OBSOLETE_CODE
+
+#include "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+
+/* http://www.newhavendisplay.com/app_notes/OLED_2_7_12864.txt */
+static const uint8_t u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq[] PROGMEM = {
+  U8G_ESC_DLY(10),              /* delay 10 ms */
+  U8G_ESC_CS(0),                 /* disable chip */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_RST(1),               /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x0ae,                                /* display off, sleep mode */
+  0x0b3, 0x091,                    /* set display clock divide ratio/oscillator frequency (set clock as 135 frames/sec) */
+  0x0a8, 0x03f,                     /* multiplex ratio: 0x03f * 1/64 duty */
+  0x0a2, 0x04c,                     /* display offset, shift mapping ram counter */
+  0x0a1, 0x000,                     /* display start line */
+  0x0ad, 0x002,                     /* master configuration: disable embedded DC-DC, enable internal VCOMH */
+  0x0a0, 0x056,                     /* remap configuration, vertical address increment, enable nibble remap (upper nibble is left) */
+  0x086,                                /* full current range (0x084, 0x085, 0x086) */
+  0x0b8,                                /* set gray scale table */
+      //0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076,
+      0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x077, 0x077,            // 4L mode uses 0, 2, 4, 7
+  0x081, 0x070,                    /* contrast, brightness, 0..128, Newhaven: 0x040 */
+  0x0b2, 0x051,                    /* frame frequency (row period) */
+  0x0b1, 0x055,                    /* phase length */
+  0x0bc, 0x010,                    /* pre-charge voltage level */
+  0x0b4, 0x002,                    /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0b0, 0x028,                    /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0be, 0x01c,                     /* VCOMH voltage */
+  0x0bf, 0x002|0x00d,           /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0a5,                                 /* all pixel on */
+  0x0af,                                  /* display on */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  0x0a4,                                 /* normal display mode */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq[] PROGMEM = {
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x015,       /* column address... */
+  0x000,       /* start at column 0 */
+  0x03f,       /* end at column 63 (which is y == 127), because there are two pixel in one column */
+  0x075,       /* row address... */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+static void u8g_dev_ssd1325_2bit_prepare_page(u8g_t *u8g, u8g_dev_t *dev)
+{
+  uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq);
+  
+  page <<= 2;
+  u8g_WriteByte(u8g, dev, page);       /* start at the selected page */
+  page += 3;
+  u8g_WriteByte(u8g, dev, page);       /* end within the selected page */  
+  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+static void u8g_dev_ssd1325_2bit_2x_prepare_page(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd)
+{
+  uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq);
+  
+  page <<= 1;
+  page += is_odd;
+  
+  
+  page <<= 2;
+  u8g_WriteByte(u8g, dev, page);       /* start at the selected page */
+  page += 3;
+  u8g_WriteByte(u8g, dev, page);       /* end within the selected page */  
+  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+/* assumes row autoincrement and activated nibble remap */
+static  void u8g_dev_ssd1325_2bit_write_4_pixel(u8g_t *u8g, u8g_dev_t *dev, uint8_t left, uint8_t right)
+{
+  uint8_t d, tmp, cnt;
+  cnt = 4;
+  do    
+  {
+    d = left;
+    d &= 3;
+    d <<= 4;    
+    tmp = right;    
+    tmp &= 3;
+    d |= tmp;
+    d <<= 2;
+    u8g_WriteByte(u8g, dev, d);
+    left >>= 2;
+    right >>= 2;
+    cnt--;
+  }while ( cnt > 0 );
+}
+
+static void u8g_dev_ssd1325_2bit_write_buffer(u8g_t *u8g, u8g_dev_t *dev)
+{
+  uint8_t cnt, left, right;
+  uint8_t *ptr;
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  
+  cnt = pb->width;
+  cnt >>= 1;
+  ptr = pb->buf;
+  do
+  {
+    left = *ptr++;
+    right = *ptr++;
+    u8g_dev_ssd1325_2bit_write_4_pixel(u8g, dev, left, right);
+    cnt--;
+  } while( cnt > 0 );
+}
+
+static void u8g_dev_ssd1325_2bit_2x_write_buffer(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd)
+{
+  uint8_t cnt, left, right;
+  uint8_t *ptr;
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  
+  ptr = pb->buf;
+  cnt = pb->width;
+  if ( is_odd )
+    ptr += cnt;
+  cnt >>= 1;
+  do
+  {
+    left = *ptr++;
+    right = *ptr++;
+    u8g_dev_ssd1325_2bit_write_4_pixel(u8g, dev, left, right);
+    cnt--;
+  } while( cnt > 0 );
+}
+
+static uint8_t u8g_dev_ssd1325_nhd27oled_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_dev_ssd1325_2bit_prepare_page(u8g, dev);
+        u8g_dev_ssd1325_2bit_write_buffer(u8g, dev);
+        u8g_SetChipSelect(u8g, dev, 0);        
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb8v2_base_fn(u8g, dev, msg, arg);
+}
+
+static uint8_t u8g_dev_ssd1325_nhd27oled_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_dev_ssd1325_2bit_2x_prepare_page(u8g, dev, 0);
+        u8g_dev_ssd1325_2bit_2x_write_buffer(u8g, dev, 0);
+        u8g_dev_ssd1325_2bit_2x_prepare_page(u8g, dev, 1);
+        u8g_dev_ssd1325_2bit_2x_write_buffer(u8g, dev, 1);
+        u8g_SetChipSelect(u8g, dev, 0);        
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb16v2_base_fn(u8g, dev, msg, arg);
+}
+
+//U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_sw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_SW_SPI);
+//U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_hw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_HW_SPI);
+
+//uint8_t u8g_dev_ssd1325_nhd27oled_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
+//u8g_pb_t u8g_dev_ssd1325_nhd27oled_2x_pb = { {8, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1325_nhd27oled_2x_buf}; 
+//u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_gr_sw_spi = { u8g_dev_ssd1325_nhd27oled_2x_gr_fn, &u8g_dev_ssd1325_nhd27oled_2x_pb, U8G_COM_SW_SPI };
+//u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_gr_hw_spi = { u8g_dev_ssd1325_nhd27oled_2x_gr_fn, &u8g_dev_ssd1325_nhd27oled_2x_pb, U8G_COM_HW_SPI };
+
+
+#endif /* OBSOLETE_CODE */

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1325_nhd27oled_gr_new.c

@@ -0,0 +1,227 @@
+/*
+
+  u8g_dev_ssd1325_nhd27oled_gr.c
+  
+  2-Bit (gray level) Driver for SSD1325 Controller (OLED Display)
+  Rewritten with new architecture
+  Tested with NHD-2.7-12864UCY3
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+  SSD130x       Monochrom OLED Controller
+  SSD131x       Character OLED Controller
+  SSD132x       Graylevel OLED Controller
+  SSD1331       Color OLED Controller       
+
+*/
+
+#include "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+
+/* http://www.newhavendisplay.com/app_notes/OLED_2_7_12864.txt */
+static const uint8_t u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq[] PROGMEM = {
+  U8G_ESC_DLY(10),              /* delay 10 ms */
+  U8G_ESC_CS(0),                 /* disable chip */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_RST(1),               /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x0ae,                                /* display off, sleep mode */
+  0x0b3, 0x091,                    /* set display clock divide ratio/oscillator frequency (set clock as 135 frames/sec) */
+  0x0a8, 0x03f,                     /* multiplex ratio: 0x03f * 1/64 duty */
+  0x0a2, 0x04c,                     /* display offset, shift mapping ram counter */
+  0x0a1, 0x000,                     /* display start line */
+  0x0ad, 0x002,                     /* master configuration: disable embedded DC-DC, enable internal VCOMH */
+  0x0a0, 0x052,                     /* remap configuration, horizontal address increment (bit 2 = 0), enable nibble remap (upper nibble is left, bit 1 = 1), old values: 0x0a0 0x0a6 */
+  0x086,                                /* full current range (0x084, 0x085, 0x086) */
+  0x0b8,                                /* set gray scale table */
+      //0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076,
+      0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x077, 0x077,            // 4L mode uses 0, 2, 4, 7
+  0x081, 0x070,                    /* contrast, brightness, 0..128, Newhaven: 0x040 */
+  0x0b2, 0x051,                    /* frame frequency (row period) */
+  0x0b1, 0x055,                    /* phase length */
+  0x0bc, 0x010,                    /* pre-charge voltage level */
+  0x0b4, 0x002,                    /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0b0, 0x028,                    /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0be, 0x01c,                     /* VCOMH voltage */
+  0x0bf, 0x002|0x00d,           /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0a4,                                 /* normal display mode */
+  0x0af,                                  /* display on */
+  U8G_ESC_DLY(50),             /* delay 50 ms */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq[] PROGMEM = {
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x015,       /* column address... */
+  0x000,       /* start at column 0 */
+  0x03f,       /* end at column 63 (which is y == 127), because there are two pixel in one column */
+  0x075,       /* row address... */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static void u8g_dev_ssd1325_gr_prepare_row(u8g_t *u8g, u8g_dev_t *dev, uint8_t delta_row)
+{
+  uint8_t row = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  row *= ((u8g_pb_t *)(dev->dev_mem))->p.page_height;
+  row += delta_row;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_prepare_page_seq);
+  
+  u8g_WriteByte(u8g, dev, row);       /* start at the selected row */
+  u8g_WriteByte(u8g, dev, row+1);       /* end within the selected row */  
+  
+  //u8g_SetAddress(u8g, dev, 0);          /* instruction mode mode */
+  //u8g_WriteByte(u8g, dev, 0x05c);       /* write to ram */  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+static const uint8_t u8g_dev_ssd13xx_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ae,		/* display off */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd13xx_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+
+static uint8_t u8g_dev_ssd1325_nhd27oled_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+	uint8_t i;
+	u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	uint8_t *p = pb->buf;
+	u8g_uint_t cnt;
+	cnt = pb->width;
+	cnt >>= 2;
+
+	for( i = 0; i < pb->p.page_height; i++ )
+	{
+	  u8g_dev_ssd1325_gr_prepare_row(u8g, dev, i);		/* this will also enable chip select */
+	  u8g_WriteSequence4LTo16GrDevice(u8g, dev, cnt, p);
+	  u8g_SetChipSelect(u8g, dev, 0);        
+	  p+=cnt;
+	}
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8h2_base_fn(u8g, dev, msg, arg);
+}
+
+
+
+static uint8_t u8g_dev_ssd1325_nhd27oled_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1325_2bit_nhd_27_12864ucy3_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+	uint8_t i;
+	u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+	uint8_t *p = pb->buf;
+	u8g_uint_t cnt;
+	cnt = pb->width;
+	cnt >>= 2;
+
+	for( i = 0; i < pb->p.page_height; i++ )
+	{
+	  u8g_dev_ssd1325_gr_prepare_row(u8g, dev, i);		/* this will also enable chip select */
+	  u8g_WriteSequence4LTo16GrDevice(u8g, dev, cnt, p);
+	  u8g_SetChipSelect(u8g, dev, 0);        
+	  p+=cnt;
+	}
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd13xx_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb16h2_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_sw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_hw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_HW_SPI);
+
+uint8_t u8g_dev_ssd1325_nhd27oled_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_ssd1325_nhd27oled_2x_pb = { {8, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1325_nhd27oled_2x_buf}; 
+u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_gr_sw_spi = { u8g_dev_ssd1325_nhd27oled_2x_gr_fn, &u8g_dev_ssd1325_nhd27oled_2x_pb, U8G_COM_SW_SPI };
+u8g_dev_t u8g_dev_ssd1325_nhd27oled_2x_gr_hw_spi = { u8g_dev_ssd1325_nhd27oled_2x_gr_fn, &u8g_dev_ssd1325_nhd27oled_2x_pb, U8G_COM_HW_SPI };

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_ssd1327_96x96_gr.c

@@ -0,0 +1,299 @@
+/*
+
+  u8g_dev_ssd1327_96x96_gr.c
+  
+  2-Bit (graylevel) Driver for SSD1327 Controller (OLED Display)
+  Tested with Seedstudio 96x96 Oled (LY120)
+  http://www.seeedstudio.com/wiki/index.php?title=Twig_-_OLED_96x96
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+  
+  SSD130x       Monochrom OLED Controller
+  SSD131x       Character OLED Controller
+  SSD132x       Graylevel OLED Controller
+  SSD1331       Color OLED Controller       
+
+*/
+
+#include "u8g.h"
+
+#define WIDTH 96
+#define HEIGHT 96
+#define XOFFSET 8
+
+/*  
+  http://www.seeedstudio.com/wiki/index.php?title=Twig_-_OLED_96x96
+*/
+static const uint8_t u8g_dev_ssd1327_2bit_96x96_init_seq[] PROGMEM = {
+  U8G_ESC_DLY(10),              /* delay 10 ms */
+  U8G_ESC_CS(0),                 /* disable chip */
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_RST(1),               /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x0fd, 0x012,			/* unlock display, usually not required because the display is unlocked after reset */
+  0x0ae,             			/* display off, sleep mode */
+  0x0a8, 0x05f,			/* multiplex ratio: 0x05f * 1/64 duty */
+  0x0a1, 0x000,            		/* display start line */
+  0x0a2, 0x060,           		/* display offset, shift mapping ram counter */
+  //0x0a2, 0x04c,           		/* NHD: display offset, shift mapping ram counter */
+  0x0a0, 0x046,  			/* remap configuration, vertical address increment, enable nibble remap (upper nibble is left) */
+  //0x0a0, 0x056,  			/* NHD: remap configuration, vertical address increment, enable nibble remap (upper nibble is left) */
+  0x0ab, 0x001,			/* Enable internal VDD regulator (RESET) */
+  0x081, 0x053,          		/* contrast, brightness, 0..128, Newhaven: 0x040, LY120 0x053, 0x070 seems also ok */
+  0x0b1, 0x051,          		/* phase length */
+  0x0b3, 0x001,           		/* set display clock divide ratio/oscillator frequency */
+  0x0b9,					/* use linear lookup table */
+#if 0
+  0x0b8,                                /* set gray scale table */
+      //0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x065, 0x076,
+      0x01, 0x011, 0x022, 0x032, 0x043, 0x054, 0x077, 0x077,            // 4L mode uses 0, 2, 4, 7
+#endif  
+  0x0bc, 0x008,                    	/* pre-charge voltage level */
+  0x0be, 0x007,                     	/* VCOMH voltage */
+  0x0b6, 0x001,			/* second precharge */
+  0x0d5, 0x062,			/* enable second precharge, internal vsl (bit0 = 0) */
+  
+#if 0
+  // the following commands are not used by the SeeedGrayOLED sequence */
+  0x0ad, 0x002,                     /* master configuration: disable embedded DC-DC, enable internal VCOMH */
+  0x086,                                /* full current range (0x084, 0x085, 0x086) */
+  0x0b2, 0x051,                    /* frame frequency (row period) */
+  0x0b4, 0x002,                    /* set pre-charge compensation level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0b0, 0x028,                    /* enable pre-charge compensation (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+  0x0bf, 0x002|0x00d,           /* VSL voltage level (not documented in the SDD1325 datasheet, but used in the NHD init seq.) */
+#endif 
+
+  0x0a5,                                 /* all pixel on */
+  //0x02e,					/* no scroll (according to SeeedGrayOLED sequence) */
+  0x0af,                                  /* display on */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  0x0a4,                                 /* normal display mode */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  0x0a5,                                 /* all pixel on */
+  0x0af,                                  /* display on */
+  U8G_ESC_DLY(100),             /* delay 100 ms */
+  0x0a4,                                 /* normal display mode */
+  
+  0x015,       /* column address... */
+  0x008,       /* start at column 8, special for the LY120 ??? */
+  0x037,       /* end at column 55, note: there are two pixel in one column */
+  
+  0x075,       /* row address... */
+  0x008,       
+  0x05f,       
+  
+  U8G_ESC_ADR(1),               /* data mode */
+  0x000f, 0x000f, 0x0000, 0x0000, 0x000f,0x000f,0x0000,0x0000,
+  0x000f, 0x000f, 0x0000, 0x0000, 0x000f,0x000f,0x0000,0x0000,
+  0x000f, 0x000f, 0x0000, 0x0000, 0x000f,0x000f,0x0000,0x0000,
+  0x000f, 0x000f, 0x0000, 0x0000, 0x000f,0x000f,0x0000,0x0000,
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_ssd1327_2bit_96x96_prepare_page_seq[] PROGMEM = {
+  U8G_ESC_ADR(0),               /* instruction mode */
+  U8G_ESC_CS(1),                /* enable chip */
+  0x015,       /* column address... */
+  XOFFSET,       /* start at column 8, special for the LY120 ??? */
+  0x037,       /* end at column 55, note: there are two pixel in one column */
+  0x075,       /* row address... */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+static void u8g_dev_ssd1327_2bit_prepare_page(u8g_t *u8g, u8g_dev_t *dev)
+{
+  uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1327_2bit_96x96_prepare_page_seq);
+  
+  page <<= 2;
+  u8g_WriteByte(u8g, dev, page);       /* start at the selected page */
+  page += 3;
+  u8g_WriteByte(u8g, dev, page);       /* end within the selected page */  
+  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+static void u8g_dev_ssd1327_2bit_2x_prepare_page(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd)
+{
+  uint8_t page = ((u8g_pb_t *)(dev->dev_mem))->p.page;
+  
+  u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1327_2bit_96x96_prepare_page_seq);
+  
+  page <<= 1;
+  page += is_odd;
+  
+  page <<= 2;
+  u8g_WriteByte(u8g, dev, page);       /* start at the selected page */
+  page += 3;
+  u8g_WriteByte(u8g, dev, page);       /* end within the selected page */  
+  
+  u8g_SetAddress(u8g, dev, 1);          /* data mode */
+}
+
+/* assumes row autoincrement and activated nibble remap */
+static  void u8g_dev_ssd1327_2bit_write_4_pixel(u8g_t *u8g, u8g_dev_t *dev, uint8_t left, uint8_t right)
+{
+  uint8_t d, tmp, cnt;
+  static uint8_t buf[4];
+  buf[0] = 0;
+  buf[1] = 0;
+  buf[2] = 0;
+  buf[3] = 0;
+  cnt = 0;
+  do 
+  {
+    if ( left == 0 && right == 0 )
+      break;
+    d = left;
+    d &= 3;
+    d <<= 4;    
+    tmp = right;    
+    tmp &= 3;
+    d |= tmp;
+    d <<= 2;
+    buf[cnt] = d;
+    left >>= 2;
+    right >>= 2;
+    cnt++;
+  }while ( cnt < 4 );
+  u8g_WriteSequence(u8g, dev, 4, buf);
+}
+
+static void u8g_dev_ssd1327_2bit_write_buffer(u8g_t *u8g, u8g_dev_t *dev)
+{
+  uint8_t cnt, left, right;
+  uint8_t *ptr;
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  
+  cnt = pb->width;
+  cnt >>= 1;
+  ptr = pb->buf;
+  do
+  {
+    left = *ptr++;
+    right = *ptr++;
+    u8g_dev_ssd1327_2bit_write_4_pixel(u8g, dev, left, right);
+    cnt--;
+  } while( cnt > 0 );
+}
+
+static void u8g_dev_ssd1327_2bit_2x_write_buffer(u8g_t *u8g, u8g_dev_t *dev, uint8_t is_odd)
+{
+  uint8_t cnt, left, right;
+  uint8_t *ptr;
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  
+  ptr = pb->buf;
+  cnt = pb->width;
+  if ( is_odd )
+    ptr += cnt;
+  cnt >>= 1;
+  do
+  {
+    left = *ptr++;
+    right = *ptr++;
+    u8g_dev_ssd1327_2bit_write_4_pixel(u8g, dev, left, right);
+    cnt--;
+  } while( cnt > 0 );
+}
+
+uint8_t u8g_dev_ssd1327_96x96_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1327_2bit_96x96_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_dev_ssd1327_2bit_prepare_page(u8g, dev);
+        u8g_dev_ssd1327_2bit_write_buffer(u8g, dev);
+        u8g_SetChipSelect(u8g, dev, 0);        
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb8v2_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_ssd1327_96x96_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1327_2bit_96x96_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_dev_ssd1327_2bit_2x_prepare_page(u8g, dev, 0);
+        u8g_dev_ssd1327_2bit_2x_write_buffer(u8g, dev, 0);
+        u8g_dev_ssd1327_2bit_2x_prepare_page(u8g, dev, 1);
+        u8g_dev_ssd1327_2bit_2x_write_buffer(u8g, dev, 1);
+        u8g_SetChipSelect(u8g, dev, 0);        
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb16v2_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_ssd1327_96x96_gr_sw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1327_96x96_gr_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1327_96x96_gr_hw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1327_96x96_gr_fn, U8G_COM_HW_SPI);
+U8G_PB_DEV(u8g_dev_ssd1327_96x96_gr_i2c , WIDTH, HEIGHT, 4, u8g_dev_ssd1327_96x96_gr_fn, U8G_COM_SSD_I2C);
+
+#define DWIDTH (2*WIDTH)
+uint8_t u8g_dev_ssd1327_96x96_2x_buf[DWIDTH] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_ssd1327_96x96_2x_pb = { {8, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1327_96x96_2x_buf}; 
+u8g_dev_t u8g_dev_ssd1327_96x96_2x_gr_sw_spi = { u8g_dev_ssd1327_96x96_2x_gr_fn, &u8g_dev_ssd1327_96x96_2x_pb, U8G_COM_SW_SPI };
+u8g_dev_t u8g_dev_ssd1327_96x96_2x_gr_hw_spi = { u8g_dev_ssd1327_96x96_2x_gr_fn, &u8g_dev_ssd1327_96x96_2x_pb, U8G_COM_HW_SPI };
+u8g_dev_t u8g_dev_ssd1327_96x96_2x_gr_i2c = { u8g_dev_ssd1327_96x96_2x_gr_fn, &u8g_dev_ssd1327_96x96_2x_pb, U8G_COM_SSD_I2C };
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7565_64128n.c

@@ -0,0 +1,153 @@
+/*
+
+  u8g_dev_st7565_64128n.c (Displaytech)
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */
+static const uint8_t u8g_dev_st7565_64128n_init_seq[] PROGMEM = {
+ 	 U8G_ESC_CS(0),            /* disable chip */
+	  U8G_ESC_ADR(0),          /* instruction mode */
+	  U8G_ESC_CS(1),           /* enable chip */
+	  U8G_ESC_RST(15),         /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+
+	  0x0A2,   				   /* 0x0a2: LCD bias 1/9 (according to Displaytech 64128N datasheet) */
+	  0x0A0,  				   /* Normal ADC Select (according to Displaytech 64128N datasheet) */
+
+	  0x0c8,                   /* common output mode: set scan direction normal operation/SHL Select, 0x0c0 --> SHL = 0, normal, 0x0c8 --> SHL = 1 */
+	  0x040,		           /* Display start line for Displaytech 64128N */
+
+	  0x028 | 0x04,            /* power control: turn on voltage converter */
+	  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+	  0x028 | 0x06,            /* power control: turn on voltage regulator */
+	  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+	  0x028 | 0x07,            /* power control: turn on voltage follower */
+	  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+	  0x010,                   /* Set V0 voltage resistor ratio. Setting for controlling brightness of Displaytech 64128N */
+
+	  0x0a6,                   /* display normal, bit val 0: LCD pixel off. */
+
+	  0x081,      	           /* set contrast */
+	  0x01e,        	       /* Contrast value. Setting for controlling brightness of Displaytech 64128N */
+
+
+	  0x0af,		           /* display on */
+
+	  U8G_ESC_DLY(100),        /* delay 100 ms */
+	  0x0a5,		           /* display all points, ST7565 */
+	  U8G_ESC_DLY(100),        /* delay 100 ms */
+	  U8G_ESC_DLY(100),        /* delay 100 ms */
+	  0x0a4,		           /* normal display */
+	  U8G_ESC_CS(0),           /* disable chip */
+	  U8G_ESC_END              /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_64128n_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),            /* enable chip */
+  0x010,	                /* set upper 4 bit of the col adr to 0x10 */
+  0x000,		            /* set lower 4 bit of the col adr to 0x00. Changed for DisplayTech 64128N */      
+  U8G_ESC_END               /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_64128n_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ac,		/* static indicator off */
+  0x000,		                /* indicator register set (not sure if this is required) */
+  0x0ae,		/* display off */      
+  0x0a5,		/* all points on */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_64128n_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0a4,		/* all points off */      
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_st7565_64128n_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_st7565_64128n_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_64128n_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7565_64128n_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_64128n_fn, U8G_COM_HW_SPI);
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7565_dogm128.c

@@ -0,0 +1,140 @@
+/*
+
+  u8g_dev_st7565_dogm128.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+const uint8_t u8g_dev_st7565_dogm128_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+  
+  0x040,		                /* set display start line */
+  0x0a1,		                /* ADC set to reverse */
+  0x0c0,		                /* common output mode: set scan direction normal operation */
+  0x0a6,                           /* display normal (none reverse) */
+  0x0a2,		                /* LCD bias 1/9 */
+  0x02f,		                /* all power  control circuits on */
+  0x0f8,		                /* set booster ratio to */
+  0x000,		                /* 4x */
+  0x027,		                /* set V0 voltage resistor ratio to large */
+  0x081,		                /* set contrast */
+  0x018,		                /* contrast value, EA default: 0x016 */
+  0x0ac,		                /* indicator */
+  0x000,		                /* disable */
+  0x0a4,		                /* normal display (not all on) */
+  0x0af,		                /* display on */
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_dogm128_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 0 */      
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_dogm128_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ac,		/* static indicator off */
+  0x000,		                /* indicator register set (not sure if this is required) */
+  0x0ae,		/* display off */      
+  0x0a5,		/* all points on */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_dogm128_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0a4,		/* all points off */      
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_st7565_dogm128_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_st7565_dogm128_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm128_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7565_dogm128_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm128_fn, U8G_COM_HW_SPI);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7565_dogm132.c

@@ -0,0 +1,157 @@
+/*
+
+  u8g_dev_st7565_dogm132.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 132
+#define HEIGHT 32
+#define PAGE_HEIGHT 8
+
+static const uint8_t u8g_dev_st7565_dogm132_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+
+  0x040,		/* set display start line to 0 */
+  0x0a1,		/* ADC set to reverse */
+  0x0c0,		/* common output mode */
+  0x0a6,		/* display normal, bit val 0: LCD pixel off. */
+  0x0a2,		/* LCD bias 1/9 */
+  0x02f,		/* all power  control circuits on */
+  0x0f8,		/* set booster ratio to */
+  0x000,		/* 4x */
+  0x023,		/* set V0 voltage resistor ratio to large */
+  0x081,		/* set contrast */
+  0x01f,		/* contrast value, EA default: 0x01f */
+  0x0ac,		/* indicator */
+  0x000,		/* disable */
+  0x0af,		/* display on */
+
+#ifdef OBSOLETE_DOGM128  
+  0x040,		                /* set display start line */
+  0x0c8,		                /* set scan direction inverse operation */
+  0x0a2,		                /* LCD bias 1/9 */
+  0x02f,		                /* all power  control circuits on */
+  0x0f8,		                /* set booster ratio to */
+  0x000,		                /* 4x */
+  0x027,		                /* set V0 voltage resistor ratio to large */
+  0x081,		                /* set contrast */
+  0x018,		                /* contrast value, EA default: 0x016 */
+  0x0ac,		                /* indicator */
+  0x000,		                /* disable */
+  0x0af,		                /* display on */
+#endif
+
+
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_dogm132_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 0  */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_dogm132_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ac,		/* static indicator off */
+  0x000,		                /* indicator register set (not sure if this is required) */
+  0x0ae,		/* display off */      
+  0x0a5,		/* all points on */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_dogm132_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0a4,		/* all points off */      
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_st7565_dogm132_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm132_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm132_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm132_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm132_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_st7565_dogm132_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm132_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7565_dogm132_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm132_fn, U8G_COM_HW_SPI);

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7565_lm6059.c

@@ -0,0 +1,157 @@
+/*
+
+  u8g_dev_st7565_lm6059.c (Adafruit display)
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */
+static const uint8_t u8g_dev_st7565_lm6059_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+
+  0x0a3,		                /* 0x0a2: LCD bias 1/9 (suggested for the LM6063), 0x0a3: Used by Adafruit, 0x0a2 does not work */
+  /* the LM6059 vs LM6063, ADC and SHL have inverted settings */
+  0x0a0,		                /* 0x0a1: ADC set to normal (suggested for the LM6059), 0x0a0: Used by Adafruit -> normal mode */
+  0x0c8,                            /* common output mode: set scan direction normal operation/SHL Select, 0x0c0 --> SHL = 0, normal, 0x0c8 --> SHL = 1 */
+  0x060,		                /* set display start line */
+  
+  0x028 | 0x04,                 /* power control: turn on voltage converter */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  0x028 | 0x06,                 /* power control: turn on voltage regulator */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  0x028 | 0x07,                 /* power control: turn on voltage follower */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  0x026,		                /* set V0 voltage resistor ratio to 6 (Adafruit Value, no info from LM6063 Manual) */
+  
+  0x0a6,                           /* display normal, bit val 0: LCD pixel off. */
+  
+  0x081,		                /* set contrast */
+  0x018,		                /* contrast value*/
+  
+  /*0x0ac,*/		                /* indicator */
+  /*0x000,*/		                /* disable */
+  
+  0x0af,		                /* display on */
+
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_lm6059_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x001,		/* set lower 4 bit of the col adr  */      
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_lm6059_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ac,		/* static indicator off */
+  0x000,		                /* indicator register set (not sure if this is required) */
+  0x0ae,		/* display off */      
+  0x0a5,		/* all points on */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_lm6059_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0a4,		/* all points off */      
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+uint8_t u8g_dev_st7565_lm6059_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_st7565_lm6059_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_lm6059_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7565_lm6059_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_lm6059_fn, U8G_COM_HW_SPI);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7565_lm6063.c

@@ -0,0 +1,188 @@
+/*
+
+  u8g_dev_st7565_lm6063.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+#ifdef OLD_ADAFRUIT_CODE
+static const uint8_t OLD_u8g_dev_st7565_lm6063_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+  
+  0x040,		                /* set display start line */
+  0x0a1,		                /* ADC set to reverse */
+  0x0c8,		                /* common output mode: set scan direction normal operation/SHL Select / 17 Jan: seems to be a bug, must be 0x0c0 */
+  0x0a6,                           /* display normal, bit val 0: LCD pixel off. */
+  0x0a2,		                /* LCD bias 1/9 */
+  0x02f,		                /* all power  control circuits on */
+  /*0x0f8,*/		                /* set booster ratio to */
+  /*0x000,	*/	                /* 4x */
+  /*0x027,*/		                /* set V0 voltage resistor ratio to large */
+  0x081,		                /* set contrast */
+  0x018,		                /* contrast value*/
+  0x0ac,		                /* indicator */
+  0x000,		                /* disable */
+  0x0af,		                /* display on */
+
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+#endif
+
+/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */
+static const uint8_t u8g_dev_st7565_lm6063_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+
+  0x0a3,		                /* 0x0a2: LCD bias 1/9 (suggested for the LM6063), 0x0a3: Used by Adafruit */
+  0x0a1,		                /* 0x0a1: ADC set to reverse (suggested for the LM6063), 0x0a0: Used by Adafruit -> normal mode */
+  0x0c0,                            /* common output mode: set scan direction normal operation/SHL Select, 0x0c0 --> SHL = 0, normal, 0x0c8 --> SHL = 1 */
+  0x040,		                /* set display start line */
+  
+  0x028 | 0x04,                 /* power control: turn on voltage converter */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  0x028 | 0x06,                 /* power control: turn on voltage regulator */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+  
+  0x028 | 0x07,                 /* power control: turn on voltage follower */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  0x026,		                /* set V0 voltage resistor ratio to 6 (Adafruit Value, no info from LM6063 Manual) */
+  
+  0x0a6,                           /* display normal, bit val 0: LCD pixel off. */
+  
+  0x081,		                /* set contrast */
+  0x018,		                /* contrast value*/
+  
+  /*0x0ac,*/		                /* indicator */
+  /*0x000,*/		                /* disable */
+  
+  0x0af,		                /* display on */
+
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_lm6063_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 0 */      
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_st7565_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ac,		/* static indicator off */
+  0x000,		                /* indicator register set (not sure if this is required) */
+  0x0ae,		/* display off */      
+  0x0a5,		/* all points on */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_st7565_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0a4,		/* all points off */      
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+uint8_t u8g_dev_st7565_lm6063_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6063_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6063_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_st7565_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_st7565_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_st7565_lm6063_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_lm6063_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7565_lm6063_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_lm6063_fn, U8G_COM_HW_SPI);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7565_nhd_c12832.c

@@ -0,0 +1,143 @@
+/*
+
+  u8g_dev_st7565_nhd_c12832.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 32
+#define PAGE_HEIGHT 8
+
+static const uint8_t u8g_dev_st7565_c12832_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+
+  0x040,		/* set display start line to 0 */
+  0x0a0,		/* ADC set, values: a0=normal, a1=reverse */
+  0x0c8,		/* common output mode: c0=normal, c8=reverse */
+  0x0a6,		/* display normal, bit val 0: LCD pixel off. */
+  0x0a2,		/* LCD bias 1/9 */
+  0x02f,		/* all power  control circuits on */
+  0x0f8,		/* set booster ratio to */
+  0x000,		/* 4x */
+  0x023,		/* set V0 voltage resistor ratio to large */
+  0x081,		/* set contrast */
+  0x00a,		/* contrast value */
+  0x0ac,		/* indicator */
+  0x000,		/* disable */
+  0x0af,		/* display on */
+
+
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_c12832_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 0  */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_c12832_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ac,		/* static indicator off */
+  0x000,		                /* indicator register set (not sure if this is required) */
+  0x0ae,		/* display off */      
+  0x0a5,		/* all points on */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_c12832_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0a4,		/* all points off */      
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_st7565_c12832_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12832_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12832_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12832_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12832_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_st7565_nhd_c12832_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_c12832_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7565_nhd_c12832_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_c12832_fn, U8G_COM_HW_SPI);
+U8G_PB_DEV(u8g_dev_st7565_nhd_c12832_parallel, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_c12832_fn, U8G_COM_PARALLEL);

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7565_nhd_c12864.c

@@ -0,0 +1,145 @@
+/*
+
+  u8g_dev_st7565_nhd_c12864.c
+
+  Support for the NHD-C12864A1Z-FSB-FBW (Newhaven Display)
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+const uint8_t u8g_dev_st7565_nhd_c12864_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(10),           /* do reset low pulse with (10*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+  
+  0x040,		                /* set display start line */
+  0x0a1,		                /* ADC set to reverse */
+  0x0c0,		                /* common output mode: set scan direction normal operation */
+  0x0a6,                           /* display normal, bit val 0: LCD pixel off. */
+  0x0a2,		                /* LCD bias 1/9 */
+  0x02f,		                /* all power  control circuits on */
+  0x0f8,		                /* set booster ratio to */
+  0x000,		                /* 4x */
+  0x027,		                /* set V0 voltage resistor ratio to large */
+  0x081,		                /* set contrast */
+  0x008,		                /* contrast: 0x008 is a good value for NHD C12864, Nov 2012: User reports that 0x1a is much better */
+  0x0ac,		                /* indicator */
+  0x000,		                /* disable */
+  0x0af,		                /* display on */
+
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_nhd_c12864_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x004,		/* set lower 4 bit of the col adr to 4 (NHD C12864) */  
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_c12864_sleep_on[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0ac,		/* static indicator off */
+  0x000,		                /* indicator register set (not sure if this is required) */
+  0x0ae,		/* display off */      
+  0x0a5,		/* all points on */      
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_st7565_c12864_sleep_off[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0a4,		/* all points off */      
+  0x0af,		/* display on */      
+  U8G_ESC_DLY(50),       /* delay 50 ms */
+  U8G_ESC_CS(1),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_st7565_nhd_c12864_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_nhd_c12864_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_nhd_c12864_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+    case U8G_DEV_MSG_SLEEP_ON:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12864_sleep_on);    
+      return 1;
+    case U8G_DEV_MSG_SLEEP_OFF:
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_c12864_sleep_off);    
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_st7565_nhd_c12864_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_nhd_c12864_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7565_nhd_c12864_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_nhd_c12864_fn, U8G_COM_HW_SPI);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7687_c144mvgd.c

@@ -0,0 +1,420 @@
+/*
+
+  u8g_dev_st7687_c144mvgd.c (1.44" TFT)
+  
+  Status: Started, but not finished
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 128
+#define PAGE_HEIGHT 8
+
+
+#ifdef FIRST_VERSION
+/* 
+see also: read.pudn.com/downloads115/sourcecode/app/484503/LCM_Display.c__.htm 
+http://en.pudn.com/downloads115/sourcecode/app/detail484503_en.html
+*/
+
+static const uint8_t u8g_dev_st7687_c144mvgd_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  
+  0x001,                        /* A0=0, SW reset */
+  U8G_ESC_DLY(200),         /* delay 200 ms */
+  
+  0x0d7,                        /* EEPROM data auto re-load control */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x09f,                             /* ARD = 1 */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+  0x0e0,                        /* EEPROM control in */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x000,                             /*  */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+#ifdef NOT_REQUIRED  
+  0x0fa,                        /* EEPROM function selection 8.1.66 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x000,                             /*  */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+#endif 
+
+  0x0e3,                        /* Read from EEPROM, 8.1.55 */
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+
+  0x0e1,                        /* EEPROM control out, 8.1.53 */
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+  //0x028,                        /* display off */
+  0x011,                                /* Sleep out & booster on */
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+  0x0c0,                        /* Vop setting, 8.1.42 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x000,                             /*  */
+  0x001,                             /*  3.6 + 256*0.04 = 13.84 Volt */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+  0x0c3,                                /* Bias selection, 8.1.45 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x003,
+  U8G_ESC_ADR(0),           /* instruction mode */
+  
+  0x0c4,                                /* Booster setting 8.1.46 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x007,
+  U8G_ESC_ADR(0),           /* instruction mode */
+  
+  0x0c5,                                /* ??? */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x001,
+  U8G_ESC_ADR(0),           /* instruction mode */
+  
+  0x0cb,                                /* FV3 with Booster x2 control, 8.1.47 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x001,
+  U8G_ESC_ADR(0),           /* instruction mode */
+  
+  0x036,                                /* Memory data access control, 8.1.28 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x080,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0b5,                                /* N-line control, 8.1.37 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x089,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+
+  0x0d0,                                /* Analog circuit setting, 8.1.49 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x01d,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0b7,                                /* Com/Seg Scan Direction, 8.1.38 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x040,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x025,                                /* Write contrast, 8.1.17 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x03f,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x03a,                                /* Interface pixel format, 8.1.32 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x004,                                /* 3: 12 bit per pixel Type A, 4: 12 bit Type B, 5: 16bit per pixel */
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0b0,                                /* Display Duty setting, 8.1.34 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x07f,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0f0,                                /* Frame Freq. in Temp range A,B,C and D, 8.1.59 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x007,
+  0x00c,
+  0x00c,
+  0x015,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0f9,                                /* Frame RGB Value, 8.1.65 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x000,
+  0x005,
+  0x008,
+  0x00a,
+  0x00c,
+  0x00e,
+  0x010,
+  0x011,
+  0x012,
+  0x013,
+  0x014,
+  0x015,
+  0x016,
+  0x018,
+  0x01a,
+  0x01b,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0f9,                                /* Frame RGB Value, 8.1.65 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x000,
+  0x000,
+  0x000,
+  0x000,
+  0x033,
+  0x055,
+  0x055,
+  0x055,
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x029,                        /* display on */
+
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+
+};
+
+#else
+
+/*
+http://www.waitingforfriday.com/images/e/e3/FTM144D01N_test.zip
+*/
+
+static const uint8_t u8g_dev_st7687_c144mvgd_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+
+  0x011,                                /* Sleep out & booster on */
+  U8G_ESC_DLY(5),         /* delay 5 ms */
+    
+  0x03a,                                /* Interface pixel format, 8.1.32 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x004,                                /* 3: 12 bit per pixel Type A, 4: 12 bit Type B, 5: 16bit per pixel */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  
+  
+  0x026,                                /* SET_GAMMA_CURVE */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x004,                                
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0f2,                                /* GAM_R_SEL */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x001,                                /* enable gamma adj */                                
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+
+  0x0e0,                                /* POSITIVE_GAMMA_CORRECT */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x3f,
+    0x25,
+    0x1c,
+    0x1e,
+    0x20,
+    0x12,
+    0x2a,
+    0x90,
+    0x24,
+    0x11,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,    
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0e1,                                /* NEGATIVE_GAMMA_CORRECT */
+  U8G_ESC_ADR(1),           /* data mode */
+    0x20,
+    0x20,
+    0x20,
+    0x20,
+    0x05,
+    0x00,
+    0x15,
+    0xa7,
+    0x3d,
+    0x18,
+    0x25,
+    0x2a,
+    0x2b,
+    0x2b,
+    0x3a,
+  U8G_ESC_ADR(0),           /* instruction mode */
+     
+  0x0b1,                                /* FRAME_RATE_CONTROL1 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x008,                                /* DIVA = 8 */
+  0x008,                                /* VPA = 8 */
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+
+  0x0b4,                                /* DISPLAY_INVERSION */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x007,                                /* NLA = 1, NLB = 1, NLC = 1 (all on Frame Inversion) */
+  U8G_ESC_ADR(0),           /* instruction mode */
+    
+  0x0c0,                                /* POWER_CONTROL1 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x00a,                                /* VRH = 10:  GVDD = 4.30 */
+  0x002,                                /* VC = 2: VCI1 = 2.65 */
+  U8G_ESC_ADR(0),           /* instruction mode */
+   
+  0x0c1,                                /* POWER_CONTROL2 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x002,                                /* BT = 2: AVDD = 2xVCI1, VCL = -1xVCI1, VGH = 5xVCI1, VGL = -2xVCI1 */
+  U8G_ESC_ADR(0),           /* instruction mode */
+      
+  0x0c5,                                /* VCOM_CONTROL1 */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x050,                                /* VMH = 80: VCOMH voltage = 4.5 */
+  0x05b,                                /* VML = 91: VCOML voltage = -0.225 */
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x0c7,                                /* VCOM_OFFSET_CONTROL */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x040,                                /* nVM = 0, VMF = 64: VCOMH output = VMH, VCOML output = VML */
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x02a,                                /* SET_COLUMN_ADDRESS */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x000,                                /*  */
+  0x000,                                /*  */
+  0x000,                                /*  */
+  0x07f,                                /*  */
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x02b,                                /* SET_PAGE_ADDRESS */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x000,                                /*  */
+  0x000,                                /*  */
+  0x000,                                /*  */
+  0x07f,                                /*  */
+  U8G_ESC_ADR(0),           /* instruction mode */
+
+  0x036,                                /* SET_ADDRESS_MODE */
+  U8G_ESC_ADR(1),           /* data mode */
+  0x000,                                /* Select display orientation */
+  U8G_ESC_ADR(0),           /* instruction mode */
+	
+
+  0x029,                        /* display on */
+  
+  0x02c,                         /* write start */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+
+};
+
+#endif
+
+
+
+
+/* calculate bytes for Type B 4096 color display */
+static uint8_t get_byte_1(uint8_t v)
+{
+  v >>= 4;
+  v &= 0x0e;
+  return v;
+}
+
+static uint8_t get_byte_2(uint8_t v)
+{
+  uint8_t w;
+  w = v;
+  w &= 3;
+  w = (w<<2) | w;
+  v <<= 3;
+  v &= 0x0e0;
+  w |= v;
+  return w;
+}
+
+uint8_t u8g_dev_st7687_c144mvgd_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7687_c144mvgd_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i, j;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_WriteByte(u8g, dev, 0x02a );      /* Column address set 8.1.20 */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        u8g_WriteByte(u8g, dev, 0x000 );      /* x0 */
+        u8g_WriteByte(u8g, dev, WIDTH-1 );      /* x1 */
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_WriteByte(u8g, dev, 0x02b );      /* Row address set 8.1.21 */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        u8g_WriteByte(u8g, dev, y );      /* y0 */
+        u8g_WriteByte(u8g, dev, y+PAGE_HEIGHT-1 );      /* y1 */
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_WriteByte(u8g, dev, 0x02c );      /* Memory write 8.1.22 */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        
+        for( i = 0; i < PAGE_HEIGHT; i ++ )
+        {
+          
+          for( j = 0; j < WIDTH; j ++ )
+          {
+            u8g_WriteByte(u8g, dev, get_byte_1(*ptr) );     
+            u8g_WriteByte(u8g, dev, get_byte_2(*ptr) );                 
+            ptr++;
+          }
+        }
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h8_base_fn(u8g, dev, msg, arg);
+}
+
+
+uint8_t u8g_st7687_c144mvgd_8h8_buf[WIDTH*8] U8G_NOCOMMON ; 
+u8g_pb_t u8g_st7687_c144mvgd_8h8_pb = { {8, HEIGHT, 0, 0, 0},  WIDTH, u8g_st7687_c144mvgd_8h8_buf}; 
+
+u8g_dev_t u8g_dev_st7687_c144mvgd_sw_spi = { u8g_dev_st7687_c144mvgd_fn, &u8g_st7687_c144mvgd_8h8_pb, u8g_com_arduino_sw_spi_fn };
+
+u8g_dev_t u8g_dev_st7687_c144mvgd_8bit = { u8g_dev_st7687_c144mvgd_fn, &u8g_st7687_c144mvgd_8h8_pb, U8G_COM_PARALLEL };

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7920_128x64.c

@@ -0,0 +1,171 @@
+/*
+
+  u8g_dev_st7565_128x64.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+
+/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */
+static const uint8_t u8g_dev_st7920_128x64_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_DLY(100),         /* 8 Dez 2012: additional delay 100 ms because of reset*/
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  0x038,                                /* 8 Bit interface (DL=1), basic instruction set (RE=0) */
+  0x00c,                                /* display on, cursor & blink off; 0x08: all off */
+  0x006,                                /* Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift */
+  0x002,                                /* disable scroll, enable CGRAM adress */
+  0x001,                                /* clear RAM, needs 1.6 ms */
+  U8G_ESC_DLY(100),               /* delay 100 ms */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_st7920_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_128x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        for( i = 0; i < 8; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x03e );      /* enable extended mode */
+
+          if ( y < 32 )
+          {
+                  u8g_WriteByte(u8g, dev, 0x080 | y );      /* y pos  */
+                  u8g_WriteByte(u8g, dev, 0x080  );      /* set x pos to 0*/
+          }
+          else
+          {
+                  u8g_WriteByte(u8g, dev, 0x080 | (y-32) );      /* y pos  */
+                  u8g_WriteByte(u8g, dev, 0x080 | 8);      /* set x pos to 64*/
+          }
+          
+          u8g_SetAddress(u8g, dev, 1);                  /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          y++;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_st7920_128x64_4x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_128x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        for( i = 0; i < 32; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x03e );      /* enable extended mode */
+
+          if ( y < 32 )
+          {
+                  u8g_WriteByte(u8g, dev, 0x080 | y );      /* y pos  */
+                  u8g_WriteByte(u8g, dev, 0x080  );      /* set x pos to 0*/
+          }
+          else
+          {
+                  u8g_WriteByte(u8g, dev, 0x080 | (y-32) );      /* y pos  */
+                  u8g_WriteByte(u8g, dev, 0x080 | 8);      /* set x pos to 64*/
+          }
+          
+          u8g_SetAddress(u8g, dev, 1);                  /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          y++;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb32h1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_st7920_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_128x64_fn, U8G_COM_ST7920_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7920_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_128x64_fn, U8G_COM_ST7920_HW_SPI);
+U8G_PB_DEV(u8g_dev_st7920_128x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_128x64_fn, U8G_COM_FAST_PARALLEL);
+
+#define QWIDTH (WIDTH*4)
+uint8_t u8g_dev_st7920_128x64_4x_buf[QWIDTH] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_st7920_128x64_4x_pb = { {32, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_st7920_128x64_4x_buf}; 
+u8g_dev_t u8g_dev_st7920_128x64_4x_sw_spi = { u8g_dev_st7920_128x64_4x_fn, &u8g_dev_st7920_128x64_4x_pb, U8G_COM_ST7920_SW_SPI };
+u8g_dev_t u8g_dev_st7920_128x64_4x_hw_spi = { u8g_dev_st7920_128x64_4x_fn, &u8g_dev_st7920_128x64_4x_pb, U8G_COM_ST7920_HW_SPI };
+u8g_dev_t u8g_dev_st7920_128x64_4x_8bit = { u8g_dev_st7920_128x64_4x_fn, &u8g_dev_st7920_128x64_4x_pb, U8G_COM_FAST_PARALLEL };
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7920_192x32.c

@@ -0,0 +1,151 @@
+/*
+
+  u8g_dev_st7920_192x32.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 192
+#define HEIGHT 32
+
+
+/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */
+static const uint8_t u8g_dev_st7920_192x32_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_DLY(100),         /* 8 Dez 2012: additional delay 100 ms because of reset*/
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  0x038,                                /* 8 Bit interface (DL=1), basic instruction set (RE=0) */
+  0x00c,                                /* display on, cursor & blink off; 0x08: all off */
+  0x006,                                /* Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift */
+  0x002,                                /* disable scroll, enable CGRAM adress */
+  0x001,                                /* clear RAM, needs 1.6 ms */
+  U8G_ESC_DLY(100),               /* delay 10 ms */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_st7920_192x32_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_192x32_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        for( i = 0; i < 8; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x03e );      /* enable extended mode */
+          u8g_WriteByte(u8g, dev, 0x080 | y );      /* y pos  */
+          u8g_WriteByte(u8g, dev, 0x080  );      /* set x pos to 0*/          
+          u8g_SetAddress(u8g, dev, 1);                  /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          y++;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_st7920_192x32_4x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_192x32_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        for( i = 0; i < 32; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x03e );      /* enable extended mode */
+          u8g_WriteByte(u8g, dev, 0x080 | y );      /* y pos  */
+          u8g_WriteByte(u8g, dev, 0x080  );      /* set x pos to 0*/          
+          u8g_SetAddress(u8g, dev, 1);                  /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          y++;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb32h1_base_fn(u8g, dev, msg, arg);
+}
+
+
+U8G_PB_DEV(u8g_dev_st7920_192x32_sw_spi, WIDTH, HEIGHT, 8, u8g_dev_st7920_192x32_fn, U8G_COM_ST7920_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7920_192x32_hw_spi, WIDTH, HEIGHT, 8, u8g_dev_st7920_192x32_fn, U8G_COM_ST7920_HW_SPI);
+U8G_PB_DEV(u8g_dev_st7920_192x32_8bit, WIDTH, HEIGHT, 8, u8g_dev_st7920_192x32_fn, U8G_COM_FAST_PARALLEL);
+
+
+#define QWIDTH (WIDTH*4)
+uint8_t u8g_dev_st7920_192x32_4x_buf[QWIDTH] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_st7920_192x32_4x_pb = { {32, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_st7920_192x32_4x_buf}; 
+u8g_dev_t u8g_dev_st7920_192x32_4x_sw_spi = { u8g_dev_st7920_192x32_4x_fn, &u8g_dev_st7920_192x32_4x_pb, U8G_COM_ST7920_SW_SPI };
+u8g_dev_t u8g_dev_st7920_192x32_4x_hw_spi = { u8g_dev_st7920_192x32_4x_fn, &u8g_dev_st7920_192x32_4x_pb, U8G_COM_ST7920_HW_SPI };
+u8g_dev_t u8g_dev_st7920_192x32_4x_8bit = { u8g_dev_st7920_192x32_4x_fn, &u8g_dev_st7920_192x32_4x_pb, U8G_COM_FAST_PARALLEL };
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_st7920_202x32.c

@@ -0,0 +1,154 @@
+/*
+
+  u8g_dev_st7920_202x32.c
+  tested with CFAG20232
+  
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 202
+#define HEIGHT 32
+#define PAGE_HEIGHT 8
+
+
+/* init sequence from https://github.com/adafruit/ST7565-LCD/blob/master/ST7565/ST7565.cpp */
+static const uint8_t u8g_dev_st7920_202x32_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+  U8G_ESC_DLY(100),         /* 8 Dez 2012: additional delay 100 ms because of reset*/
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  0x038,                                /* 8 Bit interface (DL=1), basic instruction set (RE=0) */
+  0x00c,                                /* display on, cursor & blink off; 0x08: all off */
+  0x006,                                /* Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift */
+  0x002,                                /* disable scroll, enable CGRAM adress */
+  0x001,                                /* clear RAM, needs 1.6 ms */
+  U8G_ESC_DLY(100),               /* delay 10 ms */
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_st7920_202x32_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_202x32_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        for( i = 0; i < 8; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x03e );      /* enable extended mode */
+          u8g_WriteByte(u8g, dev, 0x080 | y );      /* y pos  */
+          u8g_WriteByte(u8g, dev, 0x080  );      /* set x pos to 0*/          
+          u8g_SetAddress(u8g, dev, 1);                  /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          y++;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb8h1_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_st7920_202x32_4x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7920_202x32_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        for( i = 0; i < 32; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x03e );      /* enable extended mode */
+          u8g_WriteByte(u8g, dev, 0x080 | y );      /* y pos  */
+          u8g_WriteByte(u8g, dev, 0x080  );      /* set x pos to 0*/          
+          u8g_SetAddress(u8g, dev, 1);                  /* data mode */
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);
+          ptr += WIDTH/8;
+          y++;
+        }
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb32h1_base_fn(u8g, dev, msg, arg);
+}
+
+
+U8G_PB_DEV(u8g_dev_st7920_202x32_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_202x32_fn, U8G_COM_ST7920_SW_SPI);
+U8G_PB_DEV(u8g_dev_st7920_202x32_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_202x32_fn, U8G_COM_ST7920_HW_SPI);
+U8G_PB_DEV(u8g_dev_st7920_202x32_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_202x32_fn, U8G_COM_FAST_PARALLEL);
+
+#define QWIDTH (WIDTH*4)
+uint8_t u8g_dev_st7920_202x32_4x_buf[QWIDTH] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_st7920_202x32_4x_pb = { {32, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_st7920_202x32_4x_buf}; 
+u8g_dev_t u8g_dev_st7920_202x32_4x_sw_spi = { u8g_dev_st7920_202x32_4x_fn, &u8g_dev_st7920_202x32_4x_pb, U8G_COM_ST7920_SW_SPI };
+u8g_dev_t u8g_dev_st7920_202x32_4x_hw_spi = { u8g_dev_st7920_202x32_4x_fn, &u8g_dev_st7920_202x32_4x_pb, U8G_COM_ST7920_HW_SPI };
+u8g_dev_t u8g_dev_st7920_202x32_4x_8bit = { u8g_dev_st7920_202x32_4x_fn, &u8g_dev_st7920_202x32_4x_pb, U8G_COM_FAST_PARALLEL };
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_t6963_128x64.c

@@ -0,0 +1,191 @@
+/*
+
+  u8g_dev_t6963_128x64.c
+  
+  Tested with Varitronix MGLS240128TZ
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2013, olikraus@gmail.com
+  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.  
+  
+        
+  Application Notes for the MGLS 240x128
+    www.baso.no/content/pdf/T6963C_Application.pdf
+  
+  Hitachi App Notes:
+    https://www.sparkfun.com/datasheets/LCD/Monochrome/AN-029-Toshiba_T6963C.pdf
+
+  Notes:
+    The font selection pins should generate the 8x8 font.
+    For the MGLS240128TZ only FS1 is available on pin 18.
+    FS1 must be low to generate the 8x8 font.
+  
+  
+*/
+
+#include "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 16
+
+
+/* text is not used, so settings are not relevant */
+static const uint8_t u8g_dev_t6963_128x64_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* data mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x021,                                /* set cursor position */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x022,                                /* set offset */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x040,				     /* text home */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8,                      	    /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x041,				     /* text columns */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x042,				     /* graphics home */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8,                      /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x043,				     /* graphics columns */
+  
+  // mode set
+  // 0x080: Internal CG, OR Mode
+  // 0x081: Internal CG, EXOR Mode
+  // 0x083: Internal CG, AND Mode
+  // 0x088: External CG, OR Mode
+  // 0x089: External CG, EXOR Mode
+  // 0x08B: External CG, AND Mode
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x080,                                /* mode register: OR Mode, Internal Character Mode */
+  
+  U8G_ESC_ADR(1),               /* instruction mode */
+  // display mode
+  // 0x090: Display off
+  // 0x094: Graphic off, text on, cursor off, blink off
+  // 0x096: Graphic off, text on, cursor on, blink off
+  // 0x097: Graphic off, text on, cursor on, blink on
+  // 0x098: Graphic on, text off, cursor off, blink off
+  // 0x09a: Graphic on, text off, cursor on, blink off
+  // ...
+  // 0x09c: Graphic on, text on, cursor off, blink off
+  // 0x09f: Graphic on, text on, cursor on, blink on
+  0x098,                                /* mode register: Display Mode, Graphics on, Text off, Cursor off */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x024,                                /* set adr pointer */
+  
+
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_t6963_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);    
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_t6963_128x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint16_t disp_ram_adr;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+
+        
+	u8g_SetAddress(u8g, dev, 0);           /* data mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        disp_ram_adr = WIDTH/8;
+        disp_ram_adr *= y;
+        for( i = 0; i < PAGE_HEIGHT; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr&255 );      /* address low byte */
+          u8g_WriteByte(u8g, dev, disp_ram_adr>>8 );      /* address hight byte */
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x024 );      /* set adr ptr */
+	  
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);	
+	  
+          ptr += WIDTH/8;
+          disp_ram_adr += WIDTH/8;
+        }
+	u8g_SetAddress(u8g, dev, 0);           /* data mode */
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg);
+}
+
+// U8G_PB_DEV(u8g_dev_t6963_128x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_t6963_128x64_fn, U8G_COM_T6963);
+
+uint8_t u8g_dev_t6963_128x64_2x_bw_buf[WIDTH/8*PAGE_HEIGHT] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_t6963_128x64_2x_bw_pb = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_t6963_128x64_2x_bw_buf}; 
+u8g_dev_t u8g_dev_t6963_128x64_8bit = { u8g_dev_t6963_128x64_fn, &u8g_dev_t6963_128x64_2x_bw_pb, U8G_COM_T6963 };
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_t6963_240x128.c

@@ -0,0 +1,195 @@
+/*
+
+  u8g_dev_t6963_240x128.c
+  
+  Tested with Varitronix MGLS240128TZ
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2013, olikraus@gmail.com
+  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.  
+    
+        
+  Application Notes for the MGLS 240x128
+    www.baso.no/content/pdf/T6963C_Application.pdf
+  
+  Hitachi App Notes:
+    https://www.sparkfun.com/datasheets/LCD/Monochrome/AN-029-Toshiba_T6963C.pdf
+
+  Notes:
+    The font selection pins should generate the 8x8 font.
+    For the MGLS240128TZ only FS1 is available on pin 18.
+    FS1 must be low to generate the 8x8 font.
+  
+
+*/
+
+#include "u8g.h"
+
+#define WIDTH 240
+#define HEIGHT 128
+#define PAGE_HEIGHT 16
+
+
+/*
+  http://www.mark-products.com/graphics.htm#240x64%20Pixel%20Format
+*/
+
+/* text is not used, so settings are not relevant */
+static const uint8_t u8g_dev_t6963_240x128_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* data mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x021,                                /* set cursor position */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x022,                                /* set offset */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x040,				     /* text home */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8,                      	    /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x041,				     /* text columns */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x042,				     /* graphics home */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8,                            /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x043,				     /* graphics columns */
+  
+  // mode set
+  // 0x080: Internal CG, OR Mode
+  // 0x081: Internal CG, EXOR Mode
+  // 0x083: Internal CG, AND Mode
+  // 0x088: External CG, OR Mode
+  // 0x089: External CG, EXOR Mode
+  // 0x08B: External CG, AND Mode
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x080,                                /* mode register: OR Mode, Internal Character Mode */
+  
+  U8G_ESC_ADR(1),               /* instruction mode */
+  // display mode
+  // 0x090: Display off
+  // 0x094: Graphic off, text on, cursor off, blink off
+  // 0x096: Graphic off, text on, cursor on, blink off
+  // 0x097: Graphic off, text on, cursor on, blink on
+  // 0x098: Graphic on, text off, cursor off, blink off
+  // 0x09a: Graphic on, text off, cursor on, blink off
+  // ...
+  // 0x09c: Graphic on, text on, cursor off, blink off
+  // 0x09f: Graphic on, text on, cursor on, blink on
+  0x098,                                /* mode register: Display Mode, Graphics on, Text off, Cursor off */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x024,                                /* set adr pointer */
+  
+
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_t6963_240x128_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);    
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_t6963_240x128_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint16_t disp_ram_adr;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+
+        
+	u8g_SetAddress(u8g, dev, 0);           /* data mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        disp_ram_adr = WIDTH/8;
+        disp_ram_adr *= y;
+        for( i = 0; i < PAGE_HEIGHT; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr&255 );      /* address low byte */
+          u8g_WriteByte(u8g, dev, disp_ram_adr>>8 );      /* address hight byte */
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x024 );      /* set adr ptr */
+	  
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);	
+	  
+          ptr += WIDTH/8;
+          disp_ram_adr += WIDTH/8;
+        }
+	u8g_SetAddress(u8g, dev, 0);           /* data mode */
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg);
+}
+
+// U8G_PB_DEV(u8g_dev_t6963_240x128_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_t6963_240x128_fn, U8G_COM_T6963);
+
+uint8_t u8g_dev_t6963_240x128_2x_bw_buf[WIDTH/8*PAGE_HEIGHT] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_t6963_240x128_2x_bw_pb = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_t6963_240x128_2x_bw_buf}; 
+u8g_dev_t u8g_dev_t6963_240x128_8bit = { u8g_dev_t6963_240x128_fn, &u8g_dev_t6963_240x128_2x_bw_pb, U8G_COM_T6963 };
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_t6963_240x64.c

@@ -0,0 +1,195 @@
+/*
+
+  u8g_dev_t6963_240x64.c
+  
+  Tested with Varitronix MGLS240128TZ
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2013, olikraus@gmail.com
+  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.  
+  
+        
+  Application Notes for the MGLS 240x128
+    www.baso.no/content/pdf/T6963C_Application.pdf
+  
+  Hitachi App Notes:
+    https://www.sparkfun.com/datasheets/LCD/Monochrome/AN-029-Toshiba_T6963C.pdf
+
+  Notes:
+    The font selection pins should generate the 8x8 font.
+    For the MGLS240128TZ only FS1 is available on pin 18.
+    FS1 must be low to generate the 8x8 font.
+  
+  
+*/
+
+#include "u8g.h"
+
+#define WIDTH 240
+#define HEIGHT 64
+#define PAGE_HEIGHT 16
+
+
+/*
+  http://www.mark-products.com/graphics.htm#240x64%20Pixel%20Format
+*/
+
+/* text is not used, so settings are not relevant */
+static const uint8_t u8g_dev_t6963_240x64_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* data mode */
+  U8G_ESC_RST(15),           /* do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
+
+  U8G_ESC_CS(1),             /* enable chip */
+  U8G_ESC_DLY(50),         /* delay 50 ms */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x021,                                /* set cursor position */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x022,                                /* set offset */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x040,				     /* text home */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8,                      /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x041,				     /* text columns */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x042,				     /* graphics home */
+
+  U8G_ESC_ADR(0),               /* data mode */
+  WIDTH/8,                      /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x043,				     /* graphics columns */
+  
+  // mode set
+  // 0x080: Internal CG, OR Mode
+  // 0x081: Internal CG, EXOR Mode
+  // 0x083: Internal CG, AND Mode
+  // 0x088: External CG, OR Mode
+  // 0x089: External CG, EXOR Mode
+  // 0x08B: External CG, AND Mode
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x080,                                /* mode register: OR Mode, Internal Character Mode */
+  
+  U8G_ESC_ADR(1),               /* instruction mode */
+  // display mode
+  // 0x090: Display off
+  // 0x094: Graphic off, text on, cursor off, blink off
+  // 0x096: Graphic off, text on, cursor on, blink off
+  // 0x097: Graphic off, text on, cursor on, blink on
+  // 0x098: Graphic on, text off, cursor off, blink off
+  // 0x09a: Graphic on, text off, cursor on, blink off
+  // ...
+  // 0x09c: Graphic on, text on, cursor off, blink off
+  // 0x09f: Graphic on, text on, cursor on, blink on
+  0x098,                                /* mode register: Display Mode, Graphics on, Text off, Cursor off */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  0x000,                                /* low byte */
+  0x000,                                /* height byte */
+  U8G_ESC_ADR(1),               /* instruction mode */
+  0x024,                                /* set adr pointer */
+  
+
+  U8G_ESC_DLY(100),         /* delay 100 ms */
+  
+  U8G_ESC_ADR(0),               /* data mode */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_t6963_240x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);    
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_t6963_240x64_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        uint8_t y, i;
+        uint16_t disp_ram_adr;
+        uint8_t *ptr;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+
+        
+	u8g_SetAddress(u8g, dev, 0);           /* data mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        y = pb->p.page_y0;
+        ptr = pb->buf;
+        disp_ram_adr = WIDTH/8;
+        disp_ram_adr *= y;
+        for( i = 0; i < PAGE_HEIGHT; i ++ )
+        {
+          u8g_SetAddress(u8g, dev, 0);           /* data mode */
+          u8g_WriteByte(u8g, dev, disp_ram_adr&255 );      /* address low byte */
+          u8g_WriteByte(u8g, dev, disp_ram_adr>>8 );      /* address hight byte */
+          u8g_SetAddress(u8g, dev, 1);           /* cmd mode */
+          u8g_WriteByte(u8g, dev, 0x024 );      /* set adr ptr */
+	  
+          u8g_WriteSequence(u8g, dev, WIDTH/8, ptr);	
+	  
+          ptr += WIDTH/8;
+          disp_ram_adr += WIDTH/8;
+        }
+	u8g_SetAddress(u8g, dev, 0);           /* data mode */
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+  }
+  return u8g_dev_pb16h1_base_fn(u8g, dev, msg, arg);
+}
+
+// U8G_PB_DEV(u8g_dev_t6963_240x64_8bit, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_t6963_240x64_fn, U8G_COM_T6963);
+
+uint8_t u8g_dev_t6963_240x64_2x_bw_buf[WIDTH/8*PAGE_HEIGHT] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_t6963_240x64_2x_bw_pb = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_t6963_240x64_2x_bw_buf}; 
+u8g_dev_t u8g_dev_t6963_240x64_8bit = { u8g_dev_t6963_240x64_fn, &u8g_dev_t6963_240x64_2x_bw_pb, U8G_COM_T6963 };
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_tls8204_84x48.c

@@ -0,0 +1,115 @@
+/*
+
+  u8g_dev_tls8204_84x48.c
+  
+  Display: Nokia 84x48
+  
+  Status: Tested with TLS8204V12 Display by Olimex MOD-LCD3310
+  
+  Contributed: http://code.google.com/p/u8glib/issues/detail?id=126
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 84
+#define HEIGHT 48
+#define PAGE_HEIGHT 8
+
+
+static const uint8_t u8g_dev_tls8204_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x021,		/* activate chip (PD=0), horizontal increment (V=0), enter extended command set (H=1) */
+  0x006,		/* temp. control: b10 = 2 */
+  0x04 | !!((66-1)&(1u<<6)),
+  0x40 | ((66-2) & ((1u<<6)-1)),
+  0x013,		/* bias system 1:48 */
+  0x0c0,		/* medium Vop */
+  0x020,		/* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00c,		/* display on, normal operation */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00d,		                /* display on, invert */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+  0x00c,		                /* display on, normal */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+
+uint8_t u8g_dev_tls8204_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_tls8204_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_SetAddress(u8g, dev, 0);           /* command mode */
+        u8g_SetChipSelect(u8g, dev, 1);
+        u8g_WriteByte(u8g, dev, 0x020 );		/* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
+        u8g_WriteByte(u8g, dev, 0x080 );                        /* set X address */
+        u8g_WriteByte(u8g, dev, 0x040 | pb->p.page); /* set Y address */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      /* the contrast adjustment does not work, needs to be analysed */
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_WriteByte(u8g, dev, 0x021);        /* command mode, extended function set */
+      u8g_WriteByte(u8g, dev, 0x080 | ( (*(uint8_t *)arg) >> 1 ) );
+      u8g_WriteByte(u8g, dev, 0x020);        /* command mode, extended function set */
+      u8g_SetChipSelect(u8g, dev, 0);
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+
+U8G_PB_DEV(u8g_dev_tls8204_84x48_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_tls8204_fn, U8G_COM_SW_SPI);
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_uc1610_dogxl160.c

@@ -0,0 +1,290 @@
+/*
+
+  u8g_dev_uc1610_dogxl160.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 160
+#define HEIGHT 104
+
+static const uint8_t u8g_dev_uc1610_dogxl160_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x0f1,	        /* set display height-1 */
+  0x067,		/*  */
+  0x0c0,		/* SEG & COM normal */
+  0x040,		/* set display start line */
+  0x050,		/* */
+  0x02b,		/* set panelloading */
+  0x0eb,		/* set bias 1/2 */
+  0x081,		/* set contrast */
+  0x05f,		/* */
+  0x089,		/* set auto increment */
+  0x0a6,		/* normal pixel mode */
+  0x0d3,		/* 0xd3=40% RMS separation for gray levels */
+  0x0af,		/* display on */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565, UC1610 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  
+  
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_uc1610_dogxl160_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 0 */      
+  U8G_ESC_END                /* end of sequence */
+};
+
+static uint8_t u8g_dev_1to2(uint8_t n)
+{
+  register uint8_t a,b,c;
+  a = n;
+  a &= 1;
+  n <<= 1;
+  b = n;
+  b &= 4;  
+  n <<= 1;
+  c = n;
+  c &= 16;
+  n <<= 1;
+  n &= 64;
+  n |= a;
+  n |= b;
+  n |= c;
+  n |= n << 1;
+  return n;
+}
+
+uint8_t u8g_dev_uc1610_dogxl160_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        int i;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*2) ); /* select current page 1/2 (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        for( i = 0; i < WIDTH; i++ )
+        {
+          u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf))[i] ) );          
+        }
+
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*2+1) ); /* select current page 2/2 (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        for( i = 0; i < WIDTH; i++ )
+        {
+          u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf))[i] >> 4 ) );          
+        }
+        
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_uc1610_dogxl160_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page) ); /* select current page (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb8v2_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_uc1610_dogxl160_2x_bw_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        int i;
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*4) ); /* select current page 1/2 (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        for( i = 0; i < WIDTH; i++ )
+        {
+          u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf))[i] ) );          
+        }
+
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*4+1) ); /* select current page 2/2 (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        for( i = 0; i < WIDTH; i++ )
+        {
+          u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf))[i] >> 4 ) );          
+        }
+
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*4+2) ); /* select current page 1/2 (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        for( i = 0; i < WIDTH; i++ )
+        {
+          u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf+WIDTH))[i] ) );          
+        }
+
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*4+3) ); /* select current page 2/2 (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        for( i = 0; i < WIDTH; i++ )
+        {
+          u8g_WriteByte(u8g, dev, u8g_dev_1to2( ((uint8_t *)(pb->buf+WIDTH))[i] >> 4 ) );          
+        }
+        
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb16v1_base_fn(u8g, dev, msg, arg);
+}
+
+uint8_t u8g_dev_uc1610_dogxl160_2x_gr_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*2) ); /* select current page (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_WriteSequence(u8g, dev, WIDTH, pb->buf) == 0 )
+          return 0;
+
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1610_dogxl160_data_start);    
+        u8g_WriteByte(u8g, dev, 0x060 | (pb->p.page*2+1) ); /* select current page (UC1610) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_WriteSequence(u8g, dev, WIDTH, pb->buf+WIDTH) == 0 )
+          return 0;
+        
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 1);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb16v2_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_uc1610_dogxl160_bw_sw_spi, WIDTH, HEIGHT, 8, u8g_dev_uc1610_dogxl160_bw_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_uc1610_dogxl160_bw_hw_spi, WIDTH, HEIGHT, 8, u8g_dev_uc1610_dogxl160_bw_fn, U8G_COM_HW_SPI);
+
+U8G_PB_DEV(u8g_dev_uc1610_dogxl160_gr_sw_spi, WIDTH, HEIGHT, 4, u8g_dev_uc1610_dogxl160_gr_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_uc1610_dogxl160_gr_hw_spi, WIDTH, HEIGHT, 4, u8g_dev_uc1610_dogxl160_gr_fn, U8G_COM_HW_SPI);
+
+uint8_t u8g_dev_uc1610_dogxl160_2x_bw_buf[WIDTH*2] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_uc1610_dogxl160_2x_bw_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_uc1610_dogxl160_2x_bw_buf}; 
+u8g_dev_t u8g_dev_uc1610_dogxl160_2x_bw_sw_spi = { u8g_dev_uc1610_dogxl160_2x_bw_fn, &u8g_dev_uc1610_dogxl160_2x_bw_pb, U8G_COM_SW_SPI };
+u8g_dev_t u8g_dev_uc1610_dogxl160_2x_bw_hw_spi = { u8g_dev_uc1610_dogxl160_2x_bw_fn, &u8g_dev_uc1610_dogxl160_2x_bw_pb, U8G_COM_HW_SPI };
+
+uint8_t u8g_dev_uc1610_dogxl160_2x_gr_buf[WIDTH*2] U8G_NOCOMMON ; 
+u8g_pb_t u8g_dev_uc1610_dogxl160_2x_gr_pb = { {8, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_uc1610_dogxl160_2x_gr_buf}; 
+u8g_dev_t u8g_dev_uc1610_dogxl160_2x_gr_sw_spi = { u8g_dev_uc1610_dogxl160_2x_gr_fn, &u8g_dev_uc1610_dogxl160_2x_gr_pb, U8G_COM_SW_SPI };
+u8g_dev_t u8g_dev_uc1610_dogxl160_2x_gr_hw_spi = { u8g_dev_uc1610_dogxl160_2x_gr_fn, &u8g_dev_uc1610_dogxl160_2x_gr_pb, U8G_COM_HW_SPI };

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_uc1701_dogs102.c

@@ -0,0 +1,113 @@
+/*
+
+  u8g_dev_uc1701_dogs102.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 102
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+static const uint8_t u8g_dev_dogs102_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x040,		                /* set display start line to 0 */
+  0x0a1,		                /* ADC set to reverse */
+  0x0c0,		                /* common output mode */
+  0x0a6,		                /* display normal, bit val 0: LCD pixel off. */
+  0x0a2,		                /* LCD bias 1/9 */
+  0x02f,		                /* all power  control circuits on */
+  0x027,		                /* regulator, booster and follower */
+  0x081,		                /* set contrast */
+  0x00e,		                /* contrast value, EA default: 0x010, previous value for S102: 0x0e */
+  0x0fa,		                /* Set Temp compensation */ 
+  0x090,		                /* 0.11 deg/c WP Off WC Off*/
+  0x0a4,		                /* normal display  */
+  0x0af,		                /* display on */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565, UC1610 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_dogs102_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 0 */      
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_dogs102_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_dogs102_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_dogs102_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_uc1701_dogs102_sw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_dogs102_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_uc1701_dogs102_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_dogs102_fn, U8G_COM_HW_SPI);
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_dev_uc1701_mini12864.c

@@ -0,0 +1,114 @@
+/*
+
+  u8g_dev_uc1701_mini12864.c (dealextreme)
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+#define WIDTH 128
+#define HEIGHT 64
+#define PAGE_HEIGHT 8
+
+static const uint8_t u8g_dev_uc1701_mini12864_init_seq[] PROGMEM = {
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_RST(1),           /* do reset low pulse with (1*16)+2 milliseconds */
+  U8G_ESC_CS(1),             /* enable chip */
+
+  0x040,		/* set display start line to 0 */
+  0x0a0,		/* ADC set to reverse */
+  0x0c8,		/* common output mode */
+  0x0a6,		/* display normal, bit val 0: LCD pixel off. */
+  0x0a2,		/* LCD bias 1/9 */
+  0x02f,		/* all power  control circuits on */
+  0x0f8,		/* set booster ratio to */
+  0x000,		/* 4x */
+  0x023,		/* set V0 voltage resistor ratio to large */
+  0x081,		/* set contrast */
+  0x027,		/* contrast value */
+  0x0ac,		/* indicator */
+  0x000,		/* disable */
+  0x0af,		/* display on */
+
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a5,		                /* display all points, ST7565 */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  U8G_ESC_DLY(100),       /* delay 100 ms */
+  0x0a4,		                /* normal display */
+  U8G_ESC_CS(0),             /* disable chip */
+  U8G_ESC_END                /* end of sequence */
+};
+
+static const uint8_t u8g_dev_uc1701_mini12864_data_start[] PROGMEM = {
+  U8G_ESC_ADR(0),           /* instruction mode */
+  U8G_ESC_CS(1),             /* enable chip */
+  0x010,		/* set upper 4 bit of the col adr to 0 */
+  0x000,		/* set lower 4 bit of the col adr to 4  */
+  U8G_ESC_END                /* end of sequence */
+};
+
+uint8_t u8g_dev_uc1701_mini12864_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    case U8G_DEV_MSG_INIT:
+      u8g_InitCom(u8g, dev);
+      u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_init_seq);
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {
+        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_data_start);    
+        u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page */
+        u8g_SetAddress(u8g, dev, 1);           /* data mode */
+        if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
+          return 0;
+        u8g_SetChipSelect(u8g, dev, 0);
+      }
+      break;
+    case U8G_DEV_MSG_CONTRAST:
+      u8g_SetChipSelect(u8g, dev, 1);
+      u8g_SetAddress(u8g, dev, 0);          /* instruction mode */
+      u8g_WriteByte(u8g, dev, 0x081);
+      u8g_WriteByte(u8g, dev, (*(uint8_t *)arg) >> 2);
+      u8g_SetChipSelect(u8g, dev, 0);      
+      return 1;
+  }
+  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
+}
+
+U8G_PB_DEV(u8g_dev_uc1701_mini12864_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_uc1701_mini12864_fn, U8G_COM_SW_SPI);
+U8G_PB_DEV(u8g_dev_uc1701_mini12864_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_uc1701_mini12864_fn, U8G_COM_HW_SPI);

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_ellipse.c

@@ -0,0 +1,100 @@
+/*
+
+  u8g_ellipse.c
+
+  Utility to draw empty and filled ellipses.
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, bjthom@gmail.com
+  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.  
+  
+  Addition to the U8G Library as of 02/29/12
+  Adapted from Bresenham's Algorithm and the following websites:
+	http://free.pages.at/easyfilter/bresenham.html
+	http://homepage.smc.edu/kennedy_john/belipse.pdf
+  
+*/
+
+#include "u8g.h"
+
+
+#ifdef WORK_IN_PROGRESS
+
+void u8g_DrawEllipseRect(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t x1, u8g_uint_t y1)
+{
+	int a = abs(x1 - x0);
+	int b = abs(y1 - y0);	//get diameters
+	int b1 = b&1;
+	long dx = 4*(1-a)*b*b;
+	long dy = 4*(b1+1)*a*a;
+	long err = dx+dy+b1*a*a;
+	long e2;
+	
+	if (x0 > x1) { x0 = x1; x1 += a; }
+	if (y0 > y1) { y0 = y1; } 
+	y0 += (b+1)/2;
+	y1 = y0-b1;
+	a *= 8*a;
+	b1 = 8*b*b;
+	
+	do {
+		u8g_DrawPixel(u8g, x1, y0);
+		u8g_DrawPixel(u8g, x0, y0);
+		u8g_DrawPixel(u8g, x0, y1);
+		u8g_DrawPixel(u8g, x1, y1);
+		e2 = 2*err;
+		if (e2 >= dx) {
+			x0++;
+			x1--;
+			err += dx += b1;
+		}
+		if (e2 <= dy) {
+			y0++;
+			y1--;
+			err += dy += a;
+		}
+	} while (x0 <= x1);
+	
+	while (y0-y1 < b) {
+		u8g_DrawPixel(u8g, x0-1, y0);
+		u8g_DrawPixel(u8g, x1+1, y0++);
+		u8g_DrawPixel(u8g, x0-1, y1);
+		u8g_DrawPixel(u8g, x1+1, y1--);
+	}
+}
+
+void u8g_DrawEllipse(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t xr, u8g_uint_t yr)
+{
+	u8g_DrawPixel(u8g, x0, y0+yr);
+	u8g_DrawPixel(u8g, x0, y0-yr);
+	u8g_DrawPixel(u8g, x0+xr, y0);
+	u8g_DrawPixel(u8g, x0-xr, y0);
+}
+
+#endif
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_line.c

@@ -0,0 +1,81 @@
+/*
+
+  u8g_line.h
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+void u8g_DrawLine(u8g_t *u8g, u8g_uint_t x1, u8g_uint_t y1, u8g_uint_t x2, u8g_uint_t y2)
+{
+  u8g_uint_t tmp;
+  u8g_uint_t x,y;
+  u8g_uint_t dx, dy;
+  u8g_int_t err;
+  u8g_int_t ystep;
+
+  uint8_t swapxy = 0;
+  
+  /* no BBX intersection check at the moment, should be added... */
+
+  if ( x1 > x2 ) dx = x1-x2; else dx = x2-x1;
+  if ( y1 > y2 ) dy = y1-y2; else dy = y2-y1;
+
+  if ( dy > dx ) 
+  {
+    swapxy = 1;
+    tmp = dx; dx =dy; dy = tmp;
+    tmp = x1; x1 =y1; y1 = tmp;
+    tmp = x2; x2 =y2; y2 = tmp;
+  }
+  if ( x1 > x2 ) 
+  {
+    tmp = x1; x1 =x2; x2 = tmp;
+    tmp = y1; y1 =y2; y2 = tmp;
+  }
+  err = dx >> 1;
+  if ( y2 > y1 ) ystep = 1; else ystep = -1;
+  y = y1;
+  for( x = x1; x <= x2; x++ )
+  {
+    if ( swapxy == 0 ) 
+      u8g_DrawPixel(u8g, x, y); 
+    else 
+      u8g_DrawPixel(u8g, y, x); 
+    err -= (uint8_t)dy;
+    if ( err < 0 ) 
+    {
+      y += (u8g_uint_t)ystep;
+      err += (u8g_uint_t)dx;
+    }
+  }
+}

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_ll_api.c

@@ -0,0 +1,456 @@
+/*
+
+  u8g_ll_api.c
+  
+  low level api
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 <stddef.h>
+#include "u8g.h"
+
+uint8_t u8g_call_dev_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  return dev->dev_fn(u8g, dev, msg, arg); 
+}
+
+/*====================================================================*/
+
+uint8_t u8g_InitLL(u8g_t *u8g, u8g_dev_t *dev)
+{
+  uint8_t r;
+  u8g->state_cb(U8G_STATE_MSG_BACKUP_ENV);
+  r =  u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_INIT, NULL);
+  u8g->state_cb(U8G_STATE_MSG_BACKUP_U8G);
+  u8g->state_cb(U8G_STATE_MSG_RESTORE_ENV);
+  return r;
+}
+
+void u8g_FirstPageLL(u8g_t *u8g, u8g_dev_t *dev)
+{  
+  u8g->state_cb(U8G_STATE_MSG_BACKUP_ENV);
+  u8g->state_cb(U8G_STATE_MSG_RESTORE_U8G);
+  u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_PAGE_FIRST, NULL);
+  u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_PAGE_BOX, &(u8g->current_page));
+  u8g->state_cb(U8G_STATE_MSG_RESTORE_ENV);
+}
+
+uint8_t u8g_NextPageLL(u8g_t *u8g, u8g_dev_t *dev)
+{  
+  uint8_t r;
+  u8g->state_cb(U8G_STATE_MSG_BACKUP_ENV);
+  u8g->state_cb(U8G_STATE_MSG_RESTORE_U8G);
+  r = u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_PAGE_NEXT, NULL);
+  if ( r != 0 )
+  {
+    u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_PAGE_BOX, &(u8g->current_page));
+  }
+  u8g->state_cb(U8G_STATE_MSG_RESTORE_ENV);
+  return r;
+}
+
+uint8_t u8g_SetContrastLL(u8g_t *u8g, u8g_dev_t *dev, uint8_t contrast)
+{  
+  return u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_CONTRAST, &contrast);
+}
+
+void u8g_DrawPixelLL(u8g_t *u8g, u8g_dev_t *dev, u8g_uint_t x, u8g_uint_t y)
+{
+  u8g_dev_arg_pixel_t *arg = &(u8g->arg_pixel);
+  arg->x = x;
+  arg->y = y;
+  u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_SET_PIXEL, arg);
+}
+
+void u8g_Draw8PixelLL(u8g_t *u8g, u8g_dev_t *dev, u8g_uint_t x, u8g_uint_t y, uint8_t dir, uint8_t pixel)
+{
+  u8g_dev_arg_pixel_t *arg = &(u8g->arg_pixel);
+  arg->x = x;
+  arg->y = y;
+  arg->dir = dir;
+  arg->pixel = pixel;
+  u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_SET_8PIXEL, arg);
+}
+
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+uint8_t u8g_IsBBXIntersectionLL(u8g_t *u8g, u8g_dev_t *dev, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h)
+{  
+  return u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_IS_BBX_INTERSECTION, &arg);
+}
+#endif
+
+
+
+u8g_uint_t u8g_GetWidthLL(u8g_t *u8g, u8g_dev_t *dev)
+{
+  u8g_uint_t r;
+  u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_WIDTH, &r);
+  return r;
+}
+
+u8g_uint_t u8g_GetHeightLL(u8g_t *u8g, u8g_dev_t *dev)
+{       
+  u8g_uint_t r;
+  u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_HEIGHT, &r);
+  return r;
+}
+
+u8g_uint_t u8g_GetModeLL(u8g_t *u8g, u8g_dev_t *dev)
+{       
+  return u8g_call_dev_fn(u8g, dev, U8G_DEV_MSG_GET_MODE, NULL);
+}
+
+
+
+/*====================================================================*/
+
+void u8g_UpdateDimension(u8g_t *u8g)
+{
+  u8g->width = u8g_GetWidthLL(u8g, u8g->dev);
+  u8g->height = u8g_GetHeightLL(u8g, u8g->dev);
+  u8g->mode = u8g_GetModeLL(u8g, u8g->dev);
+  /* 9 Dec 2012: u8g_scale.c requires update of current page */
+  u8g_call_dev_fn(u8g, u8g->dev, U8G_DEV_MSG_GET_PAGE_BOX, &(u8g->current_page));
+}
+
+static void u8g_init_data(u8g_t *u8g)
+{
+  uint8_t i;
+  u8g->font = NULL;
+  u8g->cursor_font = NULL;
+  u8g->cursor_bg_color = 0;
+  u8g->cursor_fg_color = 1;
+  u8g->cursor_encoding = 34;
+  u8g->cursor_fn = (u8g_draw_cursor_fn)0;
+  
+  for( i = 0; i < U8G_PIN_LIST_LEN; i++ )
+    u8g->pin_list[i] = U8G_PIN_NONE;
+
+  u8g_SetColorIndex(u8g, 1);
+
+  u8g_SetFontPosBaseline(u8g);
+  
+  u8g->font_height_mode = U8G_FONT_HEIGHT_MODE_XTEXT;
+  u8g->font_ref_ascent = 0;
+  u8g->font_ref_descent = 0;
+  u8g->font_line_spacing_factor = 64;           /* 64 = 1.0, 77 = 1.2 line spacing factor */
+  u8g->line_spacing = 0;
+  
+  u8g->state_cb = u8g_state_dummy_cb;
+
+}
+
+uint8_t u8g_Begin(u8g_t *u8g)
+{
+  /* call and init low level driver and com device */
+  if ( u8g_InitLL(u8g, u8g->dev) == 0 )
+    return 0;
+  /* fetch width and height from the low level */
+  u8g_UpdateDimension(u8g);
+  return 1;
+}
+
+uint8_t u8g_Init(u8g_t *u8g, u8g_dev_t *dev)
+{
+  u8g_init_data(u8g);
+  u8g->dev = dev;
+  
+  /* On the Arduino Environment this will lead to two calls to u8g_Begin(), the following line will be called first (by U8glib constructors) */
+  /* if - in future releases - this is removed, then still call u8g_UpdateDimension() */
+  /* if Arduino call u8g_UpdateDimension else u8g_Begin */
+  /* issue 146 */
+  return u8g_Begin(u8g);
+}
+
+uint8_t u8g_InitSPI(u8g_t *u8g, u8g_dev_t *dev, uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset)
+{
+  
+  /* fill data structure with some suitable values */
+  u8g_init_data(u8g);
+  u8g->dev = dev;
+    
+  /* assign user pins */
+  u8g->pin_list[U8G_PI_SCK] = sck;
+  u8g->pin_list[U8G_PI_MOSI] = mosi;
+  u8g->pin_list[U8G_PI_CS] = cs;
+  u8g->pin_list[U8G_PI_A0] = a0;
+  u8g->pin_list[U8G_PI_RESET] = reset;
+  
+  /* On the Arduino Environment this will lead to two calls to u8g_Begin(), the following line will be called first (by U8glib constructors) */
+  /* if - in future releases - this is removed, then still call u8g_UpdateDimension() */
+  /* if Arduino call u8g_UpdateDimension else u8g_Begin */
+  /* issue 146 */
+  return u8g_Begin(u8g);
+}
+
+uint8_t u8g_InitHWSPI(u8g_t *u8g, u8g_dev_t *dev, uint8_t cs, uint8_t a0, uint8_t reset)
+{
+  /* fill data structure with some suitable values */
+  u8g_init_data(u8g);
+  u8g->dev = dev;
+  
+  
+  /* assign user pins */
+  u8g->pin_list[U8G_PI_CS] = cs;
+  u8g->pin_list[U8G_PI_A0] = a0;
+  u8g->pin_list[U8G_PI_RESET] = reset;
+  
+  return u8g_Begin(u8g);
+}
+
+uint8_t u8g_InitI2C(u8g_t *u8g, u8g_dev_t *dev, uint8_t options)
+{
+  /* fill data structure with some suitable values */
+  u8g_init_data(u8g);
+  u8g->dev = dev;
+    
+  u8g->pin_list[U8G_PI_I2C_OPTION] = options;
+  
+  return u8g_Begin(u8g);
+}
+
+
+uint8_t u8g_Init8BitFixedPort(u8g_t *u8g, u8g_dev_t *dev, uint8_t en, uint8_t cs, uint8_t di, uint8_t rw, uint8_t reset)
+{
+  
+  /* fill data structure with some suitable values */
+  u8g_init_data(u8g);
+  u8g->dev = dev;
+    
+  /* assign user pins */
+
+  u8g->pin_list[U8G_PI_EN] = en;
+  u8g->pin_list[U8G_PI_CS] = cs;
+  u8g->pin_list[U8G_PI_DI] = di;
+  u8g->pin_list[U8G_PI_RW] = rw;
+  u8g->pin_list[U8G_PI_RESET] = reset;
+
+  return u8g_Begin(u8g);
+}
+
+uint8_t u8g_Init8Bit(u8g_t *u8g, u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, 
+  uint8_t en, uint8_t cs1, uint8_t cs2, uint8_t di, uint8_t rw, uint8_t reset)
+{
+  
+  /* fill data structure with some suitable values */
+  u8g_init_data(u8g);
+  u8g->dev = dev;
+    
+  /* assign user pins */
+
+  u8g->pin_list[U8G_PI_D0] = d0;
+  u8g->pin_list[U8G_PI_D1] = d1;
+  u8g->pin_list[U8G_PI_D2] = d2;
+  u8g->pin_list[U8G_PI_D3] = d3;
+  u8g->pin_list[U8G_PI_D4] = d4;
+  u8g->pin_list[U8G_PI_D5] = d5;
+  u8g->pin_list[U8G_PI_D6] = d6;
+  u8g->pin_list[U8G_PI_D7] = d7;
+
+  u8g->pin_list[U8G_PI_EN] = en;
+  u8g->pin_list[U8G_PI_CS1] = cs1;
+  u8g->pin_list[U8G_PI_CS2] = cs2;
+  u8g->pin_list[U8G_PI_DI] = di;
+  u8g->pin_list[U8G_PI_RW] = rw;
+  u8g->pin_list[U8G_PI_RESET] = reset;
+  
+  return u8g_Begin(u8g);
+}
+
+/*
+
+  PIN_D0 8
+  PIN_D1 9
+  PIN_D2 10
+  PIN_D3 11
+  PIN_D4 4
+  PIN_D5 5
+  PIN_D6 6
+  PIN_D7 7
+
+  PIN_CS 14
+  PIN_A0 15
+  PIN_RESET 16
+  PIN_WR 17
+  PIN_RD 18
+  
+  u8g_InitRW8Bit(u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset)
+  u8g_InitRW8Bit(u8g, dev,  8,  9, 10, 11,  4,  5,  6,  7, 14, 15, 17, 18, 16)
+
+*/
+
+uint8_t u8g_InitRW8Bit(u8g_t *u8g, u8g_dev_t *dev, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, 
+  uint8_t cs, uint8_t a0, uint8_t wr, uint8_t rd, uint8_t reset)
+{
+  
+  /* fill data structure with some suitable values */
+  u8g_init_data(u8g);
+  u8g->dev = dev;
+    
+  /* assign user pins */
+
+  u8g->pin_list[U8G_PI_D0] = d0;
+  u8g->pin_list[U8G_PI_D1] = d1;
+  u8g->pin_list[U8G_PI_D2] = d2;
+  u8g->pin_list[U8G_PI_D3] = d3;
+  u8g->pin_list[U8G_PI_D4] = d4;
+  u8g->pin_list[U8G_PI_D5] = d5;
+  u8g->pin_list[U8G_PI_D6] = d6;
+  u8g->pin_list[U8G_PI_D7] = d7;
+
+  u8g->pin_list[U8G_PI_CS] = cs;
+  u8g->pin_list[U8G_PI_A0] = a0;
+  u8g->pin_list[U8G_PI_WR] = wr;
+  u8g->pin_list[U8G_PI_RD] = rd;
+  u8g->pin_list[U8G_PI_RESET] = reset;
+  
+  return u8g_Begin(u8g);
+}
+
+void u8g_FirstPage(u8g_t *u8g)
+{
+  u8g_FirstPageLL(u8g, u8g->dev);
+}
+
+uint8_t u8g_NextPage(u8g_t *u8g)
+{
+  if  ( u8g->cursor_fn != (u8g_draw_cursor_fn)0 )
+  {
+    u8g->cursor_fn(u8g);
+  }
+  return u8g_NextPageLL(u8g, u8g->dev);
+}
+
+uint8_t u8g_SetContrast(u8g_t *u8g, uint8_t contrast)
+{
+  return u8g_SetContrastLL(u8g, u8g->dev, contrast);
+}
+
+void u8g_SleepOn(u8g_t *u8g)
+{
+  u8g_call_dev_fn(u8g, u8g->dev, U8G_DEV_MSG_SLEEP_ON, NULL);
+}
+
+void u8g_SleepOff(u8g_t *u8g)
+{
+  u8g_call_dev_fn(u8g, u8g->dev, U8G_DEV_MSG_SLEEP_OFF, NULL);
+}
+
+
+void u8g_DrawPixel(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y)
+{
+  u8g_DrawPixelLL(u8g, u8g->dev, x, y);
+}
+
+void u8g_Draw8Pixel(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, uint8_t dir, uint8_t pixel)
+{
+  u8g_Draw8PixelLL(u8g, u8g->dev, x, y, dir, pixel);
+}
+
+/* u8g_IsBBXIntersection() has been moved to u8g_clip.c */
+#ifdef OBSOLETE_CODE
+uint8_t u8g_IsBBXIntersection(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h)
+{
+  /* new code */
+  u8g_dev_arg_bbx_t arg;
+  arg.x = x;
+  arg.y = y;
+  arg.w = w;
+  arg.h = h;
+  return u8g_is_box_bbx_intersection(&(u8g->current_page), &arg);
+
+  /* old code */
+  //return u8g_IsBBXIntersectionLL(u8g, u8g->dev, x, y, w, h);
+}
+#endif
+
+void u8g_SetColorIndex(u8g_t *u8g, uint8_t idx)
+{
+  u8g->arg_pixel.color = idx;
+  /*u8g->color_index = idx; */ /* must be removed */
+}
+
+uint8_t u8g_GetColorIndex(u8g_t *u8g)
+{
+  return u8g->arg_pixel.color;
+}
+
+uint8_t u8g_GetDefaultForegroundColor(u8g_t *u8g)
+{
+  uint8_t mode;
+  mode = u8g_GetMode(u8g);
+  if ( mode == U8G_MODE_R3G3B2 ) 
+    return 255;     /* white */
+  else if ( u8g_GetMode(u8g) == U8G_MODE_GRAY2BIT )
+    return 3;         /* max intensity */
+  else /* if ( u8g.getMode() == U8G_MODE_BW ) */
+    return 1;         /* pixel on */
+  return 1;
+}
+
+void u8g_SetDefaultForegroundColor(u8g_t *u8g)
+{
+  u8g_SetColorIndex(u8g, u8g_GetDefaultForegroundColor(u8g));
+}
+
+uint8_t u8g_GetDefaultBackgroundColor(u8g_t *u8g)
+{
+  return 0;
+}
+
+void u8g_SetDefaultBackgroundColor(u8g_t *u8g)
+{
+  u8g_SetColorIndex(u8g, u8g_GetDefaultBackgroundColor(u8g));         /* pixel on / black */
+}
+
+uint8_t u8g_GetDefaultMidColor(u8g_t *u8g)
+{
+  uint8_t mode;
+  mode = u8g_GetMode(u8g);
+  if ( mode == U8G_MODE_R3G3B2 ) 
+    return 0x06d;     /* gray: 01101101 */
+  else if ( u8g_GetMode(u8g) == U8G_MODE_GRAY2BIT )
+    return 1;         /* low mid intensity */
+  else /* if ( u8g.getMode() == U8G_MODE_BW ) */
+    return 1;         /* pixel on */
+  return 1;   /* default */
+}
+
+void u8g_SetDefaultMidColor(u8g_t *u8g)
+{
+  u8g_SetColorIndex(u8g, u8g_GetDefaultMidColor(u8g));
+}
+
+
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_page.c

@@ -0,0 +1,81 @@
+/*
+
+  u8g_page.c
+  
+  page helper functions, only called by the dev handler.
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+/*
+  setup page count structure
+  conditions: page_height <= total_height
+*/
+void u8g_page_Init(u8g_page_t *p, u8g_uint_t page_height, u8g_uint_t total_height )
+{
+  p->page_height = page_height;
+  p->total_height = total_height;
+  p->page = 0;
+  u8g_page_First(p);
+}
+
+void u8g_page_First(u8g_page_t *p)
+{
+  p->page_y0 = 0;
+  p->page_y1 = p->page_height;
+  p->page_y1--;
+  p->page = 0;
+}
+
+uint8_t u8g_page_Next(u8g_page_t * p)
+{
+  register u8g_uint_t y1;
+  p->page_y0 += p->page_height;
+  if ( p->page_y0 >= p->total_height )
+    return 0;
+  p->page++;
+  y1 = p->page_y1;
+  y1 += p->page_height;
+  if ( y1 >= p->total_height )
+  {
+    y1 = p->total_height;
+    y1--;
+  }
+  p->page_y1 = y1;
+  
+  return 1;
+}
+
+
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb.c

@@ -0,0 +1,191 @@
+/*
+
+  u8g_pb.c
+  
+  common procedures for the page buffer
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+void u8g_pb_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t *end_ptr = ptr;
+  end_ptr += b->width;
+  do
+  {
+    *ptr++ = 0;
+  } while( ptr != end_ptr );
+}
+
+/* the following procedure does not work. why? Can be checked with descpic */
+/*
+void u8g_pb_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t cnt = b->width;
+  do
+  {
+    *ptr++ = 0;
+    cnt--;
+  } while( cnt != 0 );
+}
+*/
+
+/*
+  intersection assumptions:
+    a1 <= a2 is always true    
+*/
+  /*
+    minimized version
+    ---1----0 1             b1 <= a2 && b1 > b2
+    -----1--0 1             b2 >= a1 && b1 > b2
+    ---1-1--- 1             b1 <= a2 && b2 >= a1
+  */
+/*
+uint8_t u8g_pb8v1_IsYIntersection___Old(u8g_pb_t *b, u8g_uint_t v0, u8g_uint_t v1)
+{
+  uint8_t c0, c1, c;
+  c0 = v0 <= b->p.page_y1;
+  c1 = v1 >= b->p.page_y0;
+  c = v0 > v1;
+  if ( c0 && c1 ) return 1;
+  if ( c0 && c ) return 1;
+  if ( c1 && c ) return 1;
+  return 0;
+}
+*/
+
+uint8_t u8g_pb_IsYIntersection(u8g_pb_t *pb, u8g_uint_t v0, u8g_uint_t v1)
+{
+  uint8_t c1, c2, c3, tmp;
+  c1 = v0 <= pb->p.page_y1;
+  c2 = v1 >= pb->p.page_y0;
+  c3 = v0 > v1;
+  /*
+  if ( c1 && c2 )
+    return 1;
+  if ( c1 && c3 )
+    return 1;
+  if ( c2 && c3 )
+    return 1;
+  return 0;
+  */
+  
+  tmp = c1;
+  c1 &= c2;
+  c2 &= c3;
+  c3 &= tmp;
+  c1 |= c2;
+  c1 |= c3;
+  return c1 & 1;
+}
+
+
+uint8_t u8g_pb_IsXIntersection(u8g_pb_t *b, u8g_uint_t v0, u8g_uint_t v1)
+{
+  uint8_t /*c0, c1, */ c2, c3;
+  /*
+    conditions: b->p.page_y0 < b->p.page_y1
+    there are no restriction on v0 and v1. If v0 > v1, then warp around unsigned is assumed
+  */
+  /*
+  c0 = v0 < 0;
+  c1 = v1 < 0;
+  */
+  c2 = v0 > b->width;
+  c3 = v1 > b->width;
+  /*if ( c0 && c1 ) return 0;*/
+  if ( c2 && c3 ) return 0;
+  /*if ( c1 && c2 ) return 0;*/
+  return 1;
+}
+
+uint8_t u8g_pb_IsIntersection(u8g_pb_t *pb, u8g_dev_arg_bbx_t *bbx)
+{
+  u8g_uint_t tmp;
+
+  tmp = bbx->y;
+  tmp += bbx->h;
+  tmp--;
+  
+  if ( u8g_pb_IsYIntersection(pb, bbx->y, tmp) == 0 )
+    return 0;
+  
+  /* maybe this one can be skiped... probability is very high to have an intersection, so it would be ok to always return 1 */
+  tmp = bbx->x;
+  tmp += bbx->w;
+  tmp--;
+    
+  return u8g_pb_IsXIntersection(pb, bbx->x, tmp);
+}
+
+void u8g_pb_GetPageBox(u8g_pb_t *pb, u8g_box_t *box)
+{
+  box->x0 = 0;
+  box->y0 = pb->p.page_y0;
+  box->x1 = pb->width;
+  box->x1--;
+  box->y1 = pb->p.page_y1;
+}
+
+
+uint8_t u8g_pb_Is8PixelVisible(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  u8g_uint_t v0, v1;
+  v0 = arg_pixel->y;
+  v1 = v0;
+  switch( arg_pixel->dir )
+  {
+    case 0:
+      break;
+    case 1:  
+      v1 += 8;          /* this is independent from the page height */
+      break;
+    case 2:  
+      break;
+    case 3: 
+      v0 -= 8;
+      break;
+  }
+  return u8g_pb_IsYIntersection(b, v0, v1);
+}
+
+
+
+uint8_t u8g_pb_WriteBuffer(u8g_pb_t *b, u8g_t *u8g, u8g_dev_t *dev)
+{
+  return u8g_WriteSequence(u8g, dev, b->width, b->buf);  
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb14v1.c

@@ -0,0 +1,200 @@
+/*
+
+  u8g_pb14v1.c
+  
+  14bit height monochrom (1 bit) page buffer, 
+  byte has vertical orientation, 7 bits per byte
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+#include <string.h>
+
+
+void u8g_pb14v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE;
+void u8g_pb14v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+void u8g_pb14v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ;
+void u8g_pb14v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE;
+
+
+void u8g_pb14v1_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t *end_ptr = ptr;
+  end_ptr += b->width*2;
+  do
+  {
+    *ptr++ = 0;
+  } while( ptr != end_ptr );
+}
+
+/* Obsolete, usually set by the init of the structure */
+void u8g_pb14v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb14v1_Clear(b);
+}
+
+void u8g_pb14v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  if ( y >= 7 )
+  {
+    ptr += b->width;
+    y -= 7;
+  }
+  mask = 1;
+  mask <<= y;
+  ptr += x;
+  if ( color_index )
+  {
+    *ptr |= mask;
+  }
+  else
+  {
+    mask ^=0xff;
+    *ptr &= mask;
+  }
+}
+
+
+void u8g_pb14v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb14v1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+void u8g_pb14v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb14v1_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+
+void u8g_pb14v1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  u8g_uint_t dx = 0;
+  u8g_uint_t dy = 0;
+  
+  switch( arg_pixel->dir )
+  {
+    case 0: dx++; break;
+    case 1: dy++; break;
+    case 2: dx--; break;
+    case 3: dy--; break;
+  }
+  
+  do
+  {
+    if ( pixel & 128 )
+      u8g_pb14v1_SetPixel(b, arg_pixel);
+    arg_pixel->x += dx;
+    arg_pixel->y += dy;
+    pixel <<= 1;
+  } while( pixel != 0  );
+  
+}
+
+uint8_t u8g_dev_pb14v1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb14v1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+        u8g_pb14v1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb14v1_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb14v1_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_BW;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb16h1.c

@@ -0,0 +1,213 @@
+/*
+
+  u8g_pb16h1.c
+  
+  2x 8bit height monochrom (1 bit) page buffer
+  byte has horizontal orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+
+
+  total buffer size is limited to 2*256 bytes because of the calculation inside the set pixel procedure
+
+
+*/
+
+#include "u8g.h"
+#include <string.h>
+
+
+void u8g_pb16h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE;
+void u8g_pb16h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+void u8g_pb16h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ;
+void u8g_pb16h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE;
+uint8_t u8g_dev_pb8h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+
+void u8g_pb16h1_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t *end_ptr = ptr;
+  end_ptr += b->width*2;
+  do
+  {
+    *ptr++ = 0;
+  } while( ptr != end_ptr );
+}
+
+
+
+void u8g_pb16h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb16h1_Clear(b);
+}
+
+
+/* limitation: total buffer must not exceed 2*256 bytes */
+void u8g_pb16h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  u8g_uint_t tmp;
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  if ( y >= 8 )
+  {
+    ptr += b->width;
+    y &= 0x07;
+  }
+  tmp = b->width;
+  tmp >>= 3;
+  tmp *= (uint8_t)y;
+  ptr += tmp;
+  
+  mask = 0x080;
+  mask >>= x & 7;
+  x >>= 3;
+  ptr += x;
+  if ( color_index )
+  {
+    *ptr |= mask;
+  }
+  else
+  {
+    mask ^=0xff;
+    *ptr &= mask;
+  }
+  
+}
+
+
+void u8g_pb16h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb16h1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+void u8g_pb16h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb16h1_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+void u8g_pb16h1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  u8g_uint_t dx = 0;
+  u8g_uint_t dy = 0;
+  
+  switch( arg_pixel->dir )
+  {
+    case 0: dx++; break;
+    case 1: dy++; break;
+    case 2: dx--; break;
+    case 3: dy--; break;
+  }
+  
+  do
+  {
+    if ( pixel & 128 )
+      u8g_pb16h1_SetPixel(b, arg_pixel);
+    arg_pixel->x += dx;
+    arg_pixel->y += dy;
+    pixel <<= 1;
+  } while( pixel != 0  );  
+}
+
+
+uint8_t u8g_dev_pb16h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb16h1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb16h1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb16h1_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb16h1_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_BW;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb16h2.c

@@ -0,0 +1,182 @@
+/*
+
+  u8g_pb16h2.c
+  
+  2 bit per pixel page buffer
+  byte has horizontal orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+#include <string.h>
+
+void u8g_pb16h2_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t *end_ptr = ptr;
+  
+  /* two bits per pixel, 16 bits height --> 8 pixel --> 4 pixel per byte */
+  end_ptr += b->width;
+  end_ptr += b->width;
+  
+  do
+  {
+    *ptr++ = 0;
+  } while( ptr != end_ptr );
+}
+
+void u8g_pb16h2_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb16h2_Clear(b);
+}
+
+static void u8g_pb16h2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+static void u8g_pb16h2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  register uint16_t tmp;
+  
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  
+  tmp = b->width;
+  tmp >>= 2;
+  tmp *= (uint8_t)y;
+  ptr += tmp;
+  
+  tmp = x;
+  tmp >>= 2;
+  ptr += tmp;
+  
+  tmp = x;
+  tmp &= 3;
+  tmp <<= 1;
+  mask = 3;
+  mask <<= tmp;
+  mask = ~mask;
+  color_index &= 3;
+  color_index <<= tmp;
+    
+  *ptr &= mask;
+  *ptr |= color_index;
+}
+
+
+void u8g_pb16h2_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb16h2_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+
+void u8g_pb16h2_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb16h2_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+
+
+uint8_t u8g_dev_pb16h2_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+      {
+        u8g_pb16h2_Set8PixelStd(pb, (u8g_dev_arg_pixel_t *)arg);
+      }
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb16h2_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_page_First(&(pb->p));
+      u8g_pb16h2_Clear(pb);
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb16h2_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_GRAY2BIT;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb16v1.c

@@ -0,0 +1,200 @@
+/*
+
+  u8g_pb16v1.c
+  
+  16bit height monochrom (1 bit) page buffer
+  byte has vertical orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+#include <string.h>
+
+
+void u8g_pb16v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE;
+void u8g_pb16v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+void u8g_pb16v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ;
+void u8g_pb16v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE;
+
+
+void u8g_pb16v1_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t *end_ptr = ptr;
+  end_ptr += b->width*2;
+  do
+  {
+    *ptr++ = 0;
+  } while( ptr != end_ptr );
+}
+
+/* Obsolete, usually set by the init of the structure */
+void u8g_pb16v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb16v1_Clear(b);
+}
+
+void u8g_pb16v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  if ( y >= 8 )
+  {
+    ptr += b->width;
+    y &= 0x07;
+  }
+  mask = 1;
+  mask <<= y;
+  ptr += x;
+  if ( color_index )
+  {
+    *ptr |= mask;
+  }
+  else
+  {
+    mask ^=0xff;
+    *ptr &= mask;
+  }
+}
+
+
+void u8g_pb16v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb16v1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+void u8g_pb16v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb16v1_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+
+void u8g_pb16v1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  u8g_uint_t dx = 0;
+  u8g_uint_t dy = 0;
+  
+  switch( arg_pixel->dir )
+  {
+    case 0: dx++; break;
+    case 1: dy++; break;
+    case 2: dx--; break;
+    case 3: dy--; break;
+  }
+  
+  do
+  {
+    if ( pixel & 128 )
+      u8g_pb16v1_SetPixel(b, arg_pixel);
+    arg_pixel->x += dx;
+    arg_pixel->y += dy;
+    pixel <<= 1;
+  } while( pixel != 0  );
+  
+}
+
+uint8_t u8g_dev_pb16v1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb16v1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+        u8g_pb16v1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb16v1_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb16v1_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_BW;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb16v2.c

@@ -0,0 +1,172 @@
+/*
+
+  u8g_pb16v2.c
+  
+  16 bit height 2 bit per pixel page buffer
+  byte has vertical orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+#include <string.h>
+
+
+void u8g_pb16v2_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t *end_ptr = ptr;
+  
+  /* two bits per pixel, 16 bits height --> 8 pixel --> 4 pixel per byte */
+  end_ptr += b->width;
+  end_ptr += b->width;
+  
+  do
+  {
+    *ptr++ = 0;
+  } while( ptr != end_ptr );
+}
+
+void u8g_pb16v2Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb16v2_Clear(b);
+}
+
+void u8g_pb16v2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  uint8_t *ptr = b->buf;
+  y -= b->p.page_y0;
+  if ( y >= 4 )
+  {
+    ptr += b->width;
+  }
+  mask = 0x03;
+  y &= 0x03;
+  y <<= 1;
+  mask <<= y;
+  mask ^=0xff;
+  color_index &= 3;
+  color_index <<= y;
+  ptr += x;
+  *ptr &= mask;
+  *ptr |= color_index;
+}
+
+
+void u8g_pb16v2_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb16v2_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+
+void u8g_pb16v2_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb16v2_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+
+
+uint8_t u8g_dev_pb16v2_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+      {
+        u8g_pb16v2_Set8PixelStd(pb, (u8g_dev_arg_pixel_t *)arg);
+      }
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb16v2_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb16v2_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb16v2_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_GRAY2BIT;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb32h1.c

@@ -0,0 +1,208 @@
+/*
+
+  u8g_pb32h1.c
+  
+  2x 8bit height monochrom (1 bit) page buffer
+  byte has horizontal orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+
+
+  total buffer size is limited to 2*256 bytes because of the calculation inside the set pixel procedure
+
+
+*/
+
+#include "u8g.h"
+#include <string.h>
+
+
+void u8g_pb32h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE;
+void u8g_pb32h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+void u8g_pb32h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ;
+void u8g_pb32h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE;
+uint8_t u8g_dev_pb8h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+
+void u8g_pb32h1_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t *end_ptr = ptr;
+  end_ptr += b->width*4;
+  do
+  {
+    *ptr++ = 0;
+  } while( ptr != end_ptr );
+}
+
+
+
+void u8g_pb32h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb32h1_Clear(b);
+}
+
+
+/* limitation: total buffer must not exceed 2*256 bytes */
+void u8g_pb32h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  uint16_t tmp;
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  tmp = b->width;
+  tmp >>= 3;
+  tmp *= y;
+  ptr += tmp;
+  
+  mask = 0x080;
+  mask >>= x & 7;
+  x >>= 3;
+  ptr += x;
+  if ( color_index )
+  {
+    *ptr |= mask;
+  }
+  else
+  {
+    mask ^=0xff;
+    *ptr &= mask;
+  }
+  
+}
+
+
+void u8g_pb32h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb32h1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+void u8g_pb32h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb32h1_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+void u8g_pb32h1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  u8g_uint_t dx = 0;
+  u8g_uint_t dy = 0;
+  
+  switch( arg_pixel->dir )
+  {
+    case 0: dx++; break;
+    case 1: dy++; break;
+    case 2: dx--; break;
+    case 3: dy--; break;
+  }
+  
+  do
+  {
+    if ( pixel & 128 )
+      u8g_pb32h1_SetPixel(b, arg_pixel);
+    arg_pixel->x += dx;
+    arg_pixel->y += dy;
+    pixel <<= 1;
+  } while( pixel != 0  );  
+}
+
+
+uint8_t u8g_dev_pb32h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb32h1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb32h1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb32h1_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb32h1_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_BW;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb8h1.c

@@ -0,0 +1,389 @@
+/*
+
+  u8g_pb8h1.c
+  
+  8bit height monochrom (1 bit) page buffer
+  byte has horizontal orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+
+  total buffer size is limited to 256 bytes because of the calculation inside the set pixel procedure
+
+  23. Sep 2012: Bug with down procedure, see FPS 1st page --> fixed (bug located in u8g_clip.c)
+
+*/
+
+#include "u8g.h"
+#include <string.h>
+
+#ifdef __unix__
+#include <assert.h>
+#endif
+
+/* NEW_CODE disabled, because the performance increase was too slow and not worth compared */
+/* to the increase of code size */
+/* #define NEW_CODE */
+
+#ifdef __unix__
+void *u8g_buf_lower_limit;
+void *u8g_buf_upper_limit;
+#endif
+
+void u8g_pb8h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE;
+void u8g_pb8h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+void u8g_pb8h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ;
+void u8g_pb8h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE;
+uint8_t u8g_dev_pb8h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+
+
+#ifdef NEW_CODE
+struct u8g_pb_h1_struct
+{
+  u8g_uint_t x;
+  u8g_uint_t y;
+  uint8_t *ptr;
+  uint8_t mask;
+  uint8_t line_byte_len;
+  uint8_t cnt;
+};
+
+static uint8_t u8g_pb8h1_bitmask[8] = { 0x080, 0x040, 0x020, 0x010, 0x008, 0x004, 0x002, 0x001 };
+
+static void u8g_pb8h1_state_right(struct u8g_pb_h1_struct *s)  U8G_NOINLINE;
+static void u8g_pb8h1_state_right(struct u8g_pb_h1_struct *s)
+{
+  register u8g_uint_t x;
+  x = s->x;
+  x++;
+  s->x = x;
+  x &= 7;
+  s->mask = u8g_pb8h1_bitmask[x];
+  if ( x == 0 )
+    s->ptr++;
+}
+
+static void u8g_pb8h1_state_left(struct u8g_pb_h1_struct *s)
+{
+  register u8g_uint_t x;
+  x = s->x;
+  x--;
+  s->x = x;
+  x &= 7;
+  s->mask = u8g_pb8h1_bitmask[x];
+  if ( x == 7 )
+    s->ptr--;
+}
+
+static void u8g_pb8h1_state_down(struct u8g_pb_h1_struct *s)
+{
+  s->y++;
+  s->ptr += s->line_byte_len;
+}
+
+static void u8g_pb8h1_state_up(struct u8g_pb_h1_struct *s)
+{
+  s->y--;
+  s->ptr -= s->line_byte_len;
+}
+
+static void u8g_pb8h1_state_init(struct u8g_pb_h1_struct *s, u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y) U8G_NOINLINE;
+static void u8g_pb8h1_state_init(struct u8g_pb_h1_struct *s, u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y)
+{
+  u8g_uint_t tmp;
+  
+  uint8_t *ptr = b->buf;
+  
+  s->x = x;  
+  s->y = y;
+  
+  y -= b->p.page_y0;
+  
+  tmp = b->width;
+  tmp >>= 3;
+  s->line_byte_len = tmp;
+  
+  /* assume negative y values, can be down to -7, subtract this from the pointer and add correction of 8 to y */
+  ptr -= tmp*8;
+  y+=8;
+  /* it is important that the result of tmp*y can be 16 bit value also for 8 bit mode */
+  ptr += tmp*y;
+  
+  s->mask = u8g_pb8h1_bitmask[x & 7];
+  
+  /* assume negative x values (to -7), subtract 8 pixel from the pointer and add 8 to x */
+  ptr--;
+  x += 8;
+  x >>= 3;
+  ptr += x;
+  s->ptr = ptr;
+}
+
+static void u8g_pb8h1_state_set_pixel(struct u8g_pb_h1_struct *s, uint8_t color_index) U8G_NOINLINE;
+static void u8g_pb8h1_state_set_pixel(struct u8g_pb_h1_struct *s, uint8_t color_index)
+{
+  
+#ifdef __unix__
+  assert( s->ptr >= u8g_buf_lower_limit );
+  assert( s->ptr < u8g_buf_upper_limit );
+#endif
+  
+  if ( color_index )
+  {
+    *s->ptr |= s->mask;
+  }
+  else
+  {
+    uint8_t mask = s->mask;
+    mask ^=0xff;
+    *s->ptr &= mask;
+  }  
+}
+#endif
+
+
+void u8g_pb8h1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb_Clear(b);
+}
+
+/* limitation: total buffer must not exceed 256 bytes */
+void u8g_pb8h1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+#ifdef NEW_CODE
+  struct u8g_pb_h1_struct s;
+  u8g_pb8h1_state_init(&s, b, x, y);
+  u8g_pb8h1_state_set_pixel(&s, color_index);
+
+//  u8g_pb8h1_state_up(&s);
+//  if ( s.y > b->p.page_y1 )
+//    return;
+//  if ( s.x > b->width )
+//    return;
+//  u8g_pb8h1_state_set_pixel(&s, color_index);
+#else
+  register uint8_t mask;
+  u8g_uint_t tmp;
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  tmp = b->width;
+  tmp >>= 3;
+  tmp *= (uint8_t)y;
+  ptr += tmp;
+  
+  mask = 0x080;
+  mask >>= x & 7;
+  x >>= 3;
+  ptr += x;
+  if ( color_index )
+  {
+    *ptr |= mask;
+  }
+  else
+  {
+    mask ^=0xff;
+    *ptr &= mask;
+  }
+#endif
+}
+
+
+void u8g_pb8h1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb8h1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+void u8g_pb8h1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb8h1_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+void u8g_pb8h1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  u8g_uint_t dx = 0;
+  u8g_uint_t dy = 0;
+  
+  switch( arg_pixel->dir )
+  {
+    case 0: dx++; break;
+    case 1: dy++; break;
+    case 2: dx--; break;
+    case 3: dy--; break;
+  }
+  
+  do
+  {
+    if ( pixel & 128 )
+      u8g_pb8h1_SetPixel(b, arg_pixel);
+    arg_pixel->x += dx;
+    arg_pixel->y += dy;
+    pixel <<= 1;
+  } while( pixel != 0  );  
+}
+
+#ifdef NEW_CODE
+static void u8g_pb8h1_Set8PixelState(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  struct u8g_pb_h1_struct s;
+  uint8_t cnt;
+  u8g_pb8h1_state_init(&s, b, arg_pixel->x, arg_pixel->y);
+  cnt = 8;
+  switch( arg_pixel->dir )
+  {
+    case 0: 
+      do
+      {
+	if ( s.x < b->width )
+	  if ( pixel & 128 )
+	    u8g_pb8h1_state_set_pixel(&s, arg_pixel->color);
+	u8g_pb8h1_state_right(&s); 
+	pixel <<= 1;
+	cnt--;
+      } while( cnt > 0 && pixel != 0  );
+      break;
+    case 1: 
+      do
+      {
+	if ( s.y >= b->p.page_y0 )
+	  if ( s.y <= b->p.page_y1 )
+	    if ( pixel & 128 )
+	      u8g_pb8h1_state_set_pixel(&s, arg_pixel->color);
+	u8g_pb8h1_state_down(&s); 
+	pixel <<= 1;
+	cnt--;
+      } while( cnt > 0 && pixel != 0  );
+      break;
+    case 2: 
+      do
+      {
+	if ( s.x < b->width )
+	  if ( pixel & 128 )
+	    u8g_pb8h1_state_set_pixel(&s, arg_pixel->color);
+	u8g_pb8h1_state_left(&s); 
+	pixel <<= 1;
+	cnt--;
+      } while( cnt > 0 && pixel != 0 );
+      break;
+    case 3: 	
+      do
+      {
+	if ( s.y >= b->p.page_y0 )
+	  if ( s.y <= b->p.page_y1 )
+	    if ( pixel & 128 )
+	      u8g_pb8h1_state_set_pixel(&s, arg_pixel->color);
+	u8g_pb8h1_state_up(&s); 
+	pixel <<= 1;
+	cnt--;
+      } while( cnt > 0 && pixel != 0  );
+      break;
+  }
+}
+#endif
+
+uint8_t u8g_dev_pb8h1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+#ifdef NEW_CODE
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb8h1_Set8PixelState(pb, (u8g_dev_arg_pixel_t *)arg);
+#else
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb8h1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg);
+#endif
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb8h1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_BW;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb8h1f.c

@@ -0,0 +1,194 @@
+/*
+
+  u8g_pb8h1f.c
+  
+  8bit height monochrom (1 bit) page buffer
+  byte has horizontal orientation, same as u8g_pb8h1, but byte is flipped 
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+
+
+  total buffer size is limited to 256 bytes because of the calculation inside the set pixel procedure
+
+
+*/
+
+#include "u8g.h"
+#include <string.h>
+
+
+void u8g_pb8h1f_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE;
+void u8g_pb8h1f_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+void u8g_pb8h1f_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ;
+void u8g_pb8h1f_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE;
+uint8_t u8g_dev_pb8h1f_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+
+
+void u8g_pb8h1f_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb_Clear(b);
+}
+
+/* limitation: total buffer must not exceed 256 bytes, 20 nov 2012: extended to >256 bytes */
+void u8g_pb8h1f_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  /*register uint8_t mask, tmp;*/
+  register uint8_t mask; 
+  register u8g_uint_t tmp;
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  tmp = b->width >> 3;
+  tmp *= (uint8_t)y;
+  ptr += tmp;
+  
+  mask = 1;
+  mask <<= x & 7;
+  x >>= 3;
+  ptr += x;
+  if ( color_index )
+  {
+    *ptr |= mask;
+  }
+  else
+  {
+    mask ^=0xff;
+    *ptr &= mask;
+  }
+}
+
+
+void u8g_pb8h1f_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb8h1f_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+void u8g_pb8h1f_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb8h1f_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+void u8g_pb8h1f_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  u8g_uint_t dx = 0;
+  u8g_uint_t dy = 0;
+  
+  switch( arg_pixel->dir )
+  {
+    case 0: dx++; break;
+    case 1: dy++; break;
+    case 2: dx--; break;
+    case 3: dy--; break;
+  }
+  
+  do
+  {
+    if ( pixel & 128 )
+      u8g_pb8h1f_SetPixel(b, arg_pixel);
+    arg_pixel->x += dx;
+    arg_pixel->y += dy;
+    pixel <<= 1;
+  } while( pixel != 0  );  
+}
+
+
+uint8_t u8g_dev_pb8h1f_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb8h1f_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb8h1f_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_BW;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb8h2.c

@@ -0,0 +1,167 @@
+/*
+
+  u8g_pb8h2.c
+  
+  8bit height 2 bit per pixel page buffer
+  byte has horizontal orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+#include <string.h>
+
+void u8g_pb8h2_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb_Clear(b);
+}
+
+static void u8g_pb8h2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+static void u8g_pb8h2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  register uint16_t tmp;
+  
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  
+  tmp = b->width;
+  tmp >>= 2;
+  tmp *= (uint8_t)y;
+  ptr += tmp;
+  
+  tmp = x;
+  tmp >>= 2;
+  ptr += tmp;
+  
+  tmp = x;
+  tmp &= 3;
+  tmp <<= 1;
+  mask = 3;
+  mask <<= tmp;
+  mask = ~mask;
+  color_index &= 3;
+  color_index <<= tmp;
+    
+  *ptr &= mask;
+  *ptr |= color_index;
+}
+
+
+void u8g_pb8h2_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb8h2_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+
+void u8g_pb8h2_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb8h2_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+
+
+uint8_t u8g_dev_pb8h2_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+      {
+        u8g_pb8h2_Set8PixelStd(pb, (u8g_dev_arg_pixel_t *)arg);
+      }
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb8h2_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_GRAY2BIT;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb8h8.c

@@ -0,0 +1,179 @@
+/*
+
+  u8g_pb8h8.c
+  
+  8 bits per pixel, horizontal
+  
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+
+
+struct _u8g_pb_t
+{
+  u8g_page_t p;
+  u8g_uint_t width;
+  void *buf;
+};
+typedef struct _u8g_pb_t u8g_pb_t;
+
+
+uint8_t u8g_index_color_8h8_buf[WIDTH*PAGE_HEIGHT] U8G_NOCOMMON ; 
+u8g_pb_t u8g_index_color_8h8_pb = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0},  WIDTH, u8g_index_color_8h8_buff}; 
+u8g_dev_t name = { dev_fn, &u8g_index_color_8h8_pb, com_fn }
+
+*/
+
+#include "u8g.h"
+
+#define WIDTH_BITS 7
+#define WIDTH (1<<WIDTH_BITS)
+#define PAGE_HEIGHT_BITS 3
+#define PAGE_HEIGHT (1<<PAGE_HEIGHT_BITS)
+
+void u8g_pb8h8_Clear(u8g_pb_t *b)
+{
+  uint8_t *ptr = (uint8_t *)b->buf;
+  uint8_t *end_ptr = ptr;
+  uint8_t cnt = b->p.page_height;
+  do
+  {
+    end_ptr += b->width;
+    cnt--;
+  } while( cnt > 0 );
+  do
+  {
+    *ptr++ = 0;
+  } while( ptr != end_ptr );
+}
+
+
+void u8g_pb8h8_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb8h8_Clear(b);
+}
+
+static void u8g_pb8h8_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  uint16_t tmp;
+  uint8_t *ptr = b->buf;
+  y -= b->p.page_y0;
+  tmp = y;
+  tmp *= b->width;
+  tmp += x;
+  ptr += tmp;
+  *ptr = color_index;
+}
+
+void u8g_pb8h8_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb8h8_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+
+void u8g_pb8h8_Set8Pixel(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  u8g_uint_t dx = 0;
+  u8g_uint_t dy = 0;
+  
+  switch( arg_pixel->dir )
+  {
+    case 0: dx++; break;
+    case 1: dy++; break;
+    case 2: dx--; break;
+    case 3: dy--; break;
+  }
+  
+  do
+  {
+    if ( pixel & 128 )
+      u8g_pb8h8_SetPixel(b, arg_pixel);
+    arg_pixel->x += dx;
+    arg_pixel->y += dy;
+    pixel <<= 1;
+  } while( pixel != 0  );  
+}
+
+
+uint8_t u8g_dev_pb8h8_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb8h8_Set8Pixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb8h8_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb8h8_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb8h8_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_R3G3B2;
+  }
+  return 1;
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb8v1.c

@@ -0,0 +1,184 @@
+/*
+
+  u8g_pb8v1.c
+  
+  8bit height monochrom (1 bit) page buffer
+  byte has vertical orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+#include <string.h>
+
+
+void u8g_pb8v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width) U8G_NOINLINE;
+void u8g_pb8v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index) U8G_NOINLINE;
+void u8g_pb8v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel) U8G_NOINLINE ;
+void u8g_pb8v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel) U8G_NOINLINE;
+
+/* Obsolete, usually set by the init of the structure */
+void u8g_pb8v1_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb_Clear(b);
+}
+
+void u8g_pb8v1_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  uint8_t *ptr = b->buf;
+  
+  y -= b->p.page_y0;
+  mask = 1;
+  y &= 0x07;
+  mask <<= y;
+  ptr += x;
+  if ( color_index )
+  {
+    *ptr |= mask;
+  }
+  else
+  {
+    mask ^=0xff;
+    *ptr &= mask;
+  }
+}
+
+
+void u8g_pb8v1_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb8v1_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+void u8g_pb8v1_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb8v1_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+}
+
+
+void u8g_pb8v1_Set8PixelOpt2(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  u8g_uint_t dx = 0;
+  u8g_uint_t dy = 0;
+  
+  switch( arg_pixel->dir )
+  {
+    case 0: dx++; break;
+    case 1: dy++; break;
+    case 2: dx--; break;
+    case 3: dy--; break;
+  }
+  
+  do
+  {
+    if ( pixel & 128 )
+      u8g_pb8v1_SetPixel(b, arg_pixel);
+    arg_pixel->x += dx;
+    arg_pixel->y += dy;
+    pixel <<= 1;
+  } while( pixel != 0  );
+  
+}
+
+uint8_t u8g_dev_pb8v1_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+        u8g_pb8v1_Set8PixelOpt2(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+        u8g_pb8v1_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_BW;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_pb8v2.c

@@ -0,0 +1,153 @@
+/*
+
+  u8g_pb8v2.c
+  
+  8bit height 2 bit per pixel page buffer
+  byte has vertical orientation
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+#include <string.h>
+
+void u8g_pb8v2_Init(u8g_pb_t *b, void *buf, u8g_uint_t width)
+{
+  b->buf = buf;
+  b->width = width;
+  u8g_pb_Clear(b);
+}
+
+void u8g_pb8v2_set_pixel(u8g_pb_t *b, u8g_uint_t x, u8g_uint_t y, uint8_t color_index)
+{
+  register uint8_t mask;
+  uint8_t *ptr = b->buf;
+  y -= b->p.page_y0;
+  mask = 0x03;
+  y &= 0x03;
+  y <<= 1;
+  mask <<= y;
+  mask ^=0xff;
+  color_index &= 3;
+  color_index <<= y;
+  ptr += x;
+  *ptr &= mask;
+  *ptr |= color_index;
+}
+
+
+void u8g_pb8v2_SetPixel(u8g_pb_t *b, const u8g_dev_arg_pixel_t * const arg_pixel)
+{
+  if ( arg_pixel->y < b->p.page_y0 )
+    return;
+  if ( arg_pixel->y > b->p.page_y1 )
+    return;
+  if ( arg_pixel->x >= b->width )
+    return;
+  u8g_pb8v2_set_pixel(b, arg_pixel->x, arg_pixel->y, arg_pixel->color);
+}
+
+
+void u8g_pb8v2_Set8PixelStd(u8g_pb_t *b, u8g_dev_arg_pixel_t *arg_pixel)
+{
+  register uint8_t pixel = arg_pixel->pixel;
+  do
+  {
+    if ( pixel & 128 )
+    {
+      u8g_pb8v2_SetPixel(b, arg_pixel);
+    }
+    switch( arg_pixel->dir )
+    {
+      case 0: arg_pixel->x++; break;
+      case 1: arg_pixel->y++; break;
+      case 2: arg_pixel->x--; break;
+      case 3: arg_pixel->y--; break;
+    }
+    pixel <<= 1;
+  } while( pixel != 0  );
+
+}
+
+
+
+uint8_t u8g_dev_pb8v2_base_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_pb_Is8PixelVisible(pb, (u8g_dev_arg_pixel_t *)arg) )
+      {
+        u8g_pb8v2_Set8PixelStd(pb, (u8g_dev_arg_pixel_t *)arg);
+      }
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      u8g_pb8v2_SetPixel(pb, (u8g_dev_arg_pixel_t *)arg);
+      break;
+    case U8G_DEV_MSG_INIT:
+      break;
+    case U8G_DEV_MSG_STOP:
+      break;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_pb_Clear(pb);
+      u8g_page_First(&(pb->p));
+      break;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      if ( u8g_page_Next(&(pb->p)) == 0 )
+        return 0;
+      u8g_pb_Clear(pb);
+      break;
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      return u8g_pb_IsIntersection(pb, (u8g_dev_arg_bbx_t *)arg);
+#endif
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      u8g_pb_GetPageBox(pb, (u8g_box_t *)arg);
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = pb->width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = pb->p.total_height;
+      break;
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+      break;
+    case U8G_DEV_MSG_SET_XY_CB:
+      break;
+    case U8G_DEV_MSG_GET_MODE:
+      return U8G_MODE_GRAY2BIT;
+  }
+  return 1;
+}
+ 
+  

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_rect.c

@@ -0,0 +1,232 @@
+/*
+
+  u8g_rect.c
+  
+  U8G high level interface for horizontal and vertical things
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+void u8g_draw_hline(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w)
+{
+  uint8_t pixel = 0x0ff;
+  while( w >= 8 )
+  {
+    u8g_Draw8Pixel(u8g, x, y, 0, pixel);
+    w-=8;
+    x+=8;
+  }
+  if ( w != 0 )
+  {
+    w ^=7;
+    w++;
+    pixel <<= w&7;
+    u8g_Draw8Pixel(u8g, x, y, 0, pixel);
+  }
+}
+
+void u8g_draw_vline(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t h)
+{
+  uint8_t pixel = 0x0ff;
+  while( h >= 8 )
+  {
+    u8g_Draw8Pixel(u8g, x, y, 1, pixel);
+    h-=8;
+    y+=8;
+  }
+  if ( h != 0 )
+  {
+    h ^=7;
+    h++;
+    pixel <<= h&7;
+    u8g_Draw8Pixel(u8g, x, y, 1, pixel);
+  }
+}
+
+void u8g_DrawHLine(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w)
+{
+  if ( u8g_IsBBXIntersection(u8g, x, y, w, 1) == 0 )
+    return;
+  u8g_draw_hline(u8g, x, y, w);
+}
+
+void u8g_DrawVLine(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w)
+{
+  if ( u8g_IsBBXIntersection(u8g, x, y, 1, w) == 0 )
+    return;
+  u8g_draw_vline(u8g, x, y, w);
+}
+
+/* restrictions: w > 0 && h > 0 */
+void u8g_DrawFrame(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h)
+{
+  u8g_uint_t xtmp = x;
+  
+  if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 )
+    return;
+
+  
+  u8g_draw_hline(u8g, x, y, w);
+  u8g_draw_vline(u8g, x, y, h);
+  x+=w;
+  x--;
+  u8g_draw_vline(u8g, x, y, h);
+  y+=h;
+  y--;
+  u8g_draw_hline(u8g, xtmp, y, w);
+}
+
+void u8g_draw_box(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h)
+{
+  do
+  { 
+    u8g_draw_hline(u8g, x, y, w);
+    y++;    
+    h--;
+  } while( h != 0 );
+}
+
+/* restrictions: h > 0 */
+void u8g_DrawBox(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h)
+{
+  if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 )
+    return;
+  u8g_draw_box(u8g, x, y, w, h);
+}
+
+
+void u8g_DrawRFrame(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r)
+{
+  u8g_uint_t xl, yu;
+
+  if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 )
+    return;
+
+  xl = x;
+  xl += r;
+  yu = y;
+  yu += r;
+ 
+  {
+    u8g_uint_t yl, xr;
+      
+    xr = x;
+    xr += w;
+    xr -= r;
+    xr -= 1;
+    
+    yl = y;
+    yl += h;
+    yl -= r; 
+    yl -= 1;
+
+    u8g_draw_circle(u8g, xl, yu, r, U8G_DRAW_UPPER_LEFT);
+    u8g_draw_circle(u8g, xr, yu, r, U8G_DRAW_UPPER_RIGHT);
+    u8g_draw_circle(u8g, xl, yl, r, U8G_DRAW_LOWER_LEFT);
+    u8g_draw_circle(u8g, xr, yl, r, U8G_DRAW_LOWER_RIGHT);
+  }
+
+  {
+    u8g_uint_t ww, hh;
+
+    ww = w;
+    ww -= r;
+    ww -= r;
+    ww -= 2;
+    hh = h;
+    hh -= r;
+    hh -= r;
+    hh -= 2;
+    
+    xl++;
+    yu++;
+    h--;
+    w--;
+    u8g_draw_hline(u8g, xl, y, ww);
+    u8g_draw_hline(u8g, xl, y+h, ww);
+    u8g_draw_vline(u8g, x,         yu, hh);
+    u8g_draw_vline(u8g, x+w, yu, hh);
+  }
+}
+
+void u8g_DrawRBox(u8g_t *u8g, u8g_uint_t x, u8g_uint_t y, u8g_uint_t w, u8g_uint_t h, u8g_uint_t r)
+{
+  u8g_uint_t xl, yu;
+    u8g_uint_t yl, xr;
+
+  if ( u8g_IsBBXIntersection(u8g, x, y, w, h) == 0 )
+    return;
+
+  xl = x;
+  xl += r;
+  yu = y;
+  yu += r;
+ 
+  xr = x;
+  xr += w;
+  xr -= r;
+  xr -= 1;
+  
+  yl = y;
+  yl += h;
+  yl -= r; 
+  yl -= 1;
+
+  u8g_draw_disc(u8g, xl, yu, r, U8G_DRAW_UPPER_LEFT);
+  u8g_draw_disc(u8g, xr, yu, r, U8G_DRAW_UPPER_RIGHT);
+  u8g_draw_disc(u8g, xl, yl, r, U8G_DRAW_LOWER_LEFT);
+  u8g_draw_disc(u8g, xr, yl, r, U8G_DRAW_LOWER_RIGHT);
+
+  {
+    u8g_uint_t ww, hh;
+
+    ww = w;
+    ww -= r;
+    ww -= r;
+    ww -= 2;
+    hh = h;
+    hh -= r;
+    hh -= r;
+    hh -= 2;
+    
+    xl++;
+    yu++;
+    h--;
+    u8g_draw_box(u8g, xl, y, ww, r+1);
+    u8g_draw_box(u8g, xl, yl, ww, r+1);
+    //u8g_draw_hline(u8g, xl, y+h, ww);
+    u8g_draw_box(u8g, x, yu, w, hh);
+    //u8g_draw_vline(u8g, x+w, yu, hh);
+  }
+}

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_rot.c

@@ -0,0 +1,398 @@
+/*
+
+  u8g_rot.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+uint8_t u8g_dev_rot90_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+uint8_t u8g_dev_rot180_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+uint8_t u8g_dev_rot270_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+
+u8g_dev_t u8g_dev_rot = { u8g_dev_rot90_fn, NULL, NULL };
+
+
+void u8g_UndoRotation(u8g_t *u8g)
+{
+  if ( u8g->dev != &u8g_dev_rot )
+    return;
+  u8g->dev = u8g_dev_rot.dev_mem;
+  u8g_UpdateDimension(u8g);
+}
+
+void u8g_SetRot90(u8g_t *u8g)
+{
+  if ( u8g->dev != &u8g_dev_rot )
+  {
+    u8g_dev_rot.dev_mem = u8g->dev;
+    u8g->dev = &u8g_dev_rot;
+  }
+  u8g_dev_rot.dev_fn = u8g_dev_rot90_fn;
+  u8g_UpdateDimension(u8g);
+}
+
+void u8g_SetRot180(u8g_t *u8g)
+{
+  if ( u8g->dev != &u8g_dev_rot )
+  {
+    u8g_dev_rot.dev_mem = u8g->dev;
+    u8g->dev = &u8g_dev_rot;
+  }
+  u8g_dev_rot.dev_fn = u8g_dev_rot180_fn;
+  u8g_UpdateDimension(u8g);
+}
+
+void u8g_SetRot270(u8g_t *u8g)
+{
+  if ( u8g->dev != &u8g_dev_rot )
+  {
+    u8g_dev_rot.dev_mem = u8g->dev;
+    u8g->dev = &u8g_dev_rot;
+  }
+  u8g_dev_rot.dev_fn = u8g_dev_rot270_fn;
+  u8g_UpdateDimension(u8g);
+}
+
+uint8_t u8g_dev_rot90_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_dev_t *rotation_chain = (u8g_dev_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    default:
+    /*
+    case U8G_DEV_MSG_INIT:
+    case U8G_DEV_MSG_STOP:
+    case U8G_DEV_MSG_PAGE_FIRST:
+    case U8G_DEV_MSG_PAGE_NEXT:
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+    case U8G_DEV_MSG_SET_XY_CB:
+    */
+      return u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      {
+        u8g_dev_arg_bbx_t *bbx = (u8g_dev_arg_bbx_t *)arg;
+        u8g_uint_t x, y, tmp;
+        
+        /* transform the reference point */
+        y = bbx->x;
+        x = u8g->height;
+        /* x = u8g_GetWidthLL(u8g, rotation_chain); */
+        x -= bbx->y; 
+        x--;
+        
+        /* adjust point to be the uppler left corner again */
+        x -= bbx->h;
+        x++;
+        
+        /* swap box dimensions */        
+        tmp = bbx->w;
+        bbx->w = bbx->h;
+        bbx->h = tmp;
+        
+        /* store x,y */
+        bbx->x = x;
+        bbx->y = y;
+      }
+      return u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+#endif /* U8G_DEV_MSG_IS_BBX_INTERSECTION */
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      /* get page size from next device in the chain */
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      //printf("pre x: %3d..%3d y: %3d..%3d   ", ((u8g_box_t *)arg)->x0, ((u8g_box_t *)arg)->x1, ((u8g_box_t *)arg)->y0, ((u8g_box_t *)arg)->y1);
+      {
+	u8g_box_t new_box;
+	//new_box.x0 = u8g_GetHeightLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->y1 - 1;
+	//new_box.x1 = u8g_GetHeightLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->y0 - 1;
+	
+	new_box.x0 = ((u8g_box_t *)arg)->y0;
+	new_box.x1 = ((u8g_box_t *)arg)->y1;
+	new_box.y0 = ((u8g_box_t *)arg)->x0;
+	new_box.y1 = ((u8g_box_t *)arg)->x1;
+	*((u8g_box_t *)arg) = new_box;
+	//printf("post x: %3d..%3d y: %3d..%3d\n", ((u8g_box_t *)arg)->x0, ((u8g_box_t *)arg)->x1, ((u8g_box_t *)arg)->y0, ((u8g_box_t *)arg)->y1);
+      }
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = u8g_GetHeightLL(u8g,rotation_chain);
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = u8g_GetWidthLL(u8g, rotation_chain);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      {
+        u8g_uint_t x, y;
+        y = ((u8g_dev_arg_pixel_t *)arg)->x;
+        x = u8g_GetWidthLL(u8g, rotation_chain);
+        x -= ((u8g_dev_arg_pixel_t *)arg)->y; 
+        x--;
+        ((u8g_dev_arg_pixel_t *)arg)->x = x;
+        ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      }
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      break;
+    case U8G_DEV_MSG_SET_8PIXEL:
+      {
+        u8g_uint_t x, y;
+	//uint16_t x,y;
+        y = ((u8g_dev_arg_pixel_t *)arg)->x;
+        x = u8g_GetWidthLL(u8g, rotation_chain);
+        x -= ((u8g_dev_arg_pixel_t *)arg)->y; 
+        x--;
+        ((u8g_dev_arg_pixel_t *)arg)->x = x;
+        ((u8g_dev_arg_pixel_t *)arg)->y = y;
+        ((u8g_dev_arg_pixel_t *)arg)->dir+=1;
+        ((u8g_dev_arg_pixel_t *)arg)->dir &= 3;
+      }
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      break;
+  }
+  return 1;
+}
+
+uint8_t u8g_dev_rot180_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_dev_t *rotation_chain = (u8g_dev_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    default:
+    /*
+    case U8G_DEV_MSG_INIT:
+    case U8G_DEV_MSG_STOP:
+    case U8G_DEV_MSG_PAGE_FIRST:
+    case U8G_DEV_MSG_PAGE_NEXT:
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+    case U8G_DEV_MSG_SET_XY_CB:
+    */
+      return u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      {
+        u8g_dev_arg_bbx_t *bbx = (u8g_dev_arg_bbx_t *)arg;
+        u8g_uint_t x, y;
+        
+        /* transform the reference point */
+        //y = u8g_GetHeightLL(u8g, rotation_chain);
+        y = u8g->height;
+        y -= bbx->y; 
+        y--;
+        
+        //x = u8g_GetWidthLL(u8g, rotation_chain);
+        x = u8g->width;
+        x -= bbx->x; 
+        x--;
+        
+        /* adjust point to be the uppler left corner again */
+        y -= bbx->h;
+        y++;
+        
+        x -= bbx->w;
+        x++;
+                
+        /* store x,y */
+        bbx->x = x;
+        bbx->y = y;
+      }
+      return u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+#endif /* U8G_DEV_MSG_IS_BBX_INTERSECTION */
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      /* get page size from next device in the chain */
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      //printf("pre x: %3d..%3d y: %3d..%3d   ", ((u8g_box_t *)arg)->x0, ((u8g_box_t *)arg)->x1, ((u8g_box_t *)arg)->y0, ((u8g_box_t *)arg)->y1);
+      {
+	u8g_box_t new_box;
+	
+	new_box.x0 = u8g_GetWidthLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->x1 - 1;
+	new_box.x1 = u8g_GetWidthLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->x0 - 1;
+	new_box.y0 = u8g_GetHeightLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->y1 - 1;
+	new_box.y1 = u8g_GetHeightLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->y0 - 1;
+	*((u8g_box_t *)arg) = new_box;
+	//printf("post x: %3d..%3d y: %3d..%3d\n", ((u8g_box_t *)arg)->x0, ((u8g_box_t *)arg)->x1, ((u8g_box_t *)arg)->y0, ((u8g_box_t *)arg)->y1);
+      }
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = u8g_GetWidthLL(u8g,rotation_chain);
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = u8g_GetHeightLL(u8g, rotation_chain);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      {
+        u8g_uint_t x, y;
+
+        y = u8g_GetHeightLL(u8g, rotation_chain);
+        y -= ((u8g_dev_arg_pixel_t *)arg)->y; 
+        y--;
+        
+        x = u8g_GetWidthLL(u8g, rotation_chain);
+        x -= ((u8g_dev_arg_pixel_t *)arg)->x; 
+        x--;
+        
+        ((u8g_dev_arg_pixel_t *)arg)->x = x;
+        ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      }
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      break;
+    case U8G_DEV_MSG_SET_8PIXEL:
+      {
+        u8g_uint_t x, y;
+        
+        y = u8g_GetHeightLL(u8g, rotation_chain);
+        y -= ((u8g_dev_arg_pixel_t *)arg)->y; 
+        y--;
+        
+        x = u8g_GetWidthLL(u8g, rotation_chain);
+        x -= ((u8g_dev_arg_pixel_t *)arg)->x; 
+        x--;
+        
+        ((u8g_dev_arg_pixel_t *)arg)->x = x;
+        ((u8g_dev_arg_pixel_t *)arg)->y = y;
+        ((u8g_dev_arg_pixel_t *)arg)->dir+=2;
+        ((u8g_dev_arg_pixel_t *)arg)->dir &= 3;
+      }
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      break;
+  }
+  return 1;
+}
+
+uint8_t u8g_dev_rot270_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_dev_t *rotation_chain = (u8g_dev_t *)(dev->dev_mem);
+  switch(msg)
+  {
+    default:
+    /*
+    case U8G_DEV_MSG_INIT:
+    case U8G_DEV_MSG_STOP:
+    case U8G_DEV_MSG_PAGE_FIRST:
+    case U8G_DEV_MSG_PAGE_NEXT:
+    case U8G_DEV_MSG_SET_COLOR_INDEX:
+    case U8G_DEV_MSG_SET_XY_CB:
+    */
+      return u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+#ifdef U8G_DEV_MSG_IS_BBX_INTERSECTION
+    case U8G_DEV_MSG_IS_BBX_INTERSECTION:
+      {
+        u8g_dev_arg_bbx_t *bbx = (u8g_dev_arg_bbx_t *)arg;
+        u8g_uint_t x, y, tmp;
+        
+        /* transform the reference point */
+        x = bbx->y;
+        
+        y = u8g->width;
+        /* y = u8g_GetHeightLL(u8g, rotation_chain); */
+        y -= bbx->x; 
+        y--;
+                
+        /* adjust point to be the uppler left corner again */
+        y -= bbx->w;
+        y++;
+        
+        /* swap box dimensions */        
+        tmp = bbx->w;
+        bbx->w = bbx->h;
+        bbx->h = tmp;
+        
+        /* store x,y */
+        bbx->x = x;
+        bbx->y = y;
+      }
+      return u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+#endif /* U8G_DEV_MSG_IS_BBX_INTERSECTION */
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      /* get page size from next device in the chain */
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      //printf("pre x: %3d..%3d y: %3d..%3d   ", ((u8g_box_t *)arg)->x0, ((u8g_box_t *)arg)->x1, ((u8g_box_t *)arg)->y0, ((u8g_box_t *)arg)->y1);
+      {
+	u8g_box_t new_box;
+	
+	new_box.x0 = u8g_GetHeightLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->y1 - 1;
+	new_box.x1 = u8g_GetHeightLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->y0 - 1;
+	new_box.y0 = u8g_GetWidthLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->x1 - 1;
+	new_box.y1 = u8g_GetWidthLL(u8g,rotation_chain) - ((u8g_box_t *)arg)->x0 - 1;
+	*((u8g_box_t *)arg) = new_box;
+	//printf("post x: %3d..%3d y: %3d..%3d\n", ((u8g_box_t *)arg)->x0, ((u8g_box_t *)arg)->x1, ((u8g_box_t *)arg)->y0, ((u8g_box_t *)arg)->y1);
+      }
+      break;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = u8g_GetHeightLL(u8g,rotation_chain);
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = u8g_GetWidthLL(u8g, rotation_chain);
+      break;
+    case U8G_DEV_MSG_SET_PIXEL:
+      {
+        u8g_uint_t x, y;
+        x = ((u8g_dev_arg_pixel_t *)arg)->y;
+        
+        y = u8g_GetHeightLL(u8g, rotation_chain);
+        y -= ((u8g_dev_arg_pixel_t *)arg)->x; 
+        y--;
+          
+        /*
+        x = u8g_GetWidthLL(u8g, rotation_chain);
+        x -= ((u8g_dev_arg_pixel_t *)arg)->y; 
+        x--;
+        */
+        ((u8g_dev_arg_pixel_t *)arg)->x = x;
+        ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      }
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      break;
+    case U8G_DEV_MSG_SET_8PIXEL:
+      {
+        u8g_uint_t x, y;
+        x = ((u8g_dev_arg_pixel_t *)arg)->y;
+        
+        y = u8g_GetHeightLL(u8g, rotation_chain);
+        y -= ((u8g_dev_arg_pixel_t *)arg)->x; 
+        y--;
+          
+        /*
+        x = u8g_GetWidthLL(u8g, rotation_chain);
+        x -= ((u8g_dev_arg_pixel_t *)arg)->y; 
+        x--;
+        */
+        ((u8g_dev_arg_pixel_t *)arg)->x = x;
+        ((u8g_dev_arg_pixel_t *)arg)->y = y;
+        ((u8g_dev_arg_pixel_t *)arg)->dir+=3;
+        ((u8g_dev_arg_pixel_t *)arg)->dir &= 3;
+      }
+      u8g_call_dev_fn(u8g, rotation_chain, msg, arg);
+      break;
+  }
+  return 1;
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_scale.c

@@ -0,0 +1,188 @@
+/*
+
+  u8g_scale.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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.  
+
+  Scale screen by some constant factors. Usefull for making bigger fonts wiht less
+  memory consumption
+    
+*/
+
+#include "u8g.h"
+
+uint8_t u8g_dev_scale_2x2_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg);
+
+
+u8g_dev_t u8g_dev_scale = { u8g_dev_scale_2x2_fn, NULL, NULL };
+
+void u8g_UndoScale(u8g_t *u8g)
+{
+  if ( u8g->dev != &u8g_dev_scale )
+    return;
+  u8g->dev = u8g_dev_scale.dev_mem;
+  u8g_UpdateDimension(u8g);
+}
+
+void u8g_SetScale2x2(u8g_t *u8g)
+{
+  if ( u8g->dev != &u8g_dev_scale )
+  {
+    u8g_dev_scale.dev_mem = u8g->dev;
+    u8g->dev = &u8g_dev_scale;
+  }
+  u8g_dev_scale.dev_fn = u8g_dev_scale_2x2_fn;
+  u8g_UpdateDimension(u8g);
+}
+
+
+uint8_t u8g_dev_scale_2x2_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  u8g_dev_t *chain = (u8g_dev_t *)(dev->dev_mem);
+  uint8_t pixel;
+  uint16_t scaled_pixel;
+  uint8_t i;
+  uint8_t dir;
+  u8g_uint_t x, y, xx,yy;
+  
+  switch(msg)
+  {
+    default:
+      return u8g_call_dev_fn(u8g, chain, msg, arg);
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = u8g_GetWidthLL(u8g, chain) / 2;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = u8g_GetHeightLL(u8g, chain) / 2;
+      break;
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      /* get page size from next device in the chain */
+      u8g_call_dev_fn(u8g, chain, msg, arg);
+      ((u8g_box_t *)arg)->x0 /= 2;
+      ((u8g_box_t *)arg)->x1 /= 2;
+      ((u8g_box_t *)arg)->y0 /= 2;
+      ((u8g_box_t *)arg)->y1 /= 2;
+      return 1;
+    case U8G_DEV_MSG_SET_PIXEL:
+      x = ((u8g_dev_arg_pixel_t *)arg)->x;
+      x *= 2;
+      y = ((u8g_dev_arg_pixel_t *)arg)->y;
+      y *= 2;
+      ((u8g_dev_arg_pixel_t *)arg)->x = x;
+      ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      u8g_call_dev_fn(u8g, chain, msg, arg);
+      x++;
+      ((u8g_dev_arg_pixel_t *)arg)->x = x;
+      ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      u8g_call_dev_fn(u8g, chain, msg, arg);
+      y++;
+      ((u8g_dev_arg_pixel_t *)arg)->x = x;
+      ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      u8g_call_dev_fn(u8g, chain, msg, arg);
+      x--;
+      ((u8g_dev_arg_pixel_t *)arg)->x = x;
+      ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      u8g_call_dev_fn(u8g, chain, msg, arg);    
+      break;
+    case U8G_DEV_MSG_SET_8PIXEL:
+      pixel = ((u8g_dev_arg_pixel_t *)arg)->pixel;
+      dir = ((u8g_dev_arg_pixel_t *)arg)->dir;
+      scaled_pixel = 0;
+      for( i = 0; i < 8; i++ )
+      {
+	scaled_pixel<<=2;
+	if ( pixel & 128 )
+	{
+	  scaled_pixel |= 3;
+	}
+	pixel<<=1;
+      }
+      x = ((u8g_dev_arg_pixel_t *)arg)->x;
+      x *= 2;
+      xx = x;
+      y = ((u8g_dev_arg_pixel_t *)arg)->y;
+      y *= 2;
+      yy = y;
+      if ( ((u8g_dev_arg_pixel_t *)arg)->dir & 1 )
+      {
+	xx++;
+      }
+      else
+      {
+	yy++;
+      }
+      
+      ((u8g_dev_arg_pixel_t *)arg)->pixel = scaled_pixel>>8;      
+      ((u8g_dev_arg_pixel_t *)arg)->x = x;
+      ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      ((u8g_dev_arg_pixel_t *)arg)->dir = dir;
+      u8g_call_dev_fn(u8g, chain, msg, arg);    
+
+      
+      ((u8g_dev_arg_pixel_t *)arg)->x = xx;
+      ((u8g_dev_arg_pixel_t *)arg)->y = yy;
+      ((u8g_dev_arg_pixel_t *)arg)->dir = dir;
+      u8g_call_dev_fn(u8g, chain, msg, arg);    
+      
+      ((u8g_dev_arg_pixel_t *)arg)->pixel = scaled_pixel&255;
+      //((u8g_dev_arg_pixel_t *)arg)->pixel = 0x00;
+      switch(dir)
+      {
+	case 0:
+ 	  x+=8;
+	  xx+=8;
+	  break;
+	case 1:
+	  y+=8;
+	  yy+=8;
+	  break;
+	case 2:
+	  x-=8;
+	  xx-=8;
+	  break;
+	case 3:
+	  y-=8;
+	  yy-=8;
+	  break;
+      }
+      ((u8g_dev_arg_pixel_t *)arg)->x = x;
+      ((u8g_dev_arg_pixel_t *)arg)->y = y;
+      ((u8g_dev_arg_pixel_t *)arg)->dir = dir;
+      u8g_call_dev_fn(u8g, chain, msg, arg);    
+      
+      ((u8g_dev_arg_pixel_t *)arg)->x = xx;
+      ((u8g_dev_arg_pixel_t *)arg)->y = yy;
+      ((u8g_dev_arg_pixel_t *)arg)->dir = dir;
+      u8g_call_dev_fn(u8g, chain, msg, arg);    
+      break;
+  }
+  return 1;
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_state.c

@@ -0,0 +1,102 @@
+/*
+
+  u8g_state.c
+  
+  backup and restore hardware state
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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.  
+  
+
+  state callback: backup env U8G_STATE_MSG_BACKUP_ENV
+  device callback: DEV_MSG_INIT
+  state callback: backup u8g U8G_STATE_MSG_BACKUP_U8G
+  state callback: restore env U8G_STATE_MSG_RESTORE_ENV
+
+  state callback: backup env U8G_STATE_MSG_BACKUP_ENV
+  state callback: retore u8g U8G_STATE_MSG_RESTORE_U8G
+  DEV_MSG_PAGE_FIRST or DEV_MSG_PAGE_NEXT
+  state callback: restore env U8G_STATE_MSG_RESTORE_ENV
+
+*/
+
+#include <stddef.h>
+#include "u8g.h"
+
+void u8g_state_dummy_cb(uint8_t msg)
+{
+  /* the dummy procedure does nothing */
+}
+
+void u8g_SetHardwareBackup(u8g_t *u8g, u8g_state_cb backup_cb)
+{
+  u8g->state_cb = backup_cb;
+  /* in most cases the init message was already sent, so this will backup the */
+  /* current u8g state */
+  backup_cb(U8G_STATE_MSG_BACKUP_U8G);
+}
+
+
+/*===============================================================*/
+/* AVR */
+
+#if defined(__AVR__)
+#define U8G_ATMEGA_HW_SPI
+
+/* remove the definition for attiny */
+#if __AVR_ARCH__ == 2
+#undef U8G_ATMEGA_HW_SPI
+#endif
+#if __AVR_ARCH__ == 25
+#undef U8G_ATMEGA_HW_SPI
+#endif
+#endif
+
+#if defined(U8G_ATMEGA_HW_SPI)
+#include <avr/interrupt.h>
+static uint8_t u8g_state_avr_spi_memory[2];
+
+void u8g_backup_avr_spi(uint8_t msg)
+{
+  if ( U8G_STATE_MSG_IS_BACKUP(msg) )
+  {
+    u8g_state_avr_spi_memory[U8G_STATE_MSG_GET_IDX(msg)] = SPCR;
+  }
+  else
+  {
+    uint8_t tmp = SREG;
+    cli();
+    SPCR = 0;
+    SPCR = u8g_state_avr_spi_memory[U8G_STATE_MSG_GET_IDX(msg)];
+    SREG = tmp;
+  }
+}
+
+#endif
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_u16toa.c

@@ -0,0 +1,68 @@
+/*
+
+  u8g_u16toa.c
+
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+const char *u8g_u16toap(char * dest, uint16_t v)
+{
+  uint8_t pos;
+  uint8_t d;
+  uint16_t c;
+  c = 10000;
+  for( pos = 0; pos < 5; pos++ )
+  {
+      d = '0';
+      while( v >= c )
+      {
+	v -= c;
+	d++;
+      }
+      dest[pos] = d;
+      c /= 10;
+  }  
+  dest[5] = '\0';
+  return dest;
+}
+
+/* v = value, d = number of digits */
+const char *u8g_u16toa(uint16_t v, uint8_t d)
+{
+  static char buf[6];
+  d = 5-d;
+  return u8g_u16toap(buf, v) + d;
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_u8toa.c

@@ -0,0 +1,68 @@
+/*
+
+  u8g_u8toa.c
+
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2011, olikraus@gmail.com
+  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 "u8g.h"
+
+static const unsigned char u8g_u8toa_tab[3]  = { 100, 10, 1 } ;
+const char *u8g_u8toap(char * dest, uint8_t v)
+{
+  uint8_t pos;
+  uint8_t d;
+  uint8_t c;
+  for( pos = 0; pos < 3; pos++ )
+  {
+      d = '0';
+      c = *(u8g_u8toa_tab+pos);
+      while( v >= c )
+      {
+	v -= c;
+	d++;
+      }
+      dest[pos] = d;
+  }  
+  dest[3] = '\0';
+  return dest;
+}
+
+/* v = value, d = number of digits */
+const char *u8g_u8toa(uint8_t v, uint8_t d)
+{
+  static char buf[4];
+  d = 3-d;
+  return u8g_u8toap(buf, v) + d;
+}
+

ArduinoAddons/Arduino_1.x.x/libraries/U8glib/utility/u8g_virtual_screen.c

@@ -0,0 +1,145 @@
+/*
+
+  u8g_virtual_screen.c
+
+  Universal 8bit Graphics Library
+  
+  Copyright (c) 2012, olikraus@gmail.com
+  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 "u8g.h"
+
+struct _u8g_vs_t
+{
+  u8g_uint_t x;
+  u8g_uint_t y;
+  u8g_t *u8g;
+};
+typedef struct _u8g_vs_t u8g_vs_t;
+
+#define U8g_VS_MAX 4
+uint8_t u8g_vs_cnt = 0;
+u8g_vs_t u8g_vs_list[U8g_VS_MAX]; 
+uint8_t u8g_vs_current;
+u8g_uint_t u8g_vs_width;
+u8g_uint_t u8g_vs_height;
+
+uint8_t u8g_dev_vs_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg)
+{
+  switch(msg)
+  {
+    default:
+      {
+	uint8_t i;
+	for( i = 0; i < u8g_vs_cnt; i++ )
+	{
+	  u8g_call_dev_fn(u8g_vs_list[i].u8g, u8g_vs_list[i].u8g->dev, msg, arg);
+	}
+      }
+      return 1;
+    case U8G_DEV_MSG_PAGE_FIRST:
+      u8g_vs_current = 0;
+      if ( u8g_vs_cnt != 0 )
+	return u8g_call_dev_fn(u8g_vs_list[u8g_vs_current].u8g, u8g_vs_list[u8g_vs_current].u8g->dev, msg, arg);
+      return 0;
+    case U8G_DEV_MSG_PAGE_NEXT:
+      {	
+	uint8_t ret = 0;
+	if ( u8g_vs_cnt != 0 )
+	  ret = u8g_call_dev_fn(u8g_vs_list[u8g_vs_current].u8g, u8g_vs_list[u8g_vs_current].u8g->dev, msg, arg);
+	if ( ret != 0 )
+	  return ret;
+	u8g_vs_current++;	/* next device */
+	if ( u8g_vs_current >= u8g_vs_cnt )  /* reached end? */
+	  return 0;
+	return u8g_call_dev_fn(u8g_vs_list[u8g_vs_current].u8g, u8g_vs_list[u8g_vs_current].u8g->dev, U8G_DEV_MSG_PAGE_FIRST, arg);	
+      }
+      return 0;
+    case U8G_DEV_MSG_GET_WIDTH:
+      *((u8g_uint_t *)arg) = u8g_vs_width;
+      break;
+    case U8G_DEV_MSG_GET_HEIGHT:
+      *((u8g_uint_t *)arg) = u8g_vs_height;
+      break;
+    case U8G_DEV_MSG_GET_PAGE_BOX:
+      if ( u8g_vs_current < u8g_vs_cnt )
+      {
+	u8g_call_dev_fn(u8g_vs_list[u8g_vs_current].u8g, u8g_vs_list[u8g_vs_current].u8g->dev, msg, arg);
+	((u8g_box_t *)arg)->x0 += u8g_vs_list[u8g_vs_current].x;
+	((u8g_box_t *)arg)->x1 += u8g_vs_list[u8g_vs_current].x;
+	((u8g_box_t *)arg)->y0 += u8g_vs_list[u8g_vs_current].y;
+	((u8g_box_t *)arg)->y1 += u8g_vs_list[u8g_vs_current].y;
+      }
+      else
+      {
+	((u8g_box_t *)arg)->x0 = 0;
+	((u8g_box_t *)arg)->x1 = 0;
+	((u8g_box_t *)arg)->y0 = 0;
+	((u8g_box_t *)arg)->y1 = 0;
+      }
+      return 1;
+    case U8G_DEV_MSG_SET_PIXEL:
+    case U8G_DEV_MSG_SET_8PIXEL:
+      if ( u8g_vs_current < u8g_vs_cnt )
+      {
+        ((u8g_dev_arg_pixel_t *)arg)->x -= u8g_vs_list[u8g_vs_current].x;
+        ((u8g_dev_arg_pixel_t *)arg)->y -= u8g_vs_list[u8g_vs_current].y;
+	return u8g_call_dev_fn(u8g_vs_list[u8g_vs_current].u8g, u8g_vs_list[u8g_vs_current].u8g->dev, msg, arg);
+      }
+      break;
+  }
+  return 1;
+}
+
+
+
+u8g_dev_t u8g_dev_vs = { u8g_dev_vs_fn, NULL, NULL };
+
+void u8g_SetVirtualScreenDimension(u8g_t *vs_u8g, u8g_uint_t width, u8g_uint_t height)
+{
+  if ( vs_u8g->dev != &u8g_dev_vs )
+    return; 	/* abort if there is no a virtual screen device */
+  u8g_vs_width = width;
+  u8g_vs_height = height;  
+}
+
+uint8_t u8g_AddToVirtualScreen(u8g_t *vs_u8g, u8g_uint_t x, u8g_uint_t y, u8g_t *child_u8g)
+{
+  if ( vs_u8g->dev != &u8g_dev_vs )
+    return 0; 	/* abort if there is no a virtual screen device */
+  if ( u8g_vs_cnt >= U8g_VS_MAX )
+    return 0;  	/* maximum number of  child u8g's reached */
+  u8g_vs_list[u8g_vs_cnt].u8g = child_u8g;
+  u8g_vs_list[u8g_vs_cnt].x = x;
+  u8g_vs_list[u8g_vs_cnt].y = y;
+  u8g_vs_cnt++;
+  return 1;
+}
+