Merged 1.1.0-RC6 Version changes

Merge RC => RCBugFix changes since RC5

.astylerc

@@ -0,0 +1,23 @@
+--style=google
+--keep-one-line-blocks
+
+--indent=spaces=2
+--indent-preproc-block
+--indent-preproc-define
+--indent-col1-comments
+
+--remove-brackets
+--break-after-logical
+--delete-empty-lines
+
+--pad-oper
+--pad-header
+--unpad-paren
+--align-pointer=type
+--align-reference=type
+
+--attach-classes
+--attach-inlines
+--keep-one-line-statements
+
+--indent-namespaces

.gitignore

@@ -1,3 +1,12 @@
+// Our automatic versioning scheme generates the following file
+// NEVER put it in the repository
+_Version.h
+
+// All of the following OS, IDE and compiler generated file
+// references should be moved from this file
+// They are needed, but they belong in your global .gitignore
+// rather than in a per-project file such as this
+
 *.o
 applet/
 *~
@@ -6,3 +15,6 @@ applet/
 *.bak
 *.DS_Store
 *.idea
+*.s
+*.i
+*.ii

.pioenvs/do-not-modify-files-here.url

@@ -1,3 +0,0 @@
-
-[InternetShortcut]
-URL=http://docs.platformio.org/page/projectconf.html#envs-dir

.pioenvs/megaatmega2560/libFrameworkArduinoVariant.a

@@ -1 +0,0 @@
-!<arch>

.pioenvs/structure.hash

@@ -1 +0,0 @@
-7139b6316d7ee09825c8b66954eab4443fcf0d83

.piolibdeps/U8glib_ID7/.library.json

@@ -1,40 +0,0 @@
-{
-    "description": "A library for monochrome TFTs and OLEDs", 
-    "repository": {
-        "url": "https://github.com/olikraus/U8glib_Arduino", 
-        "type": "git"
-    }, 
-    "platforms": [
-        "atmelavr", 
-        "atmelsam"
-    ], 
-    "export": {
-        "exclude": [
-            "extras", 
-            "docs", 
-            "tests", 
-            "test", 
-            "*.doxyfile", 
-            "*.pdf"
-        ], 
-        "include": null
-    }, 
-    "authors": [
-        {
-            "maintainer": true, 
-            "name": "oliver", 
-            "url": null, 
-            "email": "olikraus@gmail.com"
-        }
-    ], 
-    "keywords": [
-        "display"
-    ], 
-    "id": 7, 
-    "name": "U8glib", 
-    "frameworks": [
-        "arduino"
-    ], 
-    "version": "1.19.1", 
-    "homepage": "https://github.com/olikraus/u8glib"
-}

.piolibdeps/U8glib_ID7/README.md

@@ -1,30 +0,0 @@
-
-# U8glib
-
-A graphics library with support for many different monochrome displays.
-
-![nhd_oled180.jpg](https://github.com/olikraus/u8glib/wiki/otherpic/nhd_oled180.jpg) ![dogs102_180.jpg](https://github.com/olikraus/u8glib/wiki/otherpic/dogs102_180.jpg)
-
-Left: NHD-2.7-12864 OLED (SSD1325), right: EA DOGS102 LCD (UC1701)
-
- * [Gallery](https://github.com/olikraus/u8glib/wiki/gallery)
- * [Bintray](https://bintray.com/olikraus/u8glib) download links:
-  * [U8glib for Arduino](https://bintray.com/olikraus/u8glib/Arduino)
-  * [U8glib for AVR](https://bintray.com/olikraus/u8glib/AVR)
-  * [U8glib for ARM](https://bintray.com/olikraus/u8glib/ARM)
-  * Converter for BDF fonts: [bdf2u8g_101.exe on google drive](https://drive.google.com/folderview?id=0B5b6Dv0wCeCRLWJkYTh2TUlYVDg&usp=sharing).
- * Supported environments:
-  * [Arduino (ATMEGA and ARM)](http://www.arduino.cc/)
-  * [AVR (ATMEGA)](https://github.com/olikraus/u8glib/wiki/avr)
-  * [ARM (with example for LPC1114)](https://github.com/olikraus/u8glib/wiki/lpc1114)
- * Library for graphic LCDs and OLEDs
- * [U8glib documentation and tutorials](https://github.com/olikraus/u8glib/wiki)
- * Graphical user interface library (GUI) available: [M2tklib](http://code.google.com/p/m2tklib/)
- * COM interfaces: Software SPI, Hardware SPI, 8Bit parallel
- * Large number of [fonts](https://github.com/olikraus/u8glib/wiki/fontsize)
- * Monospaced and proportional fonts 
- * Mouse-Cursor support
- * Landscape and portrait mode
- * Many supported [devices](https://github.com/olikraus/u8glib/wiki/device) (SSD1325, ST7565, ST7920, UC1608, UC1610, UC1701, PCD8544, PCF8812, KS0108, LC7981, SBN1661, SSD1306, SH1106, T6963, LD7032)
- * Well-defined interface to the device subsystem
-

.piolibdeps/U8glib_ID7/library.properties

@@ -1,9 +0,0 @@
-name=U8glib
-version=1.19.1
-author=oliver <olikraus@gmail.com>
-maintainer=oliver <olikraus@gmail.com>
-sentence=A library for monochrome TFTs and OLEDs
-paragraph=Supported display controller: SSD1306, SSD1309, SSD1322, SSD1325, SSD1327, SH1106, UC1601, UC1610, UC1611, UC1701, ST7565, ST7920, KS0108, LC7981, PCD8544, PCF8812, SBN1661, TLS8204, T6963.
-category=Display
-url=https://github.com/olikraus/u8glib
-architectures=avr,sam

.piolibdeps/U8glib_ID7/license.txt

@@ -1,81 +0,0 @@
-
-The U8glib code (http://code.google.com/p/u8glib/) is licensed under the terms of 
-the new-bsd license (two-clause bsd license).
-See also: http://www.opensource.org/licenses/bsd-license.php
-
-The repository and optionally the releases contain icons, which are
-derived from the WPZOOM Developer Icon Set:
-http://www.wpzoom.com/wpzoom/new-freebie-wpzoom-developer-icon-set-154-free-icons/
-WPZOOM Developer Icon Set by WPZOOM is licensed under a Creative Commons 
-Attribution-ShareAlike 3.0 Unported License.
-
-Fonts are licensed under different conditions.
-See http://code.google.com/p/u8glib/wiki/fontgroup for
-detailed information on the licensing conditions for each font.
-
-============ X11 Fonts COUR, HELV, NCEN, TIM, SYMB ============
-
-For fonts derived from the following files, the license below applies.
-COURB08.BDF COURB10.BDF COURB12.BDF COURB14.BDF COURB18.BDF 
-COURB24.BDF COURR08.BDF COURR10.BDF COURR12.BDF COURR14.BDF 
-COURR18.BDF COURR24.BDF HELVB08.BDF HELVB10.BDF HELVB12.BDF HELVB14.BDF 
-HELVB18.BDF HELVB24.BDF HELVR08.BDF HELVR10.BDF HELVR12.BDF HELVR14.BDF 
-HELVR18.BDF HELVR24.BDF NCENB08.BDF NCENB10.BDF NCENB12.BDF 
-NCENB14.BDF NCENB18.BDF NCENB24.BDF NCENR08.BDF NCENR10.BDF 
-NCENR12.BDF NCENR14.BDF NCENR18.BDF NCENR24.BDF SYMB08.BDF SYMB10.BDF 
-SYMB12.BDF SYMB14.BDF SYMB18.BDF SYMB24.BDF TIMB08.BDF TIMB10.BDF 
-TIMB12.BDF TIMB14.BDF TIMB18.BDF TIMB24.BDF TIMR08.BDF TIMR10.BDF 
-TIMR12.BDF TIMR14.BDF TIMR18.BDF TIMR24.BDF 
-
-Copyright 1984-1989, 1994 Adobe Systems Incorporated.
-Copyright 1988, 1994 Digital Equipment Corporation.
-
-Adobe is a trademark of Adobe Systems Incorporated which may be
-registered in certain jurisdictions.
-Permission to use these trademarks is hereby granted only in
-association with the images described in this file.
-
-Permission to use, copy, modify, distribute and sell this software
-and its documentation for any purpose and without fee is hereby
-granted, provided that the above copyright notices appear in all
-copies and that both those copyright notices and this permission
-notice appear in supporting documentation, and that the names of
-Adobe Systems and Digital Equipment Corporation not be used in
-advertising or publicity pertaining to distribution of the software
-without specific, written prior permission.  Adobe Systems and
-Digital Equipment Corporation make no representations about the
-suitability of this software for any purpose.  It is provided "as
-is" without express or implied warranty.
-
-
-============ BSD License for U8glib Code ============
-
-Universal 8bit Graphics Library (http://code.google.com/p/u8glib/)
-
-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.  
-

.piolibdeps/U8glib_ID7/src/U8glib.cpp

@@ -1,80 +0,0 @@
-/*
-
-  U8glib.cpp
-
-  C++ 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 "U8glib.h"
-
-
-#if defined(U8G_WITH_PINLIST)
-uint8_t U8GLIB::initSPI(u8g_dev_t *dev, uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset)
-{
-  prepare();
-  return u8g_InitSPI(&u8g, dev, sck, mosi, cs, a0, reset);
-}
-
-uint8_t U8GLIB::initHWSPI(u8g_dev_t *dev, uint8_t cs, uint8_t a0, uint8_t reset)
-{
-  prepare();
-  return u8g_InitHWSPI(&u8g, dev, cs, a0, reset);
-}
-
-uint8_t U8GLIB::initI2C(u8g_dev_t *dev, uint8_t options)
-{
-  prepare();
-  return u8g_InitI2C(&u8g, dev, options);
-}
-
-uint8_t U8GLIB::init8Bit(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)
-{
-  prepare();
-  return u8g_Init8Bit(&u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, en, cs1, cs2, di, rw, reset); 
-}
-
-uint8_t U8GLIB::init8BitFixedPort(u8g_dev_t *dev, uint8_t en, uint8_t cs, uint8_t di, uint8_t rw, uint8_t reset)
-{
-  prepare();
-  return u8g_Init8BitFixedPort(&u8g, dev, en, cs, di, rw, reset);
-}
-
-uint8_t U8GLIB::initRW8Bit(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)
-{
-  prepare();
-  return u8g_InitRW8Bit(&u8g, dev, d0, d1, d2, d3, d4, d5, d6, d7, cs, a0, wr, rd, reset); 
-}
-#endif
-

.piolibdeps/U8glib_ID7/src/clib/u8g_bitmap.c

@@ -1,177 +0,0 @@
-/*
-
-  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--;
-  }
-}

.piolibdeps/U8glib_ID7/src/clib/u8g_circle.c

@@ -1,382 +0,0 @@
-/*
-
-  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);
-}
-
-
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_clip.c

@@ -1,156 +0,0 @@
-/*
-
-  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 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 __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_ALWAYS_INLINE 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);
-}
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_api.c

@@ -1,173 +0,0 @@
-/*
-
-  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, uint8_t clk_cycle_time)
-{
-  return dev->com_fn(u8g, U8G_COM_MSG_INIT, clk_cycle_time, 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;
-}
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_api_16gr.c

@@ -1,94 +0,0 @@
-/*
-
-  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;
-}

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_common.c

@@ -1,75 +0,0 @@
-/*
-  
-  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
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_fast_parallel.c

@@ -1,254 +0,0 @@
-/*
-  
-  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)
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START();
-    U8G_ATOMIC_END();
-
-*/
-
-#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]);  
-}
-
-/* atomic protection must be done by calling function */
-static 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_ATOMIC_START();
-  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;
-  U8G_ATOMIC_END();
-  
-  /* 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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_hw_spi.c

@@ -1,438 +0,0 @@
-/*
-  
-  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.  
-
-  SPI Clock Cycle Type
-  
-  SSD1351	  50ns		20 MHz
-  SSD1322	300ns		  3.3 MHz
-  SSD1327	300ns
-  SSD1306	300ns
-  ST7565		400ns 		  2.5 MHz
-  ST7920		400ns
-
-  Arduino DUE
-  
-  PA25	MISO
-  PA26	MOSI	75
-  PA27	SCLK	76
-  
-  
-typedef struct {
-  WoReg SPI_CR;        (Spi Offset: 0x00) Control Register 
-  RwReg SPI_MR;        (Spi Offset: 0x04) Mode Register 
-  RoReg SPI_RDR;       (Spi Offset: 0x08) Receive Data Register 
-  WoReg SPI_TDR;       (Spi Offset: 0x0C) Transmit Data Register 
-  RoReg SPI_SR;        (Spi Offset: 0x10) Status Register 
-  WoReg SPI_IER;       (Spi Offset: 0x14) Interrupt Enable Register 
-  WoReg SPI_IDR;       (Spi Offset: 0x18) Interrupt Disable Register 
-  RoReg SPI_IMR;       (Spi Offset: 0x1C) Interrupt Mask Register 
-  RoReg Reserved1[4];
-  RwReg SPI_CSR[4];    (Spi Offset: 0x30) Chip Select Register 
-  RoReg Reserved2[41];
-  RwReg SPI_WPMR;      (Spi Offset: 0xE4) Write Protection Control Register 
-  RoReg SPI_WPSR;      (Spi Offset: 0xE8) Write Protection Status Register 
-} Spi;
-  
-  Power Management Controller (PMC)
-  arduino-1.5.2/hardware/arduino/sam/system/CMSIS/Device/ATMEL/sam3xa/include/instance/instance_pmc.h
-    - enable PIO
-      
-      REG_PMC_PCER0 = 1UL << ID_PIOA
-    - enable SPI
-      REG_PMC_PCER0 = 1UL << ID_SPI0
-
-
-    - enable PIOA and SPI0
-      REG_PMC_PCER0 = (1UL << ID_PIOA) | (1UL << ID_SPI0);
-
-  Parallel Input/Output Controller (PIO)
-  arduino-1.5.2/hardware/arduino/sam/system/CMSIS/Device/ATMEL/sam3xa/include/instance/instance_pioa.h
-    - enable special function of the pin: disable PIO on A26 and A27:
-	REG_PIOA_PDR = 0x0c000000
-	PIOA->PIO_PDR = 0x0c000000
-
-  SPI
-    SPI0->SPI_CR = SPI_CR_SPIDIS
-    SPI0->SPI_CR = SPI_CR_SWRST ;
-    SPI0->SPI_CR = SPI_CR_SWRST ;
-    SPI0->SPI_CR = SPI_CR_SPIEN
-  
-    Bit 0: Master Mode = 1 (active)
-    Bit 1: Peripheral Select = 0 (fixed)
-    Bit 2: Chip Select Decode Mode = 1 (4 to 16)
-    Bit 4: Mode Fault Detection = 1 (disabled)
-    Bit 5: Wait Data Read = 0 (disabled) 
-    Bit 7: Loop Back Mode = 0 (disabled)
-    Bit 16-19: Peripheral Chip Select = 0 (chip select 0)    
-    SPI0->SPI_MR = SPI_MR_MSTR | SPI_MR_PCSDEC | SPI_MR_MODFDIS
-    
-    Bit 0: Clock Polarity = 0
-    Bit 1: Clock Phase = 0
-    Bit 4-7: Bits = 0 (8 Bit)
-    Bit 8-15: SCBR = 1
-    SPI0->SPI_CSR[0] = SPI_CSR_SCBR(x)	Serial Baud Rate
-	SCBR / 84000000 > 50 / 1000000000 
-	SCBR / 84 > 5 / 100 
-	SCBR  > 50 *84 / 1000 --> SCBR=5
-	SCBR  > 300*84 / 1000 --> SCBR=26
-	SCBR  > 400*84 / 1000 --> SCBR=34
-
-  Arduino Due test code:
-    REG_PMC_PCER0 = (1UL << ID_PIOA) | (1UL << ID_SPI0);
-    REG_PIOA_PDR = 0x0c000000;
-    SPI0->SPI_CR = SPI_CR_SPIDIS;
-    SPI0->SPI_CR = SPI_CR_SWRST;
-    SPI0->SPI_CR = SPI_CR_SWRST;
-    SPI0->SPI_CR = SPI_CR_SPIEN;
-    SPI0->SPI_MR = SPI_MR_MSTR | SPI_MR_PCSDEC | SPI_MR_MODFDIS;
-    SPI0->SPI_CSR[0] = SPI_CSR_SCBR(30);
-
-    for(;;)
-    {
-      while( (SPI0->SPI_SR & SPI_SR_TDRE) == 0 )
-	;
-      SPI0->SPI_TDR = 0x050;
-    }
-
-*/
-
-#include "u8g.h"
-
-#if defined(ARDUINO)
-
-#if defined(__AVR__)
-#define U8G_ARDUINO_ATMEGA_HW_SPI
-/* remove the definition for attiny */
-#if __AVR_ARCH__ == 2
-#undef U8G_ARDUINO_ATMEGA_HW_SPI
-#endif
-#if __AVR_ARCH__ == 25
-#undef U8G_ARDUINO_ATMEGA_HW_SPI
-#endif
-#endif
-
-#if defined(U8G_ARDUINO_ATMEGA_HW_SPI)
-
-#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)|(0<<SPR0)|(0<<CPOL)|(0<<CPHA);
-#ifdef U8G_HW_SPI_2X
-      SPSR = (1 << SPI2X);  /* double speed, issue 89 */
-#else
-      if ( arg_val  <= U8G_SPI_CLK_CYCLE_50NS )
-      {
-	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) */
-
-#elif defined(__SAM3X8E__)		// Arduino Due, maybe we should better check for __SAM3X8E__
-
-#include <Arduino.h> 
-
-/* use Arduino pin definitions */
-#define PIN_SCK SCK
-#define PIN_MISO  MISO
-#define PIN_MOSI MOSI
-#define PIN_CS SS
-
-
-static uint8_t u8g_spi_out(uint8_t data)
-{
-  /* wait until tx register is empty */
-  while( (SPI0->SPI_SR & SPI_SR_TDRE) == 0 )
-    ;
-  /* send data */
-  SPI0->SPI_TDR = (uint32_t)data;
-  return  data;
-}
-
-
-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);
-      u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
-    
-      /* Arduino Due specific code */
-      
-      /* enable PIOA and SPI0 */
-      REG_PMC_PCER0 = (1UL << ID_PIOA) | (1UL << ID_SPI0);
-
-      /* disable PIO on A26 and A27 */
-      REG_PIOA_PDR = 0x0c000000;
-
-      /* reset SPI0 (from sam lib) */
-      SPI0->SPI_CR = SPI_CR_SPIDIS;
-      SPI0->SPI_CR = SPI_CR_SWRST;
-      SPI0->SPI_CR = SPI_CR_SWRST;
-      SPI0->SPI_CR = SPI_CR_SPIEN;
-      u8g_MicroDelay();
-      
-      /* master mode, no fault detection, chip select 0 */
-      SPI0->SPI_MR = SPI_MR_MSTR | SPI_MR_PCSDEC | SPI_MR_MODFDIS;
-      
-      /* Polarity, Phase, 8 Bit data transfer, baud rate */
-      /* x * 1000 / 84 --> clock cycle in ns 
-        5 * 1000 / 84 = 58 ns       
-	SCBR  > 50 *84 / 1000 --> SCBR=5
-	SCBR  > 300*84 / 1000 --> SCBR=26
-	SCBR  > 400*84 / 1000 --> SCBR=34
-      */
-      
-      if ( arg_val <= U8G_SPI_CLK_CYCLE_50NS )
-      {
-	SPI0->SPI_CSR[0] = SPI_CSR_SCBR(5) | 1;
-      }
-      else if ( arg_val <= U8G_SPI_CLK_CYCLE_300NS )
-      {
-	SPI0->SPI_CSR[0] = SPI_CSR_SCBR(26) | 1;
-      }
-      else if ( arg_val <= U8G_SPI_CLK_CYCLE_400NS )
-      {
-	SPI0->SPI_CSR[0] = SPI_CSR_SCBR(34) | 1;
-      }
-      else
-      {
-	SPI0->SPI_CSR[0] = SPI_CSR_SCBR(84) | 1;
-      }
-      
-      u8g_MicroDelay();      
-      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);
-      u8g_MicroDelay();
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      if ( arg_val == 0 )
-      {
-        /* disable */
-	u8g_MicroDelay();		/* this delay is required to avoid that the display is switched off too early --> DOGS102 with DUE */
-        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
-	u8g_MicroDelay();
-      }
-      else
-      {
-        /* enable */
-        //u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, LOW);
-        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
-	u8g_MicroDelay();
-      }
-      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);
-      u8g_MicroDelay();
-      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;
-}
-
-
-
-#else /* U8G_ARDUINO_ATMEGA_HW_SPI */
-
-#endif /* U8G_ARDUINO_ATMEGA_HW_SPI */
-
-#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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_no_en_parallel.c

@@ -1,234 +0,0 @@
-/*
-  
-  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)
-  Update for ATOMIC operation done (01 Jun 2013)
-  
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START();
-    U8G_ATOMIC_END();
-
-*/
-
-#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]);  
-}
-
-/* No atomic protcetion. This is done by caller */
-static 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_ATOMIC_START();
-  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;
-  U8G_ATOMIC_END();
-  
-  /* 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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_parallel.c

@@ -1,184 +0,0 @@
-/*
-  
-  u8g_com_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_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 */
-}
-
-
-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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_port_d_wr.c

@@ -1,177 +0,0 @@
-/*
-  
-  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)
-
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START();
-    U8G_ATOMIC_END();
-
-*/
-
-#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
-      U8G_ATOMIC_START();
-      DDRD = 0x0ff;
-      PORTD = 0x0ff;
-      U8G_ATOMIC_END();
-
-      /* 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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_ssd_i2c.c

@@ -1,212 +0,0 @@
-/*
-  
-  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"
-
-#if defined(U8G_WITH_PINLIST)
-
-
-#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;
-}
-
-#else  /* defined(U8G_WITH_PINLIST) */
-
-uint8_t u8g_com_arduino_ssd_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-{
-  return 1;
-}
-
-#endif /* defined(U8G_WITH_PINLIST) */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_st7920_hw_spi.c

@@ -1,293 +0,0 @@
-/*
-  
-  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_ARDUINO_ATMEGA_HW_SPI
-#endif
-#if __AVR_ARCH__ == 25
-#undef U8G_ARDUINO_ATMEGA_HW_SPI
-#endif
-
-#endif
-
-
-#if defined(U8G_ARDUINO_ATMEGA_HW_SPI)
-
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-
-#if ARDUINO < 100 
-
-/* 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 
-
-/* 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_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_seq(u8g_t *u8g, uint8_t rs, uint8_t *ptr, uint8_t len)
-{
-  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);
-  }
-
-  while( len > 0 )
-  {
-    u8g_arduino_st7920_hw_spi_shift_out(u8g, *ptr & 0x0f0);
-    u8g_arduino_st7920_hw_spi_shift_out(u8g, *ptr << 4);
-    ptr++;
-    len--;
-    u8g_10MicroDelay();
-  }
-  
-  for( i = 0; i < 4; i++ )
-    u8g_10MicroDelay();
-}
-
-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);
-      
-      
-      /* code from u8g_com-arduino_hw_spi.c */
-      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);
-      
-      
-      //u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
-      
-#ifdef OBSOLETE      
-      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 */
-#endif
-
-      /*
-        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:
-      u8g_com_arduino_st7920_write_byte_hw_spi_seq(u8g, u8g->pin_list[U8G_PI_A0_STATE], (uint8_t *)arg_ptr, arg_val);
-      /*
-      {
-        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++);
-          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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_st7920_spi.c

@@ -1,330 +0,0 @@
-/*
-  
-  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
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START();
-    U8G_ATOMIC_END();
-
-
-*/
-
-#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__)
-
-static uint8_t u8g_bitData, u8g_bitNotData;
-static uint8_t u8g_bitClock, u8g_bitNotClock;
-static volatile uint8_t *u8g_outData;
-static 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;
-  
-  
-  U8G_ATOMIC_START();
-  bitData |= *outData;
-  bitNotData &= *outData;
-  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 );
-  U8G_ATOMIC_END();
-}
-
-#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;
-  U8G_ATOMIC_START();
-  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 );
-  U8G_ATOMIC_END();
-}
-
-#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_seq(uint8_t rs, uint8_t *ptr, uint8_t len)
-{
-  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);
-  }
-
-  while( len > 0 )
-  {
-    u8g_com_arduino_do_shift_out_msb_first(*ptr & 0x0f0);
-    u8g_com_arduino_do_shift_out_msb_first(*ptr << 4);
-    ptr++;
-    len--;
-    u8g_10MicroDelay();
-  }
-  
-  for( i = 0; i < 4; i++ )
-    u8g_10MicroDelay();
-}
-
-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);
-	/* 28 Dec 2013 reassign pins, fixes issue with more than one display */
-	/* issue 227 */
-	u8g_com_arduino_init_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK]);
-      }
-      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:
-      u8g_com_arduino_st7920_write_byte_seq(u8g->pin_list[U8G_PI_A0_STATE], (uint8_t *)arg_ptr, 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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_std_sw_spi.c

@@ -1,143 +0,0 @@
-/*
-  
-  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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_sw_spi.c

@@ -1,301 +0,0 @@
-/*
-  
-  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.  
-  
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START();
-    U8G_ATOMIC_END();
- 
-
-*/
-
-#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
-
-/*=========================================================*/
-/* Arduino, AVR */
-
-#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;
-  U8G_ATOMIC_START();
-  do
-  {
-    if ( val & 128 )
-      *outData |= bitData;
-    else
-      *outData &= bitNotData;
-   
-    *outClock |= bitClock;
-    val <<= 1;
-    cnt--;
-    *outClock &= bitNotClock;
-  } while( cnt != 0 );
-  U8G_ATOMIC_END();
-}
-
-/*=========================================================*/
-/* Arduino, Chipkit */
-#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;
-  U8G_ATOMIC_START();
-  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 );
-  U8G_ATOMIC_END();
-}
-
-/*=========================================================*/
-/* Arduino Due */
-#elif defined(__SAM3X8E__)
-
-/* Due */
-
-void u8g_digital_write_sam_high(uint8_t pin)
-{
-    PIO_Set( g_APinDescription[pin].pPort, g_APinDescription[pin].ulPin) ;
-}
-
-void u8g_digital_write_sam_low(uint8_t pin)
-{
-    PIO_Clear( g_APinDescription[pin].pPort, g_APinDescription[pin].ulPin) ;
-}
-
-static uint8_t u8g_sam_data_pin;
-static uint8_t u8g_sam_clock_pin;
-
-static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin)
-{
-  u8g_sam_data_pin = dataPin;
-  u8g_sam_clock_pin = clockPin;
-}
-
-static void u8g_com_arduino_do_shift_out_msb_first(uint8_t val)
-{
-  uint8_t i = 8;
-  do
-  {
-    if ( val & 128 )
-      u8g_digital_write_sam_high(u8g_sam_data_pin);
-    else
-      u8g_digital_write_sam_low(u8g_sam_data_pin);
-    val <<= 1;
-    //u8g_MicroDelay();	
-    u8g_digital_write_sam_high(u8g_sam_clock_pin);
-    u8g_MicroDelay();	
-    u8g_digital_write_sam_low(u8g_sam_clock_pin);
-    u8g_MicroDelay();	
-    i--;
-  } while( i != 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);
-	/* issue 227 */
-	u8g_com_arduino_init_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK]);
-      }
-      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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_arduino_t6963.c

@@ -1,403 +0,0 @@
-/*
-  
-  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)
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START();
-    U8G_ATOMIC_END();
- 
-
-*/
-
-#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)
-{
-  /* no ATOMIC protection required here, this is done by calling procedure */
-  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;
-  U8G_ATOMIC_START();
-  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
-
-  }
-  U8G_ATOMIC_END();
-}
-
-static void u8g_com_arduino_t6963_set_port_input(void)
-{
-  uint8_t i;
-  U8G_ATOMIC_START();
-  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
-  }
-  U8G_ATOMIC_END();
-}
-
-
-static void u8g_com_arduino_t6963_write(u8g_t *u8g, uint8_t val)
-{
-  U8G_ATOMIC_START();
-
-  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_ATOMIC_END();
-  
-  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 */
-  
-  U8G_ATOMIC_START();
-  /* 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_ATOMIC_END();
-
-  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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_atmega_hw_spi.c

@@ -1,188 +0,0 @@
-/*
-  
-  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
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START()
-    U8G_ATOMIC_END()
- 
-
-
-*/
-
-#include "u8g.h"
-
-#if defined(__AVR_XMEGA__)
-#elif 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);
-      u8g_SetPIOutput(u8g, U8G_PI_RESET);
-      
-      U8G_ATOMIC_START();
-      
-      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_ATOMIC_END();
-      
-      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
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_atmega_parallel.c

@@ -1,183 +0,0 @@
-/*
-  
-  u8g_com_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 */
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_atmega_st7920_hw_spi.c

@@ -1,217 +0,0 @@
-/*
-  
-  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
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START()
-    U8G_ATOMIC_END()
- 
-
-*/
-
-#include "u8g.h"
-
-#if defined(__AVR_XMEGA__)
-#elif 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);
-      
-      U8G_ATOMIC_START();
-      
-      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_ATOMIC_END();
-      
-      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! */
-      /* 24 Jan 2014: implemented, see also issue 221 */
-      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:
-      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
-
- 

.piolibdeps/U8glib_ID7/src/clib/u8g_com_atmega_st7920_spi.c

@@ -1,170 +0,0 @@
-/*
-  
-  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
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_atmega_sw_spi.c

@@ -1,141 +0,0 @@
-/*
-  
-  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
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_atxmega_hw_spi.c

@@ -1,174 +0,0 @@
-/*
-  
-  u8g_com_atxmega_hw_spi.c
-
-  Universal 8bit Graphics Library
-  
-  Copyright (c) 2011, olikraus@gmail.com
-  Copyright (c) 2015, florianmenne@t-online.de
-  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
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START()
-    U8G_ATOMIC_END()
- 
-
-*/
-
-#include "u8g.h"
-
-#if defined(__AVR_XMEGA__)
-#define U8G_ATXMEGA_HW_SPI
-#endif
-
-
-#if defined(U8G_ATXMEGA_HW_SPI)
-
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-
-static uint8_t u8g_atxmega_spi_out(uint8_t data)
-{
-  /* send data */
-  SPIC.DATA = data;
-  
-  /* wait for transmission */
-  while(!(SPIC.STATUS & SPI_IF_bm));
-  
-  /* clear the SPIF flag by reading SPDR */
-  return SPIC.DATA;
-}
-
-
-uint8_t u8g_com_atxmega_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);
-    u8g_SetPIOutput(u8g, U8G_PI_RESET);
-    
-    //U8G_ATOMIC_START();
-    
-    PORTC.DIR |= PIN4_bm | PIN5_bm | PIN7_bm;
-    PORTC.DIR &= ~PIN6_bm;
-
-    //U8G_ATOMIC_END();
-    
-    u8g_SetPILevel(u8g, U8G_PI_CS, 1);
-
-    SPIC.CTRL = 0;
-    SPIC.CTRL     = SPI_PRESCALER_DIV4_gc |		// SPI prescaler.
-    //SPI_CLK2X_bm |			 //SPI Clock double.
-    SPI_ENABLE_bm |			 //Enable SPI module.
-    //SPI_DORD_bm |			 //Data order.
-    SPI_MASTER_bm |			 //SPI master.
-    SPI_MODE_0_gc;			// SPI mode.
-    
-#ifdef U8G_HW_SPI_2X
-    SPIC.CTRL |= SPI_CLK2X_bm;  /* 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 */
-      PORTC.OUT &= ~PIN7_bm;
-      /* 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_atxmega_spi_out(arg_val);
-    break;
-    
-    case U8G_COM_MSG_WRITE_SEQ:
-    {
-      register uint8_t *ptr = arg_ptr;
-      while( arg_val > 0 )
-      {
-        u8g_atxmega_spi_out(*ptr++);
-        arg_val--;
-      }
-    }
-    break;
-    case U8G_COM_MSG_WRITE_SEQ_P:
-    {
-      register uint8_t *ptr = arg_ptr;
-      while( arg_val > 0 )
-      {
-        u8g_atxmega_spi_out(u8g_pgm_read(ptr));
-        ptr++;
-        arg_val--;
-      }
-    }
-    break;
-  }
-  return 1;
-}
-
-#else
-
-uint8_t u8g_com_atxmega_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-{
-  return 1;
-}
-
-#endif

.piolibdeps/U8glib_ID7/src/clib/u8g_com_atxmega_st7920_hw_spi.c

@@ -1,202 +0,0 @@
-/*
-  
-  u8g_com_atxmega_st7920_hw_spi.c
-
-  Universal 8bit Graphics Library
-  
-  Copyright (c) 2011, olikraus@gmail.com
-  Copyright (c) 2015, florianmenne@t-online.de
-  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
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START()
-    U8G_ATOMIC_END()
- 
-
-*/
-
-#include "u8g.h"
-
-#if defined(__AVR_XMEGA__)
-#define U8G_ATXMEGA_HW_SPI
-#endif
-
-#if defined(U8G_ATXMEGA_HW_SPI)
-
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-static uint8_t u8g_atxmega_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val) U8G_NOINLINE;
-static uint8_t u8g_atxmega_st7920_hw_spi_shift_out(u8g_t *u8g, uint8_t val)
-{
-  /* send data */
-  SPIC.DATA = val;
-  
-  /* wait for transmission */
-  while(!(SPIC.STATUS & SPI_IF_bm));
-  
-  /* clear the SPIF flag by reading SPDR */
-  return SPIC.DATA;
-}
-
-
-static void u8g_com_atxmega_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val) U8G_NOINLINE;
-static void u8g_com_atxmega_st7920_write_byte_hw_spi(u8g_t *u8g, uint8_t rs, uint8_t val)
-{
-  uint8_t i;
-
-  if ( rs == 0 )
-  {
-    /* command */
-    u8g_atxmega_st7920_hw_spi_shift_out(u8g, 0x0f8);
-  }
-  else if ( rs == 1 )
-  {
-    /* data */
-    u8g_atxmega_st7920_hw_spi_shift_out(u8g, 0x0fa);
-  }
-  
-  u8g_atxmega_st7920_hw_spi_shift_out(u8g, val & 0x0f0);
-  u8g_atxmega_st7920_hw_spi_shift_out(u8g, val << 4);
-
-  for( i = 0; i < 4; i++ )
-    u8g_10MicroDelay();
-}
-
-
-uint8_t u8g_com_atxmega_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);
-      
-      //U8G_ATOMIC_START();
-      
-      PORTC.DIR |= PIN4_bm | PIN5_bm | PIN7_bm;
-      PORTC.DIR &= ~PIN6_bm;
-
-      //U8G_ATOMIC_END();
-      
-      u8g_SetPILevel(u8g, U8G_PI_CS, 1);
-
-      SPIC.CTRL = 0;
-      SPIC.CTRL     = SPI_PRESCALER_DIV4_gc |		// SPI prescaler.
-      //SPI_CLK2X_bm |			 //SPI Clock double.
-      SPI_ENABLE_bm |			 //Enable SPI module.
-      //SPI_DORD_bm |			 //Data order.
-      SPI_MASTER_bm |			 //SPI master.
-      SPI_MODE_0_gc;			// SPI mode.
-
-#ifdef U8G_HW_SPI_2X
-      SPIC.CTRL |= SPI_CLK2X_bm;  /* 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_atxmega_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_atxmega_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_atxmega_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_atxmega_st7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-{
-  return 1;
-}
-
-
-#endif
-
- 

.piolibdeps/U8glib_ID7/src/clib/u8g_com_i2c.c

@@ -1,643 +0,0 @@
-/*
-  
-  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"
-
-//#define U8G_I2C_WITH_NO_ACK
-
-static uint8_t u8g_i2c_err_code;
-static uint8_t u8g_i2c_opt;		/* U8G_I2C_OPT_NO_ACK, SAM: U8G_I2C_OPT_DEV_1 */
-/*
-  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;
-}
-
-
-#if defined(__AVR_XMEGA__)
-#elif defined(__AVR__)
-
-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;
-}
-
-#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
-
-    TWBR = 12;
-    TWSR = 0;
-	--> 400KHz
-
-    F_CPU/(2*100000)-8  --> calculate TWBR value for 100KHz
-*/
-  u8g_i2c_opt = options;
-  TWSR = 0;
-  if ( options & U8G_I2C_OPT_FAST )
-  {
-    TWBR = F_CPU/(2*400000)-8;
-  }
-  else
-  {  
-    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 )
-      {
-	if ( u8g_i2c_opt & U8G_I2C_OPT_NO_ACK )
-	{
-	  return 1;	/* all ok */
-	}
-	else
-	{
-	  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;
-
-  if ( u8g_i2c_opt & U8G_I2C_OPT_NO_ACK )
-  {
-    /* do not check for ACK */
-  }
-  else
-  {
-    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;
-    
-  if ( u8g_i2c_opt & U8G_I2C_OPT_NO_ACK )
-  {
-    /* do not check for ACK */
-  }
-  else
-  {
-    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();
-}
-*/
-
-#elif defined(ARDUINO) && defined(__SAM3X8E__)
-/* Arduino Due */
-#include "Arduino.h"
-#include "sam.h"
-
-/*
-
-Controller
-
-TWI0 TWCK0 PA18 A			DUE PCB: SCL1
-TWI0 TWD0 PA17 A			DUE PCB: SDA1 
-TWI1 TWCK1 PB13 A			DUE PCB: SCL 21
-TWI1 TWD1 PB12 A			DUE PCB: SDA 20
-
-Arduino definitions
-
-#define PIN_WIRE_SDA         (20u)
-#define PIN_WIRE_SCL         (21u)
-#define WIRE_INTERFACE       TWI1
-#define WIRE_INTERFACE_ID    ID_TWI1
-#define WIRE_ISR_HANDLER     TWI1_Handler
-
-#define PIN_WIRE1_SDA        (70u)
-#define PIN_WIRE1_SCL        (71u)
-#define WIRE1_INTERFACE      TWI0
-#define WIRE1_INTERFACE_ID   ID_TWI0
-#define WIRE1_ISR_HANDLER    TWI0_Handler
-
-
-*/
-
-static void i2c_400KHz_delay(void)
-{
-  /* should be at least 4 */
-  /* should be 5 for 100KHz transfer speed */
- 
-  
-  /*
-    Arduino Due
-    0x NOP: 470KHz
-    4x NOP: 450KHz
-    8x NOP: 430KHz
-    16x NOP: 400KHz
-  */
-  
-  __NOP();
-  __NOP();
-  __NOP();
-  __NOP();
-  
-  __NOP();
-  __NOP();
-  __NOP();
-  __NOP();
-
-  __NOP();
-  __NOP();
-  __NOP();
-  __NOP();
-
-  __NOP();
-  __NOP();
-  __NOP();
-  __NOP();
-}
-
-static void i2c_100KHz_delay(void)
-{
-  /* 
-    1x u8g_MicroDelay()	ca. 130KHz
-    2x u8g_MicroDelay()	ca. 80KHz 
-  */
-  u8g_MicroDelay();
-  u8g_MicroDelay();  
-}
-
-
-uint32_t i2c_started = 0;
-uint32_t i2c_scl_pin = 0;
-uint32_t i2c_sda_pin = 0;
-void (*i2c_delay)(void) = i2c_100KHz_delay;
-
-const PinDescription *i2c_scl_pin_desc;
-const PinDescription *i2c_sda_pin_desc;
-
-
-/* maybe this can be optimized */
-static void i2c_init(void)
-{
-  i2c_sda_pin_desc = &(g_APinDescription[i2c_sda_pin]);
-  i2c_scl_pin_desc = &(g_APinDescription[i2c_scl_pin]);
-  pinMode(i2c_sda_pin, OUTPUT);
-  digitalWrite(i2c_sda_pin, HIGH);
-  pinMode(i2c_scl_pin, OUTPUT);
-  digitalWrite(i2c_scl_pin, HIGH);
-  PIO_Configure( i2c_sda_pin_desc->pPort, PIO_OUTPUT_0, i2c_sda_pin_desc->ulPin, PIO_OPENDRAIN );
-  PIO_Configure( i2c_scl_pin_desc->pPort, PIO_OUTPUT_0, i2c_scl_pin_desc->ulPin, PIO_OPENDRAIN );
-  PIO_Clear( i2c_sda_pin_desc->pPort, i2c_sda_pin_desc->ulPin) ;
-  PIO_Clear( i2c_scl_pin_desc->pPort, i2c_scl_pin_desc->ulPin) ;
-  PIO_Configure( i2c_sda_pin_desc->pPort, PIO_INPUT, i2c_sda_pin_desc->ulPin, PIO_DEFAULT ) ;
-  PIO_Configure( i2c_scl_pin_desc->pPort, PIO_INPUT, i2c_scl_pin_desc->ulPin, PIO_DEFAULT ) ;
-  i2c_delay();
-}
-
-/* actually, the scl line is not observed, so this procedure does not return a value */
-static void i2c_read_scl_and_delay(void)
-{
-  uint32_t dwMask = i2c_scl_pin_desc->ulPin;
-  //PIO_Configure( i2c_scl_pin_desc->pPort, PIO_INPUT, i2c_scl_pin_desc->ulPin, PIO_DEFAULT ) ;
-  //PIO_SetInput( i2c_scl_pin_desc->pPort, i2c_scl_pin_desc->ulPin, PIO_DEFAULT ) ;
-
-  /* set as input */
-  i2c_scl_pin_desc->pPort->PIO_ODR = dwMask ;
-  i2c_scl_pin_desc->pPort->PIO_PER = dwMask ;
-
-  i2c_delay();
-}
-
-static void i2c_clear_scl(void)
-{
-  uint32_t dwMask = i2c_scl_pin_desc->ulPin;
-  
-  /* set open collector and drive low */
-  //PIO_Configure( i2c_scl_pin_desc->pPort, PIO_OUTPUT_0, i2c_scl_pin_desc->ulPin, PIO_OPENDRAIN );
-  //PIO_SetOutput( i2c_scl_pin_desc->pPort, i2c_scl_pin_desc->ulPin, 0, 1, 0);
-
-  /* open drain, zero default output */
-  i2c_scl_pin_desc->pPort->PIO_MDER = dwMask;
-  i2c_scl_pin_desc->pPort->PIO_CODR = dwMask;
-  i2c_scl_pin_desc->pPort->PIO_OER = dwMask;
-  i2c_scl_pin_desc->pPort->PIO_PER = dwMask;
-
-  //PIO_Clear( i2c_scl_pin_desc->pPort, i2c_scl_pin_desc->ulPin) ;
-}
-
-static uint8_t i2c_read_sda(void)
-{
-  uint32_t dwMask = i2c_sda_pin_desc->ulPin;
-  //PIO_Configure( i2c_sda_pin_desc->pPort, PIO_INPUT, i2c_sda_pin_desc->ulPin, PIO_DEFAULT ) ;
-  //PIO_SetInput( i2c_sda_pin_desc->pPort, i2c_sda_pin_desc->ulPin, PIO_DEFAULT ) ;
-
-  /* set as input */
-  i2c_sda_pin_desc->pPort->PIO_ODR = dwMask ;
-  i2c_sda_pin_desc->pPort->PIO_PER = dwMask ;
-
-
-  return 1;
-}
-
-static void i2c_clear_sda(void)
-{
-  uint32_t dwMask = i2c_sda_pin_desc->ulPin;
-  
-  /* set open collector and drive low */
-  //PIO_Configure( i2c_sda_pin_desc->pPort, PIO_OUTPUT_0, i2c_sda_pin_desc->ulPin, PIO_OPENDRAIN );
-  //PIO_SetOutput( i2c_sda_pin_desc->pPort, i2c_sda_pin_desc->ulPin, 0, 1, 0);
-  
-  /* open drain, zero default output */
-  i2c_sda_pin_desc->pPort->PIO_MDER = dwMask ;
-  i2c_sda_pin_desc->pPort->PIO_CODR = dwMask ;
-  i2c_sda_pin_desc->pPort->PIO_OER = dwMask ;
-  i2c_sda_pin_desc->pPort->PIO_PER = dwMask ;
-  
-  //PIO_Clear( i2c_sda_pin_desc->pPort, i2c_sda_pin_desc->ulPin) ;
-}
-
-static void i2c_start(void)
-{
-  if ( i2c_started != 0 )
-  {
-    /* if already started: do restart */
-    i2c_read_sda();     /* SDA = 1 */
-    i2c_delay();
-    i2c_read_scl_and_delay();
-  }
-  i2c_read_sda();
-  /*
-  if (i2c_read_sda() == 0)
-  {
-    // do something because arbitration is lost
-  }
-  */
-  /* send the start condition, both lines go from 1 to 0 */
-  i2c_clear_sda();
-  i2c_delay();
-  i2c_clear_scl();
-  i2c_started = 1;
-}
-
-
-static void i2c_stop(void)
-{
-  /* set SDA to 0 */
-  i2c_clear_sda();  
-  i2c_delay();
- 
-  /* now release all lines */
-  i2c_read_scl_and_delay();
- 
-  /* set SDA to 1 */
-  i2c_read_sda();
-  i2c_delay();
-  i2c_started = 0;
-}
-
-static void i2c_write_bit(uint8_t val)
-{
-  if (val)
-    i2c_read_sda();
-  else
-    i2c_clear_sda();
- 
-  i2c_delay();
-  i2c_read_scl_and_delay();
-  i2c_clear_scl();
-}
-
-static uint8_t i2c_read_bit(void)
-{
-  uint8_t val;
-  /* do not drive SDA */
-  i2c_read_sda();
-  i2c_delay();
-  i2c_read_scl_and_delay();
-  val = i2c_read_sda();
-  i2c_delay();
-  i2c_clear_scl();
-  return val;
-}
-
-static uint8_t i2c_write_byte(uint8_t b)
-{
-  i2c_write_bit(b & 128);
-  i2c_write_bit(b & 64);
-  i2c_write_bit(b & 32);
-  i2c_write_bit(b & 16);
-  i2c_write_bit(b & 8);
-  i2c_write_bit(b & 4);
-  i2c_write_bit(b & 2);
-  i2c_write_bit(b & 1);
-    
-  /* read ack from client */
-  /* 0: ack was given by client */
-  /* 1: nothing happend during ack cycle */  
-  return i2c_read_bit();
-}
-
-
-
-void u8g_i2c_init(uint8_t options)
-{
-  u8g_i2c_opt = options;
-  u8g_i2c_clear_error();
-
-  if ( u8g_i2c_opt & U8G_I2C_OPT_FAST )
-  {
-    i2c_delay = i2c_400KHz_delay;
-  }
-  else
-  {
-    i2c_delay = i2c_100KHz_delay;
-  }
-
-
-  if ( u8g_i2c_opt & U8G_I2C_OPT_DEV_1 )
-  {
-    i2c_scl_pin = PIN_WIRE1_SCL;
-    i2c_sda_pin = PIN_WIRE1_SDA;
-    
-    //REG_PIOA_PDR = PIO_PB12A_TWD1 | PIO_PB13A_TWCK1;
-  }
-  else
-  {    
-    
-    i2c_scl_pin = PIN_WIRE_SCL;
-    i2c_sda_pin = PIN_WIRE_SDA;
-    
-    //REG_PIOA_PDR = PIO_PA17A_TWD0 | PIO_PA18A_TWCK0;
-  }
-  
-  i2c_init();
-
-}
-
-/* sla includes also the r/w bit */
-uint8_t u8g_i2c_start(uint8_t sla)
-{  
-  i2c_start();
-  i2c_write_byte(sla);
-  return 1;
-}
-
-uint8_t u8g_i2c_send_byte(uint8_t data)
-{
-  return i2c_write_byte(data);
-}
-
-void u8g_i2c_stop(void)
-{
-  i2c_stop();
-}
-
-
-#elif defined(U8G_RASPBERRY_PI)
-
-#include <wiringPi.h>
-#include <wiringPiI2C.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-
-#define I2C_SLA         0x3c
-
-static int fd=-1;
-static uint8_t i2cMode = 0;
-
-void u8g_i2c_init(uint8_t options) {
-   u8g_i2c_clear_error();
-   u8g_i2c_opt = options;
-
-   if (wiringPiSetup() == -1) {
-      printf("wiringPi-Error\n");
-      exit(1);
-   }
-
-   fd = wiringPiI2CSetup(I2C_SLA);
-   if (fd < 0) {
-      printf ("Unable to open I2C device 0: %s\n", strerror (errno)) ;
-      exit (1) ;
-   }
-   //u8g_SetPIOutput(u8g, U8G_PI_RESET);
-   //u8g_SetPIOutput(u8g, U8G_PI_A0);
-}
-uint8_t u8g_i2c_start(uint8_t sla) {
-   u8g_i2c_send_mode(0);
-
-   return 1;
-}
-
-void u8g_i2c_stop(void) {
-}
-
-uint8_t u8g_i2c_send_mode(uint8_t mode) {
-   i2cMode = mode;
-} 
-
-uint8_t u8g_i2c_send_byte(uint8_t data) {
-   wiringPiI2CWriteReg8(fd, i2cMode, data);
-
-   return 1;
-}
-
-uint8_t u8g_i2c_wait(uint8_t mask, uint8_t pos)
-{
-  return 1;
-}
-
-#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
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_io.c

@@ -1,452 +0,0 @@
-/*
-  
-  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.  
-
-  Update for ATOMIC operation done (01 Jun 2013)
-    U8G_ATOMIC_OR(ptr, val)
-    U8G_ATOMIC_AND(ptr, val)
-    U8G_ATOMIC_START();
-    U8G_ATOMIC_END();
-
-  uint8_t u8g_Pin(uint8_t port, uint8_t bitpos)						Convert to internal number: AVR: port*8+bitpos, ARM: port*16+bitpos
-  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)
-
-
-*/
-
-#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;
-}
-
-#if defined(__AVR_XMEGA__)
-
-const IO_PTR u8g_avr_ddr_P[] PROGMEM = {
-#ifdef PORTA
-  &PORTA.DIR,
-#else
-  0,
-#endif
-  &PORTB.DIR,
-#ifdef PORTC
-  &PORTC.DIR,
-#ifdef PORTD
-  &PORTD.DIR,
-#ifdef PORTE
-  &PORTE.DIR,
-#ifdef PORTF
-  &PORTF.DIR,
-#ifdef PORTR
-  &PORTR.DIR,
-#endif
-#endif
-#endif
-#endif
-#endif
-};
-
-
-const IO_PTR u8g_avr_port_P[] PROGMEM = {
-#ifdef PORTA
-  &PORTA.OUT,
-#else
-  0,
-#endif
-  &PORTB.OUT,
-#ifdef PORTC
-  &PORTC.OUT,
-#ifdef PORTD
-  &PORTD.OUT,
-#ifdef PORTE
-  &PORTE.OUT,
-#ifdef PORTF
-  &PORTF.OUT,
-#ifdef PORTR
-  &PORTR.OUT,
-#endif
-#endif
-#endif
-#endif
-#endif
-};
-
-const IO_PTR u8g_avr_pin_P[] PROGMEM = {
-#ifdef PORTA
-  &PORTA.IN,
-#else
-  0,
-#endif
-  &PORTB.IN,
-#ifdef PORTC
-  &PORTC.IN,
-#ifdef PORTD
-  &PORTD.IN,
-#ifdef PORTE
-  &PORTE.IN,
-#ifdef PORTF
-  &PORTF.IN,
-#ifdef PORTR
-  &PORTR.IN,
-#endif
-#endif
-#endif
-#endif
-#endif
-};
-
-
-#else
-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
-};
-#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 )
-  {
-    U8G_ATOMIC_AND(tmp, ~_BV(internal_pin_number&7));
-   // *tmp &= ~_BV(internal_pin_number&7);
-  }
-  else
-  {
-    U8G_ATOMIC_OR(tmp, _BV(internal_pin_number&7));
-    //*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;
-}
-
-#elif defined (__MSP430__)
-#include <msp430.h>
-
-typedef volatile uint8_t * IO_PTR;
-
-// MSP430 F5XXX / F6XXX series. 
-const IO_PTR u8g_msp_ddr_P[] PROGMEM = {
-	&P1DIR
-	,&P2DIR
-	,&P3DIR
-	,&P4DIR
-	,&P5DIR
-	,&P6DIR
-	,&P7DIR
-	,&P8DIR
-#if defined (__MSP430_HAS_PORT9_R__)
-	,&P9DIR
-#if defined (__MSP430_HAS_PORT10_R__)
-	,&P10DIR
-#endif
-#endif
-};
-
-const IO_PTR u8g_msp_port_P[] PROGMEM = {
-	&P1OUT
-	,&P2OUT
-	,&P3OUT
-	,&P4OUT
-	,&P5OUT
-	,&P6OUT
-	,&P7OUT
-	,&P8OUT
-#if defined (__MSP430_HAS_PORT9_R__)
-	,&P9OUT
-#if defined (__MSP430_HAS_PORT10_R__)
-	,&P10OUT
-#endif
-#endif
-};
-
-const IO_PTR u8g_msp_pin_P[] PROGMEM = {
-	&P1IN
-	,&P2IN
-	,&P3IN
-	,&P4IN
-	,&P5IN
-	,&P6IN
-	,&P7IN
-	,&P8IN
-#if defined (__MSP430_HAS_PORT9_R__)
-	,&P9IN
-#if defined (__MSP430_HAS_PORT10_R__)
-	,&P10IN
-#endif
-#endif
-};
-
-uint8_t u8g_Pin(uint8_t port, uint8_t bitpos)
-{
-	port <<= 3;
-	port += bitpos;
-	return port;
-}
-
-void u8g_SetPinOutput(uint8_t internal_pin_number)
-{
-	uint8_t port = (internal_pin_number >> 3)-1;
-	uint8_t output = 1 << (internal_pin_number & 0x07);
-	*u8g_msp_ddr_P[port] |= output;
-}
-
-void u8g_SetPinInput(uint8_t internal_pin_number)
-{
-	uint8_t port = (internal_pin_number >> 3)-1;
-	*u8g_msp_ddr_P[port] &= ~(1 << (internal_pin_number & 0x07));
-}
-
-void u8g_SetPinLevel(uint8_t internal_pin_number, uint8_t level)
-{
-	uint8_t port = (internal_pin_number >> 3)-1;
-	if (level == 0)
-	{
-		*u8g_msp_port_P[port] &= ~(1 << (internal_pin_number & 0x07));
-	}
-	else
-	{
-		*u8g_msp_port_P[port]|= (1 << (internal_pin_number & 0x07));
-	}
-}
-
-uint8_t u8g_GetPinLevel(uint8_t internal_pin_number)
-{
-	uint8_t port = (internal_pin_number >> 3)-1;
-	uint8_t tmp = *u8g_msp_pin_P[port];
-	if (tmp & (1 << (internal_pin_number & 0x07)))
-	{
-		return 1;
-	}
-	return 0;
-}
-
-#elif defined(U8G_RASPBERRY_PI)
-
-#include <wiringPi.h>
-//#include "/usr/local/include/wiringPi.h"
-
-void u8g_SetPinOutput(uint8_t internal_pin_number) {
-   pinMode(internal_pin_number, OUTPUT);
-}
-
-void u8g_SetPinInput(uint8_t internal_pin_number) {
-   pinMode(internal_pin_number, INPUT);
-}
-
-void u8g_SetPinLevel(uint8_t internal_pin_number, uint8_t level) {
-   digitalWrite(internal_pin_number, level);
-}
-
-uint8_t u8g_GetPinLevel(uint8_t internal_pin_number) {
-   return digitalRead(internal_pin_number);
-}
-
-
-#else
-
-/* convert "port" and "bitpos" to internal pin number */
-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
-
-
-#if defined(U8G_WITH_PINLIST)
-
-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);
-}
-
-#else  /* defined(U8G_WITH_PINLIST) */
-void u8g_SetPIOutput(u8g_t *u8g, uint8_t pi)
-{
-}
-
-void u8g_SetPILevel(u8g_t *u8g, uint8_t pi, uint8_t level)
-{
-}
-
-#endif /* defined(U8G_WITH_PINLIST) */

.piolibdeps/U8glib_ID7/src/clib/u8g_com_linux_ssd_i2c.c

@@ -1,168 +0,0 @@
-/*
-
-  u8g_com_linux_ssd_i2c.c
-
-  com interface for linux i2c-dev and the SSDxxxx chip (SOLOMON) variant
-  I2C protocol
-
-
-  Universal 8bit Graphics Library
-
-  Copyright (c) 2012, olikraus@gmail.com
-  Copyright (c) 2015, daniel@redfelineninja.org.uk
-  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(U8G_LINUX)
-
-#include <errno.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <linux/i2c-dev.h>
-
-
-#define I2C_SLA		0x3c
-#define I2C_CMD_MODE	0x80
-#define I2C_DATA_MODE	0x40
-#define MAX_PACKET      64
-
-#ifndef U8G_WITH_PINLIST
-#error U8G_WITH_PINLIST is mandatory for this driver
-#endif
-
-static void set_cmd_mode(u8g_t *u8g, bool cmd_mode)
-{
-  u8g->pin_list[U8G_PI_A0_STATE] = cmd_mode;
-}
-
-static bool get_cmd_mode(u8g_t *u8g)
-{
-  return u8g->pin_list[U8G_PI_A0_STATE];
-}
-
-static uint8_t send_data_burst(u8g_t *u8g, int fd, uint8_t *buf, size_t buflen)
-{
-  uint8_t i2cbuf[2*MAX_PACKET];
-  uint8_t i2clen;
-  int res;
-
-  /* ignore bursts when there is no file open */
-  if (fd < 0)
-	  return 0;
-
-  if (get_cmd_mode(u8g)) {
-    i2clen = 0;
-    while (buflen > 0) {
-      i2cbuf[i2clen++] = I2C_CMD_MODE;
-      i2cbuf[i2clen++] = *buf++;
-      buflen--;
-    }
-  } else {
-    i2cbuf[0] = I2C_DATA_MODE;
-    memcpy(i2cbuf+1, buf, buflen);
-    i2clen = buflen + 1;
-  }
-
-  res = write(fd, i2cbuf, i2clen);
-  if (res < 0)
-    fprintf(stderr, "I2C write failed (%s)\n", strerror(errno));
-  else if (res != i2clen)
-    fprintf(stderr, "Incomplete I2C write (%d of %d packet)\n", res, i2clen);
-
-  return res == i2clen;
-}
-
-uint8_t u8g_com_linux_ssd_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-{
-  static int fd = -1;
-  char dev[24];
-
-  switch(msg)
-  {
-    case U8G_COM_MSG_INIT:
-      sprintf(dev, "/dev/i2c-%d", u8g->pin_list[U8G_PI_I2C_OPTION]);
-      fd = open(dev, O_RDWR);
-      if (fd < 0) {
-	fprintf(stderr, "cannot open %s (%s)\n", dev, strerror(errno));
-	return 0;
-      }
-
-      if (ioctl(fd, I2C_SLAVE, I2C_SLA) < 0) {
-	fprintf(stderr, "cannot set slave address (%s)\n", strerror(errno));
-	return 0;
-      }
-
-      break;
-
-    case U8G_COM_MSG_STOP:
-      /* ignored - i2c-dev will automatically stop between writes */
-      break;
-
-    case U8G_COM_MSG_RESET:
-      /* ignored - no obvious means to reset an SSD via I2C */
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      set_cmd_mode(u8g, true);
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      send_data_burst(u8g, fd, &arg_val, 1);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ:
-    case U8G_COM_MSG_WRITE_SEQ_P:	/* no progmem in Linux */
-      while (arg_val > MAX_PACKET) {
-	send_data_burst(u8g, fd, arg_ptr, MAX_PACKET);
-	arg_ptr += MAX_PACKET;
-	arg_val -= MAX_PACKET;
-      }
-      send_data_burst(u8g, fd, arg_ptr, arg_val);
-      break;
-
-    case U8G_COM_MSG_ADDRESS:
-      /* choose cmd (arg_val = 0) or data mode (arg_val = 1) */
-      set_cmd_mode(u8g, !arg_val);
-      break;
-  }
-
-  return 1;
-}
-
-#endif /* U8G_LINUX */

.piolibdeps/U8glib_ID7/src/clib/u8g_com_msp430_hw_spi.c

@@ -1,221 +0,0 @@
-/*
-  
-  u8g_com_msp430_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.  
- 
-*/ 
- 
-#include "u8g.h"
-
-#if defined(__MSP430__)
-#define U8G_MSP430_HW_SPI
-#endif
-
-#if defined(U8G_MSP430_HW_SPI)
-
-#include <msp430.h>
-
-#ifndef F_CPU
-#error "Please specifiy actual master clock using F_CPU in HZ"
-#endif
-#ifndef F_SPI
-#define F_SPI  1000000UL
-#endif
-
-#define U8G_USE_USCIA0	1
-#define U8G_USE_USCIB0	2
-#define U8G_USE_USCIA1	3
-#define U8G_USE_USCIB1	4
-#define U8G_USE_USCIA2	5
-#define U8G_USE_USCIB2	6
-#define U8G_USE_USCIA3	7
-#define U8G_USE_USCIB3	8
-
-#ifndef U8G_USE_USCI
-#define U8G_USE_USCI	U8G_USE_USCIB0
-#endif
-
-#if U8G_USE_USCI == 1
-#define UCIFG	UCA0IFG
-#define UCTXBUF UCA0TXBUF
-#define UCSTAT  UCA0STAT
-#define UCCTL0  UCA0CTL0
-#define UCCTL1  UCA0CTL1
-#define UCBR0   UCA0BR0
-#define UCBR1   UCA0BR1
-#elif U8G_USE_USCI == 2
-#define UCIFG	UCB0IFG
-#define UCTXBUF UCB0TXBUF
-#define UCSTAT  UCB0STAT
-#define UCCTL0  UCB0CTL0
-#define UCCTL1  UCB0CTL1
-#define UCBR0   UCB0BR0
-#define UCBR1   UCB0BR1
-#elif U8G_USE_USCI == 3
-#define UCIFG	UCA1IFG
-#define UCTXBUF UCA1TXBUF
-#define UCSTAT  UCA1STAT
-#define UCCTL0  UCA1CTL0
-#define UCCTL1  UCA1CTL1
-#define UCBR0   UCA1BR0
-#define UCBR1   UCA1BR1
-#elif U8G_USE_USCI == 4
-#define UCIFG	UCB1IFG
-#define UCTXBUF UCB1TXBUF
-#define UCSTAT  UCB1STAT
-#define UCCTL0  UCB1CTL0
-#define UCCTL1  UCB1CTL1
-#define UCBR0   UCB1BR0
-#define UCBR1   UCB1BR1
-#elif U8G_USE_USCI == 5
-#define UCIFG	UCA2IFG
-#define UCTXBUF UCA2TXBUF
-#define UCSTAT  UCA2STAT
-#define UCCTL0  UCA2CTL0
-#define UCCTL1  UCA2CTL1
-#define UCBR0   UCA2BR0
-#define UCBR1   UCA2BR1
-#elif U8G_USE_USCI == 6
-#define UCIFG	UCB2IFG
-#define UCTXBUF UCB2TXBUF
-#define UCSTAT  UCB2STAT
-#define UCCTL0  UCB2CTL0
-#define UCCTL1  UCB2CTL1
-#define UCBR0   UCB2BR0
-#define UCBR1   UCB2BR1
-#elif U8G_USE_USCI == 7
-#define UCIFG	UCA3IFG
-#define UCTXBUF UCA3TXBUF
-#define UCSTAT  UCA3STAT
-#define UCCTL0  UCA3CTL0
-#define UCCTL1  UCA3CTL1
-#define UCBR0   UCA3BR0
-#define UCBR1   UCA3BR1
-#elif U8G_USE_USCI == 8
-#define UCIFG	UCB3IFG
-#define UCTXBUF UCB3TXBUF
-#define UCSTAT  UCB3STAT
-#define UCCTL0  UCB3CTL0
-#define UCCTL1  UCB3CTL1
-#define UCBR0   UCB3BR0
-#define UCBR1   UCB3BR1
-#endif
-
-inline void u8g_msp430_spi_out(uint8_t data)
-{
-  while (!(UCIFG&UCTXIFG));
-  UCTXBUF = data;
-}
-
-uint8_t u8g_com_msp430_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:
-	/*
- 	 * on MSP430 you need to set PSEL alternative function which
- 	 * may not be required on other MCU's - should be handled
- 	 * by a low level u8g_SetPinAlternate(pin_number)...
- 	 */
-      UCCTL1 |= UCSWRST;                      // **Put state machine in reset**
-      UCCTL0 |= UCMST|UCSYNC|UCCKPL|UCMSB;    // 3-pin, 8-bit SPI master Clock polarity high, MSB
-      UCCTL1 |= UCSSEL_2;                     // SMCLK
-      UCBR0 = (unsigned char)(F_CPU/F_SPI);   // 
-      UCBR1 = 0;                              //
-      UCCTL1 &= ~UCSWRST;                     // **Initialize USCI state machine**
-      u8g_SetPILevel(u8g, U8G_PI_CS, 1);
-      u8g_SetPILevel(u8g, U8G_PI_A0, 1);
-      u8g_SetPILevel(u8g, U8G_PI_RESET, 1);
-      u8g_SetPIOutput(u8g, U8G_PI_CS);
-      u8g_SetPIOutput(u8g, U8G_PI_A0);
-      u8g_SetPIOutput(u8g, U8G_PI_RESET);
-
-      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:
-      
-       u8g_SetPILevel(u8g, U8G_PI_CS, (arg_val ? 0 : 1));
-      break;
-      
-    case U8G_COM_MSG_RESET:
-
-      u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
-      break;
-    
-    case U8G_COM_MSG_WRITE_BYTE:
-      u8g_msp430_spi_out(arg_val);
-      while ((UCSTAT&UCBUSY));
-      break;
-    
-    case U8G_COM_MSG_WRITE_SEQ:
-      {
-        register uint8_t *ptr = arg_ptr;
-        while( arg_val > 0 )
-        {
-          u8g_msp430_spi_out(*ptr++);
-          arg_val--;
-        }
-        while ((UCSTAT&UCBUSY));
-      }
-      break;
-    case U8G_COM_MSG_WRITE_SEQ_P:
-      {
-        register uint8_t *ptr = arg_ptr;
-        while( arg_val > 0 )
-        {
-          u8g_msp430_spi_out(u8g_pgm_read(ptr));
-          ptr++;
-          arg_val--;
-        }
-        while ((UCSTAT&UCBUSY));
-      }
-      break;
-  }
-  return 1;
-}
-
-#else
-
-uint8_t u8g_com_msp430_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-{
-  return 1;
-}
-
-#endif
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_null.c

@@ -1,63 +0,0 @@
-/*
-
-  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;
-}
-

.piolibdeps/U8glib_ID7/src/clib/u8g_com_psoc5_ssd_hw_parallel.c

@@ -1,107 +0,0 @@
-/*
-  
-  u8g_com_psoc5_ssd_hw_parallel.c
-
-  com interface for Cypress PSoC5 and the SSDxxxx chip variant
-  I2C protocol
-
-  Universal 8bit Graphics Library
-  
-  Copyright (c) 2015, olikraus@gmail.com, schmidt.ronny@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(U8G_CYPRESS_PSOC5)
-  
-#include <project.h>   
-
-static uint8 dc = 0; // need to store whether next write is data or command
-  
-uint8_t u8g_com_psoc5_ssd_hw_parallel_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-{
-  switch(msg)
-  {
-    case U8G_COM_MSG_STOP:
-      // stop the device
-      GraphicLCDIntf_Stop();
-      break;
-    
-    case U8G_COM_MSG_INIT:
-  		// init hardware interfaces, timers, gpios, ...
-      GraphicLCDIntf_Init();
-      break;
-    
-    case U8G_COM_MSG_ADDRESS:                     
-      // switch from cmd (arg_val = 0) to data mode (arg_val = 1) or vice versa
-      dc = arg_val;
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-		  /* done by the hardware */
-      break;
-      
-    case U8G_COM_MSG_RESET:
-      // toggle the reset pin of the display by value in arg_val
-      nRES_Write(0);
-      u8g_10MicroDelay();
-      nRES_Write(1);
-      break;
-    
-    case U8G_COM_MSG_WRITE_BYTE:
-      // write byte to the device
-		  GraphicLCDIntf_Write8(dc, arg_val);
-      break;
-    
-    case U8G_COM_MSG_WRITE_SEQ:
-    case U8G_COM_MSG_WRITE_SEQ_P:
-      {
-        // write a sequence of bytes to the device
-        register uint8_t *ptr = arg_ptr;
-        while (arg_val-- > 0)
-        {
-          GraphicLCDIntf_Write8(dc, *ptr++);
-        }
-      }
-      break;
-      
-
-  }
-  return 1;
-}
-
-#else
-
-uint8_t u8g_com_psoc5_ssd_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-{
-  return 1;
-}
-
-#endif

.piolibdeps/U8glib_ID7/src/clib/u8g_com_std_sw_spi.c

@@ -1,140 +0,0 @@
-/*
-  
-  u8g_com_std_sw_spi.c
-
-  Universal 8bit Graphics Library
-  
-  Copyright (c) 2015, 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(U8G_WITH_PINLIST)
-
-static void u8g_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val)
-{
-  uint8_t i = 8;
-  do
-  {
-    if ( val & 128 )
-      u8g_SetPinLevel(dataPin, 1);
-    else
-      u8g_SetPinLevel(dataPin, 0);
-    val <<= 1;
-    u8g_MicroDelay();		/* 23 Sep 2012 */
-    //delay(1);
-    u8g_SetPinLevel(clockPin, 1);
-    u8g_MicroDelay();		/* 23 Sep 2012 */
-    //delay(1);
-    u8g_SetPinLevel(clockPin, 0);
-    u8g_MicroDelay();		/* 23 Sep 2012 */
-    //delay(1);
-    i--;
-  } while( i != 0 );
-}
-
-uint8_t u8g_com_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_SetPIOutput(u8g, U8G_PI_SCK);
-      u8g_SetPIOutput(u8g, U8G_PI_MOSI);
-      u8g_SetPIOutput(u8g, U8G_PI_RESET);
-      u8g_SetPIOutput(u8g, U8G_PI_CS);
-      u8g_SetPIOutput(u8g, U8G_PI_A0);
-      u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
-      u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
-      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_CHIP_SELECT:
-      if ( arg_val == 0 )
-      {
-        /* disable */
-	u8g_SetPILevel(u8g, U8G_PI_CS, 1);
-      }
-      else
-      {
-        /* enable */
-	u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
-	u8g_SetPILevel(u8g, U8G_PI_CS, 0);
-      }
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      u8g_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_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_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_SetPILevel(u8g, U8G_PI_A0, arg_val);
-      break;
-  }
-  return 1;
-}
-
-#else
-
-
-uint8_t u8g_com_std_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr)
-{
-  return 1;
-}
-
-
-#endif

.piolibdeps/U8glib_ID7/src/clib/u8g_cursor.c

@@ -1,99 +0,0 @@
-/*
-
-  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); 
-}
-

.piolibdeps/U8glib_ID7/src/clib/u8g_delay.c

@@ -1,323 +0,0 @@
-/*
-
-  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.  
-
-
-  void u8g_Delay(uint16_t val)		Delay by "val" milliseconds
-  void u8g_MicroDelay(void)		Delay be one microsecond
-  void u8g_10MicroDelay(void)	Delay by 10 microseconds
-
-  
-*/
-
-
-#include "u8g.h"
-
-/*==== Part 1: Derive suitable delay procedure ====*/
-
-#if defined(ARDUINO)
-
-#  if ARDUINO < 100 
-#    include <WProgram.h> 
-#  else 
-#    include <Arduino.h> 
-#  endif
-
-/* issue 353 */
-#if defined(ARDUINO_ARCH_SAMD)
-#    include <delay.h>
-#endif
-
-#  if defined(__AVR__)
-#    define USE_AVR_DELAY
-#  elif defined(__PIC32MX)
-#    define USE_PIC32_DELAY
-#  elif defined(__arm__)		/* Arduino Due & Teensy */
-#    define USE_ARDUINO_DELAY
-#  else
-#    define USE_ARDUINO_DELAY
-#  endif
-#elif defined(_GNU_SOURCE)
-#  define USE_LINUX_DELAY
-#elif defined(__MSP430__)
-#  define USE_MSP430_DELAY
-#elif defined(U8G_RASPBERRY_PI)
-#  define USE_RASPBERRYPI_DELAY
-#elif defined(__AVR__)
-#  define USE_AVR_DELAY
-#elif defined(__18CXX)
-#  define USE_PIC18_DELAY
-#elif defined(U8G_CYPRESS_PSOC5)
-#define USE_PSOC5_DELAY
-#elif defined(__arm__)
-/* do not define anything, all procedures are expected to be defined outside u8glib */
-
-/*
-void u8g_Delay(uint16_t val);
-void u8g_MicroDelay(void);
-void u8g_10MicroDelay(void);
-*/
-
-#else
-#  define USE_DUMMY_DELAY
-#endif
-
-
-
-/*==== Part 2: Definition of the delay procedures ====*/
-
-/*== Raspberry Pi Delay ==*/
-#if defined (USE_RASPBERRYPI_DELAY)
-#include <wiringPi.h>
-//#include "/usr/local/include/wiringPi.h"
-void u8g_Delay(uint16_t val) {
-   //delay(val);
-   //usleep((uint32_t)val*(uint32_t)1000);
-   delayMicroseconds((uint32_t)val*(uint32_t)1000);
-}
-void u8g_MicroDelay(void)
-{
-   usleep(1);
-}
-void u8g_10MicroDelay(void)
-{
-   usleep(10);
-}
-#endif
-
-#if defined(USE_LINUX_DELAY)
-void u8g_Delay(uint16_t val) {
-   //delay(val);
-   usleep((uint32_t)val*(uint32_t)1000);
-}
-void u8g_MicroDelay(void)
-{
-   usleep(1);
-}
-void u8g_10MicroDelay(void)
-{
-   usleep(10);
-}
-#endif
-
-
-
-/*== 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)
-{
-#if defined(__arm__)
-	delayMicroseconds((uint32_t)val*(uint32_t)1000);
-#else
-	delay(val);
-#endif
-}
-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
-
-#if defined(USE_MSP430_DELAY)
-#include <msp430.h>
-
-#ifndef F_CPU
-#define F_CPU 1000000UL
-#endif
-
-
-void u8g_Delay(uint16_t val)
-{
-  int t;
-  for (t=0; t < val; t++)
-  {
-    __delay_cycles(F_CPU/1000UL);
-  }
-}
-void u8g_MicroDelay(void)
-{
-  __delay_cycles(F_CPU/1000000UL);
-}
-
-void u8g_10MicroDelay(void)
-{
-  __delay_cycles(F_CPU/100000UL);
-}
-#endif
-#if defined USE_PSOC5_DELAY
-  #include <project.h>
-  void u8g_Delay(uint16_t val)  {CyDelay(val);};
-  void u8g_MicroDelay(void)     {CyDelay(1);};
-  void u8g_10MicroDelay(void)   {CyDelay(10);};  
-#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

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_flipdisc_2x7.c

@@ -1,92 +0,0 @@
-/*
-
-  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, (uint8_t *)(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 };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_gprof.c

@@ -1,130 +0,0 @@
-/*
-
-  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_ENTRY:
-      break;
-    case U8G_DEV_MSG_SET_XY_CB:
-      break;
-  }
-  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
-}

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ili9325d_320x240.c

@@ -1,326 +0,0 @@
-/*
-
-  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, U8G_SPI_CLK_CYCLE_50NS);
-      //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);
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ks0108_128x64.c

@@ -1,110 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_NONE);
-      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);
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_lc7981_160x80.c

@@ -1,147 +0,0 @@
-/*
-
-  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 */
-  0x050,                                /* Oct 2015: Changed from 7f to 50 (1/80 duty cycle) */
-
-  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_SPI_CLK_CYCLE_NONE);
-      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);
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_lc7981_240x128.c

@@ -1,145 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_NONE);
-      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);
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_lc7981_240x64.c

@@ -1,145 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_NONE);
-      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);
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_lc7981_320x64.c

@@ -1,151 +0,0 @@
-/*
-
-  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"
-
-#ifdef U8G_16BIT
-#define WIDTH 320
-#else
-#define WIDTH 240
-#endif
-
-#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_SPI_CLK_CYCLE_NONE);
-      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);
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_null.c

@@ -1,67 +0,0 @@
-/*
-
-  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_ENTRY:
-      break;
-    case U8G_DEV_MSG_SET_XY_CB:
-      break;
-  }
-  return 1;
-}

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_pcd8544_84x48.c

@@ -1,141 +0,0 @@
-/*
-
-  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 */
-};
-
-
-static const uint8_t u8g_dev_pcd8544_sleep_on[] PROGMEM = {
-  U8G_ESC_ADR(0),           	/* instruction mode */
-  U8G_ESC_CS(1),             	/* enable chip */
-  
-  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
-  0x00c,		                /* display on, normal */
-  U8G_ESC_CS(0),             	/* disable chip, bugfix 12 nov 2014 */
-  U8G_ESC_END                	/* end of sequence */
-};
-
-static const uint8_t u8g_dev_pcd8544_sleep_off[] PROGMEM = {
-  U8G_ESC_ADR(0),           	/* instruction mode */
-  U8G_ESC_CS(1),             	/* enable chip */
-  0x020,		                /* activate chip (PD=0), horizontal increment (V=0), enter normal command set (H=0) */
-  0x008,		                /* display blank */
-  0x024,		                /* power down (PD=1), horizontal increment (V=0), enter normal command set (H=0) */
-  
-  U8G_ESC_DLY(50),       	/* delay 50 ms */
-  U8G_ESC_CS(0),             	/* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_400NS);
-      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;
-    case U8G_DEV_MSG_SLEEP_ON:
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_pcd8544_sleep_on);    
-      return 1;
-    case U8G_DEV_MSG_SLEEP_OFF:
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_pcd8544_sleep_off);    
-      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);
-U8G_PB_DEV(u8g_dev_pcd8544_84x48_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_pcd8544_fn, U8G_COM_HW_SPI);
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_pcf8812_96x65.c

@@ -1,138 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_400NS);
-      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;
-
-	  /*  mirrored output, not tested*/
-	/*
-	{
-	  uint8_t i = pb->width;
-	  while( i > 0 )
-	  {
-	    i--;
-	    u8g_WriteByte(u8g, dev, ((unsigned char *)pb->buf)[i] );
-	  }
-	}
-	*/
-	
-	
-        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);
-U8G_PB_DEV(u8g_dev_pcf8812_96x65_hw_spi , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_pcf8812_fn, U8G_COM_HW_SPI);

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_sbn1661_122x32.c

@@ -1,107 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_NONE);
-      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);

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1306_128x32.c

@@ -1,303 +0,0 @@
-/*
-
-  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,  128x32 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,  128x32 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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_300NS);
-      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_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) ); /* 11 Jul 2015: fixed contrast calculation */
-      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);
-}
-
-uint8_t u8g_dev_ssd1306_128x32_2x_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_SPI_CLK_CYCLE_300NS);
-      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*2));	/* select current page (SSD1306) */
-        u8g_SetAddress(u8g, dev, 1);					/* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x32_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2+1));	/* select current page (SSD1306) */
-        u8g_SetAddress(u8g, dev, 1);					/* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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) ); /* 11 Jul 2015: fixed contrast calculation */
-      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_pb16v1_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);
-
-uint8_t u8g_dev_ssd1306_128x32_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_ssd1306_128x32_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1306_128x32_2x_buf}; 
-u8g_dev_t u8g_dev_ssd1306_128x32_2x_sw_spi = { u8g_dev_ssd1306_128x32_2x_fn, &u8g_dev_ssd1306_128x32_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_ssd1306_128x32_2x_hw_spi = { u8g_dev_ssd1306_128x32_2x_fn, &u8g_dev_ssd1306_128x32_2x_pb, U8G_COM_HW_SPI };
-u8g_dev_t u8g_dev_ssd1306_128x32_2x_i2c = { u8g_dev_ssd1306_128x32_2x_fn, &u8g_dev_ssd1306_128x32_2x_pb, U8G_COM_SSD_I2C };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1306_128x64.c

@@ -1,457 +0,0 @@
-/*
-
-  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
-// 26. Apr 2014: in this thead: http://forum.arduino.cc/index.php?topic=234930.msg1696754;topicseen#msg1696754
-// it is mentiond, that adafruit2_init_seq works better --> this will be used by the ssd1306_adafruit device
-//#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 0  */
-  U8G_ESC_END                /* end of sequence */
-};
-
-/* the sh1106 is compatible to the ssd1306, but is 132x64. display seems to be centered */
-static const uint8_t u8g_dev_sh1106_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 */
-  0x002,		/* set lower 4 bit of the col adr to 2 (centered display with sh1106)  */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_300NS);
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x64_adafruit2_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;
-    case U8G_DEV_MSG_CONTRAST:
-    {
-	u8g_SetChipSelect(u8g, dev, 1);
-	u8g_SetAddress(u8g, dev, 0); /* instruction mode */
-	u8g_WriteByte(u8g, dev, 0x81);
-	u8g_WriteByte(u8g, dev, *(uint8_t *) arg);
-	u8g_SetChipSelect(u8g, dev, 0);
-	return 1;
-    }
-  }
-  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
-}
-
-uint8_t u8g_dev_ssd1306_adafruit_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_SPI_CLK_CYCLE_300NS);
-      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;
-    case U8G_DEV_MSG_CONTRAST:
-    {
-	u8g_SetChipSelect(u8g, dev, 1);
-	u8g_SetAddress(u8g, dev, 0); /* instruction mode */
-	u8g_WriteByte(u8g, dev, 0x81);
-	u8g_WriteByte(u8g, dev, *(uint8_t *) arg);
-	u8g_SetChipSelect(u8g, dev, 0);
-	return 1;
-    }
-  }
-  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
-}
-
-uint8_t u8g_dev_sh1106_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_SPI_CLK_CYCLE_300NS);
-      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_sh1106_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;
-    case U8G_DEV_MSG_CONTRAST:
-    {
-	u8g_SetChipSelect(u8g, dev, 1);
-	u8g_SetAddress(u8g, dev, 0); /* instruction mode */
-	u8g_WriteByte(u8g, dev, 0x81);
-	u8g_WriteByte(u8g, dev, *(uint8_t *) arg);
-	u8g_SetChipSelect(u8g, dev, 0);
-	return 1;
-    }
-  }
-  return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
-}
-
-
-uint8_t u8g_dev_ssd1306_128x64_2x_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_SPI_CLK_CYCLE_300NS);
-      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*2)); /* select current page (SSD1306) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_128x64_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2+1)); /* select current page (SSD1306) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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;
-    case U8G_DEV_MSG_CONTRAST:
-    {
-	u8g_SetChipSelect(u8g, dev, 1);
-	u8g_SetAddress(u8g, dev, 0); /* instruction mode */
-	u8g_WriteByte(u8g, dev, 0x81);
-	u8g_WriteByte(u8g, dev, *(uint8_t *) arg);
-	u8g_SetChipSelect(u8g, dev, 0);
-	return 1;
-    }
-  }
-  return u8g_dev_pb16v1_base_fn(u8g, dev, msg, arg);
-}
-
-uint8_t u8g_dev_sh1106_128x64_2x_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_SPI_CLK_CYCLE_300NS);
-      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_sh1106_128x64_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2)); /* select current page (SSD1306) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_128x64_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2+1)); /* select current page (SSD1306) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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;
-    case U8G_DEV_MSG_CONTRAST:
-    {
-	u8g_SetChipSelect(u8g, dev, 1);
-	u8g_SetAddress(u8g, dev, 0); /* instruction mode */
-	u8g_WriteByte(u8g, dev, 0x81);
-	u8g_WriteByte(u8g, dev, *(uint8_t *) arg);
-	u8g_SetChipSelect(u8g, dev, 0);
-	return 1;
-    }
-  }
-  return u8g_dev_pb16v1_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);
-
-U8G_PB_DEV(u8g_dev_ssd1306_adafruit_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_adafruit_128x64_fn, U8G_COM_SW_SPI);
-U8G_PB_DEV(u8g_dev_ssd1306_adafruit_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_adafruit_128x64_fn, U8G_COM_HW_SPI);
-U8G_PB_DEV(u8g_dev_ssd1306_adafruit_128x64_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_adafruit_128x64_fn, U8G_COM_SSD_I2C);
-
-
-uint8_t u8g_dev_ssd1306_128x64_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_ssd1306_128x64_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1306_128x64_2x_buf}; 
-u8g_dev_t u8g_dev_ssd1306_128x64_2x_sw_spi = { u8g_dev_ssd1306_128x64_2x_fn, &u8g_dev_ssd1306_128x64_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_ssd1306_128x64_2x_hw_spi = { u8g_dev_ssd1306_128x64_2x_fn, &u8g_dev_ssd1306_128x64_2x_pb, U8G_COM_HW_SPI };
-u8g_dev_t u8g_dev_ssd1306_128x64_2x_i2c = { u8g_dev_ssd1306_128x64_2x_fn, &u8g_dev_ssd1306_128x64_2x_pb, U8G_COM_SSD_I2C };
-
-
-U8G_PB_DEV(u8g_dev_sh1106_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_sh1106_128x64_fn, U8G_COM_SW_SPI);
-U8G_PB_DEV(u8g_dev_sh1106_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_sh1106_128x64_fn, U8G_COM_HW_SPI);
-U8G_PB_DEV(u8g_dev_sh1106_128x64_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_sh1106_128x64_fn, U8G_COM_SSD_I2C);
-
-uint8_t u8g_dev_sh1106_128x64_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_sh1106_128x64_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_sh1106_128x64_2x_buf}; 
-u8g_dev_t u8g_dev_sh1106_128x64_2x_sw_spi = { u8g_dev_sh1106_128x64_2x_fn, &u8g_dev_sh1106_128x64_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_sh1106_128x64_2x_hw_spi = { u8g_dev_sh1106_128x64_2x_fn, &u8g_dev_sh1106_128x64_2x_pb, U8G_COM_HW_SPI };
-u8g_dev_t u8g_dev_sh1106_128x64_2x_i2c = { u8g_dev_sh1106_128x64_2x_fn, &u8g_dev_sh1106_128x64_2x_pb, U8G_COM_SSD_I2C };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1306_64x48.c

@@ -1,201 +0,0 @@
-/*
-
-  u8g_dev_ssd1306_64x48.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 64
-#define HEIGHT 48
-#define PAGE_HEIGHT 8
-
-
-
-/* init sequence buydisplay.com 0.66" 64x48 OLED */
-/* http://www.buydisplay.com/download/manual/ER-OLED0.66-1_Series_Datasheet.pdf */
-static const uint8_t u8g_dev_ssd1306_64x48_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, 0x02f,			/* Multiplex Ration, Jul 12, 2015: From 0.66" OLED datasheet */
-
-  0x0d3, 0x000,			/*  */
-
-  0x040,				/* start line */
-  
-  0x08d, 0x014,			/* 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: 64x48 OLED: 0x002,  64x48 OLED 0x012 */
-  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), Jul 12, 2015: From 0.66" OLED datasheet */
-  0x081, 0x0cf,			/* set contrast control */
-  0x0d9, 0x022,			/* pre-charge period 0x022/f1, from 0.66" OLED datasheet */
-  0x0db, 0x000,			/* vcomh deselect level, from 0.66" OLED datasheet */
-  
-  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 */
-};
-
-
-
-
-static const uint8_t u8g_dev_ssd1306_64x48_data_start[] PROGMEM = {
-  U8G_ESC_ADR(0),       /* instruction mode */
-  U8G_ESC_CS(1),        /* enable chip */
-  0x010+2,				/* set upper 4 bit of the col adr. to 0, 0.66" OLED starts with offset 32 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  U8G_ESC_END                /* end of sequence */
-};
-
-uint8_t u8g_dev_ssd1306_64x48_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_SPI_CLK_CYCLE_300NS);
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_64x48_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_64x48_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) ); /* 11 Jul 2015: fixed contrast calculation */
-      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);
-}
-
-uint8_t u8g_dev_ssd1306_64x48_2x_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_SPI_CLK_CYCLE_300NS);
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_64x48_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_64x48_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2));	/* select current page (SSD1306) */
-        u8g_SetAddress(u8g, dev, 1);					/* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1306_64x48_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2+1));	/* select current page (SSD1306) */
-        u8g_SetAddress(u8g, dev, 1);					/* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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) ); /* 11 Jul 2015: fixed contrast calculation */
-      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_pb16v1_base_fn(u8g, dev, msg, arg);
-}
-
-U8G_PB_DEV(u8g_dev_ssd1306_64x48_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_64x48_fn, U8G_COM_SW_SPI);
-U8G_PB_DEV(u8g_dev_ssd1306_64x48_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_64x48_fn, U8G_COM_HW_SPI);
-U8G_PB_DEV(u8g_dev_ssd1306_64x48_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1306_64x48_fn, U8G_COM_SSD_I2C);
-
-uint8_t u8g_dev_ssd1306_64x48_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_ssd1306_64x48_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1306_64x48_2x_buf}; 
-u8g_dev_t u8g_dev_ssd1306_64x48_2x_sw_spi = { u8g_dev_ssd1306_64x48_2x_fn, &u8g_dev_ssd1306_64x48_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_ssd1306_64x48_2x_hw_spi = { u8g_dev_ssd1306_64x48_2x_fn, &u8g_dev_ssd1306_64x48_2x_pb, U8G_COM_HW_SPI };
-u8g_dev_t u8g_dev_ssd1306_64x48_2x_i2c = { u8g_dev_ssd1306_64x48_2x_fn, &u8g_dev_ssd1306_64x48_2x_pb, U8G_COM_SSD_I2C };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1309_128x64.c

@@ -1,142 +0,0 @@
-/*
-
-  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(0),             /* 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(0),             /* 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_SPI_CLK_CYCLE_300NS);
-      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) ); /* 11 Jul 2015: fixed contrast calculation */
-      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);

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1322_nhd31oled_bw.c

@@ -1,338 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_300NS);
-      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_MicroDelay();	// for DUE?
-	  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_MicroDelay();	// for DUE?
-      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_SPI_CLK_CYCLE_300NS);
-      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_MicroDelay();	// for DUE?	  
-	  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, 0x0c1);	/* 21 May 2013, fixed contrast command */
-      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);
-U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_bw_parallel , WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_ssd1322_nhd31oled_bw_fn, U8G_COM_FAST_PARALLEL);
-
-#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 };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1322_nhd31oled_gr.c

@@ -1,338 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_300NS);
-      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_MicroDelay();	// for DUE?
-	  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_MicroDelay();	// for DUE?
-      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_SPI_CLK_CYCLE_300NS);
-      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;    /* 23 Oct 2013, changed to 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_MicroDelay();	// for DUE?
-	  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, 4, u8g_dev_ssd1322_nhd31oled_gr_fn, U8G_COM_SW_SPI);
-U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_gr_hw_spi , WIDTH, HEIGHT, 4, u8g_dev_ssd1322_nhd31oled_gr_fn, U8G_COM_HW_SPI);
-U8G_PB_DEV(u8g_dev_ssd1322_nhd31oled_gr_parallel , WIDTH, HEIGHT, 4, u8g_dev_ssd1322_nhd31oled_gr_fn, U8G_COM_FAST_PARALLEL);
-
-
-#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 = { {8, 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 };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1325_nhd27oled_bw.c

@@ -1,263 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_300NS);
-      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_SPI_CLK_CYCLE_300NS);
-      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
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1325_nhd27oled_bw_new.c

@@ -1,232 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_300NS);
-      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_SPI_CLK_CYCLE_300NS);
-      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 };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1325_nhd27oled_gr.c

@@ -1,255 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_300NS);
-      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_SPI_CLK_CYCLE_300NS);
-      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 */

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1325_nhd27oled_gr_new.c

@@ -1,228 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_300NS);
-      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_SPI_CLK_CYCLE_300NS);
-      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);
-U8G_PB_DEV(u8g_dev_ssd1325_nhd27oled_gr_parallel , WIDTH, HEIGHT, 4, u8g_dev_ssd1325_nhd27oled_gr_fn, U8G_COM_FAST_PARALLEL);
-
-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 };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1327_96x96_gr.c

@@ -1,299 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_300NS);
-      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_SPI_CLK_CYCLE_300NS);
-      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 };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_ssd1353_160x128.c

@@ -1,425 +0,0 @@
-/*
-  u8g_dev_ssd1353_160x128.c
-
-  Universal 8bit Graphics Library
-  
-  Copyright (c) 2015, hugodan3@googlemail.com
-  Copyright (c) 2013, jamjardavies@gmail.com
-  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.  
-  
-  History:
-  Initial version	8 Mar 2015 hugodan3@googlemail.com. This version has
-			been derived from the ssd1351 driver by jamjarda. It has
-			been improved by in-lining time critical functions.
-
-   
-  
-*/
-
-#include "u8g.h"
-
-#define WIDTH		160
-#define HEIGHT		128
-#define PAGE_HEIGHT	8
-
-#define USE_GREY_TABLE	0
-
-static const uint8_t u8g_dev_ssd1353_160x128_init_seq[] PROGMEM = {
-	U8G_ESC_CS(0),					/* disable chip */
-	U8G_ESC_DLY(50),
-	U8G_ESC_ADR(0),					/* instruction mode */
-	U8G_ESC_RST(1),					/* do reset low pulse with (1*16)+2 milliseconds */
-	U8G_ESC_DLY(50),
-	U8G_ESC_CS(1),					/* enable chip */
-
-	0xFD,						/* Command unlock */
-	U8G_ESC_ADR(1),
-	0x12,						
-
-	U8G_ESC_ADR(0),					
-	0xAE,						/* Set Display Off */
-
-	U8G_ESC_ADR(0),			
-	0xA8,
-	U8G_ESC_ADR(1),
-	0x7F,						/* Set Multiplex Ratio */
-
-	U8G_ESC_ADR(0),			
-	0xA0,
-	U8G_ESC_ADR(1),
-	0xB4,						/* Set remapping */
-
-	U8G_ESC_ADR(0),		
-	0xA1,
-	U8G_ESC_ADR(1),
-	0x00,						/* Set Display Start Line */
-
-	U8G_ESC_ADR(0),	
-	0xA2,
-	U8G_ESC_ADR(1),
-	0x00,						/* Set Display Offset */
-
-	U8G_ESC_ADR(0),
-	0xB1,
-	U8G_ESC_ADR(1),
-	0x32,						/* Set Phase Length */
-
-	U8G_ESC_ADR(0),	
-	0xB4,
-	U8G_ESC_ADR(1),
-	0x04,						/* Set Second Precharge Period */
-
-	U8G_ESC_ADR(0),
-	0xA4,						/* Set Display Mode ON */
-
-	U8G_ESC_ADR(0),
-	0xB3,
-	U8G_ESC_ADR(1),					/* frame rate  */
-	0x40,
-	
-	U8G_ESC_ADR(0),	
-	0xBB,	
-	U8G_ESC_ADR(1),					/* pre-charge level */
-	0x08,
-
-	U8G_ESC_ADR(0),
-	0xBE,
-	U8G_ESC_ADR(1),					/* vcomh */
-	0x3C,
-
-	/* color adjustments */
-#if USE_GREY_TABLE != 1
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0x81,
-	U8G_ESC_ADR(1),
-	0xC8,							/* Set Contrast Color 1*/
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0x82,
-	U8G_ESC_ADR(1),
-	0x80,							/* Set Contrast Color 2*/
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0x83,
-	U8G_ESC_ADR(1),
-	0xF8,							/* Set Contrast Color 3*/
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0x87,
-	U8G_ESC_ADR(1),
-	0x09,							/* Set Master Contrast MAX */
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0xB9,							/* Set CMD Grayscale Linear */
-#else
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0x81,
-	U8G_ESC_ADR(1),
-	0xC8,							/* Set Contrast Color 1*/
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0x82,
-	U8G_ESC_ADR(1),
-	0xA0,							/* Set Contrast Color 2*/
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0x83,
-	U8G_ESC_ADR(1),
-	0xB0,							/* Set Contrast Color 3*/
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0x87,
-	U8G_ESC_ADR(1),
-	0x0F,							/* Set Master Contrast MAX */
-
-	U8G_ESC_ADR(0),					/* instruction mode */
-	0xB8,							/* Set CMD Grayscale Lookup */
-	U8G_ESC_ADR(1),
-	0x05, 0x06, 0x07, 0x08,
-	0x09, 0x0a, 0x0b, 0x0c,
-	0x0D, 0x0E, 0x0F, 0x10, 
-	0x11, 0x12, 0x13, 0x14, 
-	0x15, 0x16, 0x18, 0x1a,
-	0x1b, 0x1C, 0x1D, 0x1F, 
-	0x21, 0x23, 0x25, 0x27, 
-	0x2A, 0x2D, 0x30, 0x33, 
-	0x36, 0x39, 0x3C, 0x3F, 
-	0x42, 0x45, 0x48, 0x4C,
-	0x50, 0x54, 0x58, 0x5C,
-	0x60, 0x64, 0x68, 0x6C,
-	0x70, 0x74, 0x78, 0x7D,
-	0x82, 0x87, 0x8C, 0x91,
-	0x96, 0x9B, 0xA0, 0xA5,
-	0xAA, 0xAF, 0xB4, 
-#endif
-	U8G_ESC_ADR(0),
-	0xAF,							/* Set Display On */
-	U8G_ESC_CS(0),					/* disable chip */
-	U8G_ESC_ADR(1),
-	U8G_ESC_END						/* end of sequence */
-};
-
-
-static const uint8_t u8g_dev_ssd1353_160x128_column_seq[] PROGMEM = {
-	U8G_ESC_CS(1),
-	U8G_ESC_ADR(0), 0x15,
-	U8G_ESC_ADR(1), 0x00, 0x9f,
-	U8G_ESC_ADR(0), 0x75,
-	U8G_ESC_ADR(1), 0x00, 0x7f,
-	U8G_ESC_ADR(0), 0x5c,
-	U8G_ESC_ADR(1),
-	U8G_ESC_CS(0),
-	U8G_ESC_END
-};
-
-static const uint8_t u8g_dev_ssd1353_160x128_sleep_on[] PROGMEM = {
-	U8G_ESC_CS(1),
-	U8G_ESC_ADR(0), 0xAE,
-	U8G_ESC_CS(0),
-	U8G_ESC_END
-};
-
-static const uint8_t u8g_dev_ssd1353_160x128_sleep_off[] PROGMEM = {
-	U8G_ESC_CS(1),
-	U8G_ESC_ADR(0), 0xAF,
-	U8G_ESC_CS(0),
-	U8G_ESC_END
-};
-
-
-#define RGB332_STREAM_BYTES 8
-static uint8_t u8g_ssd1353_stream_bytes[RGB332_STREAM_BYTES*3];
-
-uint8_t u8g_dev_ssd1353_160x128_332_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_SPI_CLK_CYCLE_50NS);
-		u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_init_seq);
-		break;
-
-	case U8G_DEV_MSG_STOP:
-		break;
-
-	case U8G_DEV_MSG_PAGE_FIRST:
-		u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_column_seq);
-		break;
-
-	case U8G_DEV_MSG_PAGE_NEXT:
-		{
-			u8g_uint_t x;
-			uint8_t page_height;
-			uint8_t i;
-			uint8_t cnt;
-			u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
-			uint8_t *ptr = pb->buf;
-
-			u8g_SetChipSelect(u8g, dev, 1);
-
-			page_height = pb->p.page_y1;
-			page_height -= pb->p.page_y0;
-			page_height++;
-			for( i = 0; i < page_height; i++ )
-			{
-			  
-			  for (x = 0; x < pb->width; x+=RGB332_STREAM_BYTES)
-			  {
-				/* inline operation for better perf */
-			    uint8_t *dest = u8g_ssd1353_stream_bytes;
-			    for( cnt = 0; cnt < RGB332_STREAM_BYTES; cnt++ )
-			    {
-			      uint8_t val = *ptr++;
-			      *dest++ = ((val & 0xe0) >> 2);
-			      *dest++ = ((val & 0x1c) << 1);
-			      *dest++ = ((val & 0x03) << 4);
-			    }
-			    u8g_WriteSequence(u8g, dev, RGB332_STREAM_BYTES*3, u8g_ssd1353_stream_bytes);
-			  }
-			}
-			u8g_SetChipSelect(u8g, dev, 0);
-		}
-
-		break;
-
-	case U8G_DEV_MSG_SLEEP_ON:
-		u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_sleep_on);
-		break;
-	case U8G_DEV_MSG_SLEEP_OFF:
-		u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_sleep_off);
-		break;
-	}
-
-	return u8g_dev_pb8h8_base_fn(u8g, dev, msg, arg);
-}
-
-/*
- * not tested and not released, just taken from ssd1351
- */
-static uint8_t u8g_dev_ssd1353_160x128_r[256];
-static uint8_t u8g_dev_ssd1353_160x128_g[256];
-static uint8_t u8g_dev_ssd1353_160x128_b[256];
-
-uint8_t u8g_dev_ssd1353_160x128_idx_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:
-		u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_50NS);
-		u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_init_seq);
-		break;
-
-	case U8G_DEV_MSG_STOP:
-		break;
-	
-	case U8G_DEV_MSG_SET_COLOR_ENTRY:
-		  u8g_dev_ssd1353_160x128_r[ ((u8g_dev_arg_irgb_t *)arg)->idx ] = ((u8g_dev_arg_irgb_t *)arg)->r;
-		  u8g_dev_ssd1353_160x128_g[ ((u8g_dev_arg_irgb_t *)arg)->idx ] = ((u8g_dev_arg_irgb_t *)arg)->g;
-		  u8g_dev_ssd1353_160x128_b[ ((u8g_dev_arg_irgb_t *)arg)->idx ] = ((u8g_dev_arg_irgb_t *)arg)->b;
-		  break;
-	
-	case U8G_DEV_MSG_PAGE_FIRST:
-		u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_column_seq);
-		break;
-
-	case U8G_DEV_MSG_PAGE_NEXT:
-		{
-			int x;
-			u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
-			uint8_t *ptr = pb->buf;
-
-			u8g_SetChipSelect(u8g, dev, 1);
-
-			for (x = 0; x < pb->width; x++)
-			{
-				u8g_WriteByte(u8g, dev, u8g_dev_ssd1353_160x128_r[(*ptr)>>2]);
-				u8g_WriteByte(u8g, dev, u8g_dev_ssd1353_160x128_g[(*ptr)>>2]);
-				u8g_WriteByte(u8g, dev, u8g_dev_ssd1353_160x128_b[(*ptr)>>2]);
-
-				ptr++;
-			}
-
-			u8g_SetChipSelect(u8g, dev, 0);
-		}
-
-		break;
-	case U8G_DEV_MSG_GET_MODE:
-	  return U8G_MODE_INDEX;
-	}
-
-	return u8g_dev_pb8h8_base_fn(u8g, dev, msg, arg);
-}
-
-uint8_t u8g_dev_ssd1353_160x128_hicolor_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_SPI_CLK_CYCLE_50NS);
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_init_seq);
-      break;
-    case U8G_DEV_MSG_STOP:
-      break;
-    case U8G_DEV_MSG_PAGE_FIRST:
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_column_seq);
-      break;
-    case U8G_DEV_MSG_PAGE_NEXT:
-      {
-        u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
-        uint8_t i, j;
-        uint8_t page_height;
-	uint8_t *ptr = pb->buf;
-
-	u8g_SetChipSelect(u8g, dev, 1);
-
-        page_height = pb->p.page_y1;
-        page_height -= pb->p.page_y0;
-        page_height++;
-        for( j = 0; j < page_height; j++ )
-        {
-            for (i = 0; i < pb->width; i+=RGB332_STREAM_BYTES)
-            {
-              register uint8_t cnt, low, high, r, g, b;
-              uint8_t *dest = u8g_ssd1353_stream_bytes;
-              for( cnt = 0; cnt < RGB332_STREAM_BYTES; cnt++ )
-              {
-                low = *ptr++;
-                high = *ptr++;
-            
-                r = high & ~7;
-                r >>= 2;
-                b = low & 31;
-                b <<= 1;
-                g = high & 7;
-                g <<= 3;
-                g |= (low>>5)&7;
-    
-                *dest++ = r;
-                *dest++ = g;
-                *dest++ = b;
-              } 
-              u8g_WriteSequence(u8g, dev, RGB332_STREAM_BYTES*3, u8g_ssd1353_stream_bytes);
-	    }
-        }
-	u8g_SetChipSelect(u8g, dev, 0);
-      }
-      break;    /* continue to base fn */
-    case U8G_DEV_MSG_SLEEP_ON:
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_sleep_on);
-      break;
-    case U8G_DEV_MSG_SLEEP_OFF:
-      u8g_WriteEscSeqP(u8g, dev, u8g_dev_ssd1353_160x128_sleep_off);
-      break;
-  }
-  return u8g_dev_pbxh16_base_fn(u8g, dev, msg, arg);
-}
-
-
-uint8_t u8g_dev_ssd1353_160x128_byte_buf[WIDTH*PAGE_HEIGHT] U8G_NOCOMMON ; 
-
-u8g_pb_t u8g_dev_ssd1353_160x128_byte_pb = { {PAGE_HEIGHT, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1353_160x128_byte_buf};  
-u8g_dev_t u8g_dev_ssd1353_160x128_332_sw_spi = { u8g_dev_ssd1353_160x128_332_fn, &u8g_dev_ssd1353_160x128_byte_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_ssd1353_160x128_332_hw_spi = { u8g_dev_ssd1353_160x128_332_fn, &u8g_dev_ssd1353_160x128_byte_pb, U8G_COM_HW_SPI };
-
-//u8g_dev_t u8g_dev_ssd1353_160x128_idx_sw_spi = { u8g_dev_ssd1353_160x128_idx_fn, &u8g_dev_ssd1353_160x128_byte_pb, U8G_COM_SW_SPI };
-//u8g_dev_t u8g_dev_ssd1353_160x128_idx_hw_spi = { u8g_dev_ssd1353_160x128_idx_fn, &u8g_dev_ssd1353_160x128_byte_pb, U8G_COM_HW_SPI };
-
-
-/* only half of the height, because two bytes are needed for one pixel */
-u8g_pb_t u8g_dev_ssd1353_160x128_hicolor_byte_pb = { {PAGE_HEIGHT/2, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1353_160x128_byte_buf}; 
-u8g_dev_t u8g_dev_ssd1353_160x128_hicolor_sw_spi = { u8g_dev_ssd1353_160x128_hicolor_fn, &u8g_dev_ssd1353_160x128_hicolor_byte_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_ssd1353_160x128_hicolor_hw_spi = { u8g_dev_ssd1353_160x128_hicolor_fn, &u8g_dev_ssd1353_160x128_hicolor_byte_pb, U8G_COM_HW_SPI };
-
-
-/* the 4x buffer is removed since it does not fit the RAM space of very small MCUs */
-#if 0
-uint8_t u8g_dev_ssd1353_160x128_4x_byte_buf[WIDTH*PAGE_HEIGHT*4] U8G_NOCOMMON ; 
-
-u8g_pb_t u8g_dev_ssd1353_160x128_4x_332_byte_pb = { {PAGE_HEIGHT*4, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1353_160x128_4x_byte_buf};  
-u8g_dev_t u8g_dev_ssd1353_160x128_4x_332_sw_spi = { u8g_dev_ssd1353_160x128_332_fn, &u8g_dev_ssd1353_160x128_4x_332_byte_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_ssd1353_160x128_4x_332_hw_spi = { u8g_dev_ssd1353_160x128_332_fn, &u8g_dev_ssd1353_160x128_4x_332_byte_pb, U8G_COM_HW_SPI };
-
-u8g_pb_t u8g_dev_ssd1353_160x128_4x_hicolor_byte_pb = { {PAGE_HEIGHT/2*4, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_ssd1353_160x128_4x_byte_buf}; 
-u8g_dev_t u8g_dev_ssd1353_160x128_4x_hicolor_sw_spi = { u8g_dev_ssd1353_160x128_hicolor_fn, &u8g_dev_ssd1353_160x128_4x_hicolor_byte_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_ssd1353_160x128_4x_hicolor_hw_spi = { u8g_dev_ssd1353_160x128_hicolor_fn, &u8g_dev_ssd1353_160x128_4x_hicolor_byte_pb, U8G_COM_HW_SPI };
-#endif

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7565_64128n.c

@@ -1,203 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_400NS);
-      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);
-}
-
-uint8_t u8g_dev_st7565_64128n_2x_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_SPI_CLK_CYCLE_400NS);
-      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 | (2*pb->p.page)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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_pb16v1_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);
-U8G_PB_DEV(u8g_dev_st7565_64128n_parallel, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_64128n_fn, U8G_COM_PARALLEL);
-
-uint8_t u8g_dev_st7565_64128n_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_st7565_64128n_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_st7565_64128n_2x_buf}; 
-u8g_dev_t u8g_dev_st7565_64128n_2x_sw_spi = { u8g_dev_st7565_64128n_2x_fn, &u8g_dev_st7565_64128n_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_st7565_64128n_2x_hw_spi = { u8g_dev_st7565_64128n_2x_fn, &u8g_dev_st7565_64128n_2x_pb, U8G_COM_HW_SPI };
-u8g_dev_t u8g_dev_st7565_64128n_2x_hw_parallel = { u8g_dev_st7565_64128n_2x_fn, &u8g_dev_st7565_64128n_2x_pb, U8G_COM_PARALLEL };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7565_dogm128.c

@@ -1,190 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_400NS);
-      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);
-}
-
-uint8_t u8g_dev_st7565_dogm128_2x_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_SPI_CLK_CYCLE_400NS);
-      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 | (2*pb->p.page)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_dogm128_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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_pb16v1_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);
-U8G_PB_DEV(u8g_dev_st7565_dogm128_parallel, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_dogm128_fn, U8G_COM_PARALLEL);
-
-
-uint8_t u8g_dev_st7565_dogm128_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_st7565_dogm128_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_st7565_dogm128_2x_buf}; 
-u8g_dev_t u8g_dev_st7565_dogm128_2x_sw_spi = { u8g_dev_st7565_dogm128_2x_fn, &u8g_dev_st7565_dogm128_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_st7565_dogm128_2x_hw_spi = { u8g_dev_st7565_dogm128_2x_fn, &u8g_dev_st7565_dogm128_2x_pb, U8G_COM_HW_SPI };
-u8g_dev_t u8g_dev_st7565_dogm128_2x_parallel = { u8g_dev_st7565_dogm128_2x_fn, &u8g_dev_st7565_dogm128_2x_pb, U8G_COM_PARALLEL };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7565_dogm132.c

@@ -1,157 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_400NS);
-      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);

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7565_lm6059.c

@@ -1,205 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_400NS);
-      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);
-}
-
-uint8_t u8g_dev_st7565_lm6059_2x_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_SPI_CLK_CYCLE_400NS);
-      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 | (2*pb->p.page)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-
-	u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6059_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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_pb16v1_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);
-
-
-uint8_t u8g_dev_st7565_lm6059_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_st7565_lm6059_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_st7565_lm6059_2x_buf}; 
-u8g_dev_t u8g_dev_st7565_lm6059_2x_sw_spi = { u8g_dev_st7565_lm6059_2x_fn, &u8g_dev_st7565_lm6059_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_st7565_lm6059_2x_hw_spi = { u8g_dev_st7565_lm6059_2x_fn, &u8g_dev_st7565_lm6059_2x_pb, U8G_COM_HW_SPI };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7565_lm6063.c

@@ -1,236 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_400NS);
-      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);
-}
-
-uint8_t u8g_dev_st7565_lm6063_2x_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_SPI_CLK_CYCLE_400NS);
-      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 | (2*pb->p.page)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_lm6063_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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_pb16v1_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);
-
-uint8_t u8g_dev_st7565_lm6063_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_st7565_lm6063_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_st7565_lm6063_2x_buf}; 
-u8g_dev_t u8g_dev_st7565_lm6063_2x_sw_spi = { u8g_dev_st7565_lm6063_2x_fn, &u8g_dev_st7565_lm6063_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_st7565_lm6063_2x_hw_spi = { u8g_dev_st7565_lm6063_2x_fn, &u8g_dev_st7565_lm6063_2x_pb, U8G_COM_HW_SPI };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7565_nhd_c12832.c

@@ -1,145 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_400NS);
-      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);
-U8G_PB_DEV(u8g_dev_st7565_nhd_c12832_hw_usart_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7565_c12832_fn, U8G_COM_HW_USART_SPI);
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7565_nhd_c12864.c

@@ -1,194 +0,0 @@
-/*
-
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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(0),             /* disable chip, bugfix 12 nov 2014 */
-  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_SPI_CLK_CYCLE_400NS);
-      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);
-}
-
-uint8_t u8g_dev_st7565_nhd_c12864_2x_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_SPI_CLK_CYCLE_400NS);
-      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 | (2*pb->p.page)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_nhd_c12864_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
-        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_pb16v1_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);
-
-
-uint8_t u8g_dev_st7565_nhd_c12864_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_st7565_nhd_c12864_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_st7565_nhd_c12864_2x_buf}; 
-u8g_dev_t u8g_dev_st7565_nhd_c12864_2x_sw_spi = { u8g_dev_st7565_nhd_c12864_2x_fn, &u8g_dev_st7565_nhd_c12864_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_st7565_nhd_c12864_2x_hw_spi = { u8g_dev_st7565_nhd_c12864_2x_fn, &u8g_dev_st7565_nhd_c12864_2x_pb, U8G_COM_HW_SPI };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7687_c144mvgd.c

@@ -1,420 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_400NS);
-      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 };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7920_128x64.c

@@ -1,175 +0,0 @@
-/*
-
-  u8g_dev_st7920_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_SPI_CLK_CYCLE_400NS);
-      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_SPI_CLK_CYCLE_400NS);
-      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);
-U8G_PB_DEV(u8g_dev_st7920_128x64_custom, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_st7920_128x64_fn, u8g_com_arduino_st7920_custom_fn);
-
-
-
-#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 };
-u8g_dev_t u8g_dev_st7920_128x64_4x_custom = { u8g_dev_st7920_128x64_4x_fn, &u8g_dev_st7920_128x64_4x_pb, u8g_com_arduino_st7920_custom_fn };
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7920_192x32.c

@@ -1,151 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_400NS);
-      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_SPI_CLK_CYCLE_400NS);
-      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 };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_st7920_202x32.c

@@ -1,154 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_400NS);
-      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_SPI_CLK_CYCLE_400NS);
-      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 };
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_t6963_128x64.c

@@ -1,191 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_NONE);    
-      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 };
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_t6963_240x128.c

@@ -1,195 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_NONE);    
-      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 };
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_t6963_240x64.c

@@ -1,195 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_NONE);    
-      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 };
-
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_tls8204_84x48.c

@@ -1,115 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_400NS);
-      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);
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_uc1610_dogxl160.c

@@ -1,290 +0,0 @@
-/*
-
-  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_SPI_CLK_CYCLE_300NS);
-      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_SPI_CLK_CYCLE_300NS);
-      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_SPI_CLK_CYCLE_300NS);
-      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 *)((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 *)((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_SPI_CLK_CYCLE_300NS);
-      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, (uint8_t *)(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 };

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_uc1701_dogs102.c

@@ -1,157 +0,0 @@
-/*
-
-  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 */
-  
-  0x0e2,            		/* soft reset */
-  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_SPI_CLK_CYCLE_300NS);
-      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);
-}
-
-uint8_t u8g_dev_uc1701_dogs102_2x_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_SPI_CLK_CYCLE_300NS);
-      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 | (2*pb->p.page)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_dogs102_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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_pb16v1_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);
-
-uint8_t u8g_dev_uc1701_dogs102_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_uc1701_dogs102_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_uc1701_dogs102_2x_buf}; 
-u8g_dev_t u8g_dev_uc1701_dogs102_2x_sw_spi = { u8g_dev_uc1701_dogs102_2x_fn, &u8g_dev_uc1701_dogs102_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_uc1701_dogs102_2x_hw_spi = { u8g_dev_uc1701_dogs102_2x_fn, &u8g_dev_uc1701_dogs102_2x_pb, U8G_COM_HW_SPI };
-

.piolibdeps/U8glib_ID7/src/clib/u8g_dev_uc1701_mini12864.c

@@ -1,158 +0,0 @@
-/*
-
-  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 */
-
-  0x0e2,            /* soft reset */
-  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_SPI_CLK_CYCLE_300NS);
-      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);
-}
-
-uint8_t u8g_dev_uc1701_mini12864_2x_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_SPI_CLK_CYCLE_300NS);
-      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 | (2*pb->p.page)); /* select current page */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, pb->buf); 
-        u8g_SetChipSelect(u8g, dev, 0);
-	
-        u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_data_start);    
-        u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page */
-        u8g_SetAddress(u8g, dev, 1);           /* data mode */
-	u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); 
-        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_pb16v1_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);
-
-uint8_t u8g_dev_uc1701_mini12864_2x_buf[WIDTH*2] U8G_NOCOMMON ; 
-u8g_pb_t u8g_dev_uc1701_mini12864_2x_pb = { {16, HEIGHT, 0, 0, 0},  WIDTH, u8g_dev_uc1701_mini12864_2x_buf}; 
-u8g_dev_t u8g_dev_uc1701_mini12864_2x_sw_spi = { u8g_dev_uc1701_mini12864_2x_fn, &u8g_dev_uc1701_mini12864_2x_pb, U8G_COM_SW_SPI };
-u8g_dev_t u8g_dev_uc1701_mini12864_2x_hw_spi = { u8g_dev_uc1701_mini12864_2x_fn, &u8g_dev_uc1701_mini12864_2x_pb, U8G_COM_HW_SPI };

.piolibdeps/U8glib_ID7/src/clib/u8g_ellipse.c

@@ -1,393 +0,0 @@
-/*
-
-  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
-
-#if defined(U8G_16BIT)
-typedef  int32_t u8g_long_t;
-#else
-typedef  int16_t u8g_long_t;
-#endif
-
-
-/*
-  Source: 
-    ftp://pc.fk0.name/pub/books/programming/bezier-ellipse.pdf
-    Foley, Computer Graphics, p 90
-*/
-static void u8g_draw_ellipse_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_ellipse_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);
-    }
-    
-    /* upper left */
-    if ( option & U8G_DRAW_UPPER_LEFT )
-    {
-      u8g_DrawPixel(u8g, x0 - x, y0 - y);
-    }
-    
-    /* lower right */
-    if ( option & U8G_DRAW_LOWER_RIGHT )
-    {
-      u8g_DrawPixel(u8g, x0 + x, y0 + y);
-    }
-    
-    /* lower left */
-    if ( option & U8G_DRAW_LOWER_LEFT )
-    {
-      u8g_DrawPixel(u8g, x0 - x, y0 + y);
-    }
-}
-
-void u8g_draw_ellipse(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rx, u8g_uint_t ry, uint8_t option)
-{
-  u8g_uint_t x, y;
-  u8g_long_t xchg, ychg;
-  u8g_long_t err;
-  u8g_long_t rxrx2;
-  u8g_long_t ryry2;
-  u8g_long_t stopx, stopy;
-  
-  rxrx2 = rx;
-  rxrx2 *= rx;
-  rxrx2 *= 2;
-  
-  ryry2 = ry;
-  ryry2 *= ry;
-  ryry2 *= 2;
-  
-  x = rx;
-  y = 0;
-  
-  xchg = 1;
-  xchg -= rx;
-  xchg -= rx;
-  xchg *= ry;
-  xchg *= ry;
-  
-  ychg = rx;
-  ychg *= rx;
-  
-  err = 0;
-  
-  stopx = ryry2;
-  stopx *= rx;
-  stopy = 0;
-  
-  while( stopx >= stopy )
-  {
-    u8g_draw_ellipse_section(u8g, x, y, x0, y0, option);
-    y++;
-    stopy += rxrx2;
-    err += ychg;
-    ychg += rxrx2;
-    if ( 2*err+xchg > 0 )
-    {
-      x--;
-      stopx -= ryry2;
-      err += xchg;
-      xchg += ryry2;      
-    }
-  }
-
-  x = 0;
-  y = ry;
-  
-  xchg = ry;
-  xchg *= ry;
-  
-  ychg = 1;
-  ychg -= ry;
-  ychg -= ry;
-  ychg *= rx;
-  ychg *= rx;
-  
-  err = 0;
-  
-  stopx = 0;
-
-  stopy = rxrx2;
-  stopy *= ry;
-  
-
-  while( stopx <= stopy )
-  {
-    u8g_draw_ellipse_section(u8g, x, y, x0, y0, option);
-    x++;
-    stopx += ryry2;
-    err += xchg;
-    xchg += ryry2;
-    if ( 2*err+ychg > 0 )
-    {
-      y--;
-      stopy -= rxrx2;
-      err += ychg;
-      ychg += rxrx2;
-    }
-  }
-  
-}
-
-void u8g_DrawEllipse(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rx, u8g_uint_t ry, uint8_t option)
-{
-  /* check for bounding box */
-  {
-    u8g_uint_t rxp, rxp2;
-    u8g_uint_t ryp, ryp2;
-    
-    rxp = rx;
-    rxp++;
-    rxp2 = rxp;
-    rxp2 *= 2;
-
-    ryp = ry;
-    ryp++;
-    ryp2 = ryp;
-    ryp2 *= 2;
-    
-    if ( u8g_IsBBXIntersection(u8g, x0-rxp, y0-ryp, rxp2, ryp2) == 0)
-      return;    
-  }
-  
-  u8g_draw_ellipse(u8g, x0, y0, rx, ry, option);
-}
-
-static void u8g_draw_filled_ellipse_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_filled_ellipse_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);
-    }
-    
-    /* upper left */
-    if ( option & U8G_DRAW_UPPER_LEFT )
-    {
-      u8g_DrawVLine(u8g, x0-x, y0-y, y+1);
-    }
-    
-    /* lower right */
-    if ( option & U8G_DRAW_LOWER_RIGHT )
-    {
-      u8g_DrawVLine(u8g, x0+x, y0, y+1);
-    }
-    
-    /* lower left */
-    if ( option & U8G_DRAW_LOWER_LEFT )
-    {
-      u8g_DrawVLine(u8g, x0-x, y0, y+1);
-    }
-}
-
-void u8g_draw_filled_ellipse(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rx, u8g_uint_t ry, uint8_t option)
-{
-  u8g_uint_t x, y;
-  u8g_long_t xchg, ychg;
-  u8g_long_t err;
-  u8g_long_t rxrx2;
-  u8g_long_t ryry2;
-  u8g_long_t stopx, stopy;
-  
-  rxrx2 = rx;
-  rxrx2 *= rx;
-  rxrx2 *= 2;
-  
-  ryry2 = ry;
-  ryry2 *= ry;
-  ryry2 *= 2;
-  
-  x = rx;
-  y = 0;
-  
-  xchg = 1;
-  xchg -= rx;
-  xchg -= rx;
-  xchg *= ry;
-  xchg *= ry;
-  
-  ychg = rx;
-  ychg *= rx;
-  
-  err = 0;
-  
-  stopx = ryry2;
-  stopx *= rx;
-  stopy = 0;
-  
-  while( stopx >= stopy )
-  {
-    u8g_draw_filled_ellipse_section(u8g, x, y, x0, y0, option);
-    y++;
-    stopy += rxrx2;
-    err += ychg;
-    ychg += rxrx2;
-    if ( 2*err+xchg > 0 )
-    {
-      x--;
-      stopx -= ryry2;
-      err += xchg;
-      xchg += ryry2;      
-    }
-  }
-
-  x = 0;
-  y = ry;
-  
-  xchg = ry;
-  xchg *= ry;
-  
-  ychg = 1;
-  ychg -= ry;
-  ychg -= ry;
-  ychg *= rx;
-  ychg *= rx;
-  
-  err = 0;
-  
-  stopx = 0;
-
-  stopy = rxrx2;
-  stopy *= ry;
-  
-
-  while( stopx <= stopy )
-  {
-    u8g_draw_filled_ellipse_section(u8g, x, y, x0, y0, option);
-    x++;
-    stopx += ryry2;
-    err += xchg;
-    xchg += ryry2;
-    if ( 2*err+ychg > 0 )
-    {
-      y--;
-      stopy -= rxrx2;
-      err += ychg;
-      ychg += rxrx2;
-    }
-  }
-  
-}
-
-void u8g_DrawFilledEllipse(u8g_t *u8g, u8g_uint_t x0, u8g_uint_t y0, u8g_uint_t rx, u8g_uint_t ry, uint8_t option)
-{
-  /* check for bounding box */
-  {
-    u8g_uint_t rxp, rxp2;
-    u8g_uint_t ryp, ryp2;
-    
-    rxp = rx;
-    rxp++;
-    rxp2 = rxp;
-    rxp2 *= 2;
-
-    ryp = ry;
-    ryp++;
-    ryp2 = ryp;
-    ryp2 *= 2;
-    
-    if ( u8g_IsBBXIntersection(u8g, x0-rxp, y0-ryp, rxp2, ryp2) == 0)
-      return;    
-  }
-  
-  u8g_draw_filled_ellipse(u8g, x0, y0, rx, ry, option);
-}

.piolibdeps/U8glib_ID7/src/clib/u8g_line.c

@@ -1,90 +0,0 @@
-/*
-
-  u8g_line.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"
-
-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;
-
-#ifndef  U8G_16BIT
-  if ( x2 == 255 )
-    x2--;
-#else
-  if ( x2 == 0xffff )
-    x2--;
-#endif
-
-  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;
-    }
-  }
-}