/Arduino/libraries/U8g2/src/U8g2lib.h

https://github.com/CongducPham/LowCostLoRaGw · C Header · 8258 lines · 8093 code · 72 blank · 93 comment · 2 complexity · bcde866006d6bfc9de705e247aa19a85 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /*
    2. 

  2.   
    3. 

  3.   U8g2lib.h
    4. 

  4.   
    5. 

  5.   C++ Arduino wrapper for the u8g2 struct and c functions for the u8g2 library
    6. 

    7. 

  7.   Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
    8. 

    9. 

  9.   Copyright (c) 2016, olikraus@gmail.com
    10. 

  10.   All rights reserved.
    11. 

    12. 

  12.   Redistribution and use in source and binary forms, with or without modification, 
    13. 

  13.   are permitted provided that the following conditions are met:
    14. 

    15. 

  15.   * Redistributions of source code must retain the above copyright notice, this list 
    16. 

  16.     of conditions and the following disclaimer.
    17. 

  17.     
    18. 

  18.   * Redistributions in binary form must reproduce the above copyright notice, this 
    19. 

  19.     list of conditions and the following disclaimer in the documentation and/or other 
    20. 

  20.     materials provided with the distribution.
    21. 

    22. 

  22.   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
    23. 

  23.   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
    24. 

  24.   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
    25. 

  25.   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
    26. 

  26.   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
    27. 

  27.   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
    28. 

  28.   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
    29. 

  29.   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
    30. 

  30.   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
    31. 

  31.   CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
    32. 

  32.   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
    33. 

  33.   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
    34. 

  34.   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
    35. 

    36. 

    37. 

  37.   Note:
    38. 

  38.   U8x8lib.h is included for the declaration of the helper functions in U8x8lib.cpp.
    39. 

  39.   U8g2 class is based on the u8g2 struct from clib/u8g2.h, the U8x8 class from U8x8lib.h is not used.
    40. 

    41. 

    42. 

  42. */
    43. 

  43. 

  44. 

  45. #ifndef _U8G2LIB_HH
    46. 

  46. #define _U8G2LIB_HH
    47. 

  47. 

  48. #include <Arduino.h>
    49. 

  49. #include <Print.h>
    50. 

  50. #include <U8x8lib.h>
    51. 

  51. 

  52. #include "clib/u8g2.h"
    53. 

  53. 

  54. class U8G2 : public Print
    55. 

  55. {
    56. 

  56.   protected:
    57. 

  57.     u8g2_t u8g2;
    58. 

  58.     u8x8_char_cb cpp_next_cb; /*  the cpp interface has its own decoding function for the Arduino print command */
    59. 

  59.   public:
    60. 

  60.     u8g2_uint_t tx, ty;
    61. 

  61.   
    62. 

  62.     U8G2(void) { cpp_next_cb = u8x8_ascii_next; home(); }
    63. 

  63.     u8x8_t *getU8x8(void) { return u8g2_GetU8x8(&u8g2); }
    64. 

  64.     u8g2_t *getU8g2(void) { return &u8g2; }
    65. 

  65. 

  66.     void setI2CAddress(uint8_t adr) { u8g2_SetI2CAddress(&u8g2, adr); }
    67. 

  67.     
    68. 

  68.     
    69. 

  69.     void enableUTF8Print(void) { cpp_next_cb = u8x8_utf8_next; }
    70. 

  70.     void disableUTF8Print(void) { cpp_next_cb = u8x8_ascii_next; }
    71. 

  71. 

  72.     /* u8x8 interface */
    73. 

  73.     uint8_t getCols(void) { return u8x8_GetCols(u8g2_GetU8x8(&u8g2)); }
    74. 

  74.     uint8_t getRows(void) { return u8x8_GetRows(u8g2_GetU8x8(&u8g2)); }
    75. 

  75.     void drawTile(uint8_t x, uint8_t y, uint8_t cnt, uint8_t *tile_ptr) {
    76. 

  76.       u8x8_DrawTile(u8g2_GetU8x8(&u8g2), x, y, cnt, tile_ptr); }
    77. 

  77. 

  78. #ifdef U8X8_WITH_USER_PTR
    79. 

  79.       void *getUserPtr() { return u8g2_GetUserPtr(&u8g2); }
    80. 

  80.       void setUserPtr(void *p) { u8g2_SetUserPtr(&u8g2, p); }
    81. 

  81. #endif
    82. 

  82.       
    83. 

  83. 

  84. #ifdef U8X8_USE_PINS 
    85. 

  85.     /* set the menu pins before calling begin() or initDisplay() */
    86. 

  86.     void setMenuSelectPin(uint8_t val) {
    87. 

  87.       u8g2_SetMenuSelectPin(&u8g2, val); }
    88. 

  88.     void setMenuPrevPin(uint8_t val) {
    89. 

  89.       u8g2_SetMenuPrevPin(&u8g2, val); }
    90. 

  90.     void setMenuNextPin(uint8_t val) {
    91. 

  91.       u8g2_SetMenuNextPin(&u8g2, val); }
    92. 

  92.     void setMenuUpPin(uint8_t val) {
    93. 

  93.       u8g2_SetMenuUpPin(&u8g2, val); }
    94. 

  94.     void setMenuDownPin(uint8_t val) {
    95. 

  95.       u8g2_SetMenuDownPin(&u8g2, val); }
    96. 

  96.     void setMenuHomePin(uint8_t val) {
    97. 

  97.       u8g2_SetMenuHomePin(&u8g2, val); }
    98. 

  98. #endif
    99. 

  99. 

  100.     /* return 0 for no event or U8X8_MSG_GPIO_MENU_SELECT, */
    101. 

  101.     /* U8X8_MSG_GPIO_MENU_NEXT, U8X8_MSG_GPIO_MENU_PREV, */
    102. 

  102.     /* U8X8_MSG_GPIO_MENU_HOME */
    103. 

  103.     uint8_t getMenuEvent(void) { return u8x8_GetMenuEvent(u8g2_GetU8x8(&u8g2)); }
    104. 

  104. 

  105.     void initDisplay(void) {
    106. 

  106.       u8g2_InitDisplay(&u8g2); }
    107. 

  107.       
    108. 

  108.     void clearDisplay(void) {
    109. 

  109.       u8g2_ClearDisplay(&u8g2); }
    110. 

  110.       
    111. 

  111.     void setPowerSave(uint8_t is_enable) {
    112. 

  112.       u8g2_SetPowerSave(&u8g2, is_enable); }
    113. 

  113.       
    114. 

  114.     void setFlipMode(uint8_t mode) {
    115. 

  115.       u8g2_SetFlipMode(&u8g2, mode); }
    116. 

  116. 

  117.     void setContrast(uint8_t value) {
    118. 

  118.       u8g2_SetContrast(&u8g2, value); }
    119. 

  119.       
    120. 

  120.     void setDisplayRotation(const u8g2_cb_t *u8g2_cb) {
    121. 

  121.       u8g2_SetDisplayRotation(&u8g2, u8g2_cb); }
    122. 

  122. 

  123.     
    124. 

  124.     void begin(void) {
    125. 

  125.       /* note: call to u8x8_utf8_init is not required here, this is done in the setup procedures before */
    126. 

  126.       initDisplay(); clearDisplay(); setPowerSave(0); }
    127. 

  127. 

  128.     void beginSimple(void) {
    129. 

  129.       /* does not clear the display and does not wake up the display */
    130. 

  130.       /* user is responsible for calling clearDisplay() and setPowerSave(0) */
    131. 

  131.       initDisplay();  }
    132. 

  132.       
    133. 

  133. #ifdef U8X8_USE_PINS 
    134. 

  134.     /* use U8X8_PIN_NONE if a pin is not required */
    135. 

  135.     void begin(uint8_t menu_select_pin, uint8_t menu_next_pin, uint8_t menu_prev_pin, uint8_t menu_up_pin = U8X8_PIN_NONE, uint8_t menu_down_pin = U8X8_PIN_NONE, uint8_t menu_home_pin = U8X8_PIN_NONE) {
    136. 

  136.       setMenuSelectPin(menu_select_pin);
    137. 

  137.       setMenuNextPin(menu_next_pin);
    138. 

  138.       setMenuPrevPin(menu_prev_pin);
    139. 

  139.       setMenuUpPin(menu_up_pin);
    140. 

  140.       setMenuDownPin(menu_down_pin);
    141. 

  141.       setMenuHomePin(menu_home_pin);
    142. 

  142.       begin(); }
    143. 

  143. #endif
    144. 

  144. 

  145.     /* u8g2  */
    146. 

  146. 

  147.       
    148. 

  148.     u8g2_uint_t getDisplayHeight() { return u8g2_GetDisplayHeight(&u8g2); }
    149. 

  149.     u8g2_uint_t getDisplayWidth() { return u8g2_GetDisplayWidth(&u8g2); }
    150. 

  150. 

  151.     
    152. 

  152.     /* u8g2_buffer.c */
    153. 

  153.     void sendBuffer(void) { u8g2_SendBuffer(&u8g2); }
    154. 

  154.     void clearBuffer(void) { u8g2_ClearBuffer(&u8g2); }    
    155. 

  155.     
    156. 

  156.     void firstPage(void) { u8g2_FirstPage(&u8g2); }
    157. 

  157.     uint8_t nextPage(void) { return u8g2_NextPage(&u8g2); }
    158. 

  158.     
    159. 

  159.     uint8_t *getBufferPtr(void) { return u8g2_GetBufferPtr(&u8g2); }
    160. 

  160.     uint8_t getBufferTileHeight(void) { return u8g2_GetBufferTileHeight(&u8g2); }
    161. 

  161.     uint8_t getBufferTileWidth(void) { return u8g2_GetBufferTileWidth(&u8g2); }
    162. 

  162.     uint8_t getPageCurrTileRow(void) { return u8g2_GetBufferCurrTileRow(&u8g2); }	// obsolete
    163. 

  163.     void setPageCurrTileRow(uint8_t row) { u8g2_SetBufferCurrTileRow(&u8g2, row); }	// obsolete
    164. 

  164.     uint8_t getBufferCurrTileRow(void) { return u8g2_GetBufferCurrTileRow(&u8g2); }
    165. 

  165.     void setBufferCurrTileRow(uint8_t row) { u8g2_SetBufferCurrTileRow(&u8g2, row); }
    166. 

  166.     
    167. 

  167.     // this should be renamed to setBufferAutoClear
    168. 

  168.     void setAutoPageClear(uint8_t mode)  { u8g2_SetAutoPageClear(&u8g2, mode); }
    169. 

  169. 

  170.     /* clib/u8g2.hvline.c */
    171. 

  171.     void setDrawColor(uint8_t color_index) { u8g2_SetDrawColor(&u8g2, color_index); }
    172. 

  172.     uint8_t getDrawColor(void) { return u8g2_GetDrawColor(&u8g2); }
    173. 

  173.     void drawPixel(u8g2_uint_t x, u8g2_uint_t y) { u8g2_DrawPixel(&u8g2, x, y); }
    174. 

  174.     void drawHLine(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w) { u8g2_DrawHLine(&u8g2, x, y, w); }
    175. 

  175.     void drawVLine(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t h) { u8g2_DrawVLine(&u8g2, x, y, h); }
    176. 

  176.     void drawHVLine(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t len, uint8_t dir) {
    177. 

  177.       u8g2_DrawHVLine(&u8g2, x, y, len, dir); }
    178. 

  178.     
    179. 

  179.     /* u8g2_box.c */
    180. 

  180.     void drawFrame(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h) { u8g2_DrawFrame(&u8g2, x, y, w, h); }
    181. 

  181.     void drawRFrame(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h, u8g2_uint_t r) { u8g2_DrawRFrame(&u8g2, x, y, w, h,r); }
    182. 

  182.     void drawBox(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h) { u8g2_DrawBox(&u8g2, x, y, w, h); }
    183. 

  183.     void drawRBox(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h, u8g2_uint_t r) { u8g2_DrawRBox(&u8g2, x, y, w, h,r); }
    184. 

  184.     
    185. 

  185.     /* u8g2_circle.c */
    186. 

  186.     void drawCircle(u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rad, uint8_t opt = U8G2_DRAW_ALL) { u8g2_DrawCircle(&u8g2, x0, y0, rad, opt); }
    187. 

  187.     void drawDisc(u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rad, uint8_t opt = U8G2_DRAW_ALL) { u8g2_DrawDisc(&u8g2, x0, y0, rad, opt); }     
    188. 

  188.     void drawEllipse(u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rx, u8g2_uint_t ry, uint8_t opt = U8G2_DRAW_ALL) { u8g2_DrawEllipse(&u8g2, x0, y0, rx, ry, opt); }
    189. 

  189.     void drawFilledEllipse(u8g2_uint_t x0, u8g2_uint_t y0, u8g2_uint_t rx, u8g2_uint_t ry, uint8_t opt = U8G2_DRAW_ALL) { u8g2_DrawFilledEllipse(&u8g2, x0, y0, rx, ry, opt); }    
    190. 

  190. 

  191.     /* u8g2_line.c */
    192. 

  192.     void drawLine(u8g2_uint_t x1, u8g2_uint_t y1, u8g2_uint_t x2, u8g2_uint_t y2) 
    193. 

  193.       { u8g2_DrawLine(&u8g2, x1, y1, x2, y2); }
    194. 

  194. 

  195.     /* u8g2_bitmap.c */
    196. 

  196.     void setBitmapMode(uint8_t is_transparent) 
    197. 

  197.       { u8g2_SetBitmapMode(&u8g2, is_transparent); }
    198. 

  198.     void drawBitmap(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t cnt, u8g2_uint_t h, const uint8_t *bitmap)
    199. 

  199.       { u8g2_DrawBitmap(&u8g2, x, y, cnt, h, bitmap); }
    200. 

  200.     void drawXBM(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h, const uint8_t *bitmap)
    201. 

  201.       { u8g2_DrawXBM(&u8g2, x, y, w, h, bitmap); }
    202. 

  202.     void drawXBMP(u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t w, u8g2_uint_t h, const uint8_t *bitmap)
    203. 

  203.       { u8g2_DrawXBMP(&u8g2, x, y, w, h, bitmap); }
    204. 

  204.     
    205. 

  205.     
    206. 

  206.     /* u8g2_polygon.c */
    207. 

  207.     void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2) 
    208. 

  208.       { u8g2_DrawTriangle(&u8g2, x0, y0, x1, y1, x2, y2); }
    209. 

  209.       
    210. 

  210.     
    211. 

  211.     /* u8g2_font.c */
    212. 

  212. 

  213.     void setFont(const uint8_t  *font) {u8g2_SetFont(&u8g2, font); }
    214. 

  214.     void setFontMode(uint8_t  is_transparent) {u8g2_SetFontMode(&u8g2, is_transparent); }
    215. 

  215.     void setFontDirection(uint8_t dir) {u8g2_SetFontDirection(&u8g2, dir); }
    216. 

  216. 

  217.     int8_t getAscent(void) { return u8g2_GetAscent(&u8g2); }
    218. 

  218.     int8_t getDescent(void) { return u8g2_GetDescent(&u8g2); }
    219. 

  219.     
    220. 

  220.     void setFontPosBaseline(void) { u8g2_SetFontPosBaseline(&u8g2); }
    221. 

  221.     void setFontPosBottom(void) { u8g2_SetFontPosBottom(&u8g2); }
    222. 

  222.     void setFontPosTop(void) { u8g2_SetFontPosTop(&u8g2); }
    223. 

  223.     void setFontPosCenter(void) { u8g2_SetFontPosCenter(&u8g2); }
    224. 

  224. 

  225.     void setFontRefHeightText(void) { u8g2_SetFontRefHeightText(&u8g2); }
    226. 

  226.     void setFontRefHeightExtendedText(void) { u8g2_SetFontRefHeightExtendedText(&u8g2); }
    227. 

  227.     void setFontRefHeightAll(void) { u8g2_SetFontRefHeightAll(&u8g2); }
    228. 

  228.     
    229. 

  229. 

  230. /*
    231. 

  231. uint8_t u8g2_IsGlyph(u8g2_t *u8g2, uint16_t requested_encoding);
    232. 

  232. int8_t u8g2_GetGlyphWidth(u8g2_t *u8g2, uint16_t requested_encoding);
    233. 

  233. u8g2_uint_t u8g2_GetStrWidth(u8g2_t *u8g2, const char *s);
    234. 

  234. u8g2_uint_t u8g2_GetUTF8Width(u8g2_t *u8g2, const char *str);
    235. 

  235. */
    236. 

  236.     
    237. 

  237.     u8g2_uint_t drawGlyph(u8g2_uint_t x, u8g2_uint_t y, uint16_t encoding) { return u8g2_DrawGlyph(&u8g2, x, y, encoding); }    
    238. 

  238.     u8g2_uint_t drawStr(u8g2_uint_t x, u8g2_uint_t y, const char *s) { return u8g2_DrawStr(&u8g2, x, y, s); }
    239. 

  239.     u8g2_uint_t drawUTF8(u8g2_uint_t x, u8g2_uint_t y, const char *s) { return u8g2_DrawUTF8(&u8g2, x, y, s); }
    240. 

  240.     u8g2_uint_t drawExtUTF8(u8g2_uint_t x, u8g2_uint_t y, uint8_t to_left, const uint16_t *kerning_table, const char *s) 
    241. 

  241.       { return u8g2_DrawExtUTF8(&u8g2, x, y, to_left, kerning_table, s); }
    242. 

  242. 

  243.       
    244. 

  244.     u8g2_uint_t getStrWidth(const char *s) { return u8g2_GetStrWidth(&u8g2, s); }
    245. 

  245.     u8g2_uint_t getUTF8Width(const char *s) { return u8g2_GetUTF8Width(&u8g2, s); }
    246. 

  246.     
    247. 

  247.     // not required any more, enable UTF8 for print 
    248. 

  248.     //void printUTF8(const char *s) { tx += u8g2_DrawUTF8(&u8g2, tx, ty, s); }
    249. 

  249. 	
    250. 

  250.     
    251. 

  251.     /* virtual function for print base class */    
    252. 

  252.     size_t write(uint8_t v) {
    253. 

  253.       uint16_t e = cpp_next_cb(&(u8g2.u8x8), v);
    254. 

  254.       
    255. 

  255.       if ( e < 0x0fffe )
    256. 

  256. 	tx += u8g2_DrawGlyph(&u8g2, tx, ty, e);
    257. 

  257.       return 1;
    258. 

  258.      }
    259. 

  259. 

  260.     size_t write(const uint8_t *buffer, size_t size) {
    261. 

  261.       size_t cnt = 0;
    262. 

  262.       while( size > 0 ) {
    263. 

  263. 	cnt += write(*buffer++); 
    264. 

  264. 	size--;
    265. 

  265.       }
    266. 

  266.       return cnt;
    267. 

  267.     }
    268. 

  268.  
    269. 

  269. 

  270.      /* user interface */
    271. 

  271. /*
    272. 

  272. uint8_t u8g2_UserInterfaceSelectionList(u8g2_t *u8g2, const char *title, uint8_t start_pos, const char *sl);
    273. 

  273. uint8_t u8g2_UserInterfaceMessage(u8g2_t *u8g2, const char *title1, const char *title2, const char *title3, const char *buttons);
    274. 

  274. uint8_t u8g2_UserInterfaceInputValue(u8g2_t *u8g2, const char *title, const char *pre, uint8_t *value, uint8_t lo, uint8_t hi, uint8_t digits, const char *post);
    275. 

  275. */
    276. 

  276. 

  277.     uint8_t userInterfaceSelectionList(const char *title, uint8_t start_pos, const char *sl) {
    278. 

  278.       return u8g2_UserInterfaceSelectionList(&u8g2, title, start_pos, sl); }
    279. 

  279.     uint8_t userInterfaceMessage(const char *title1, const char *title2, const char *title3, const char *buttons) {
    280. 

  280.       return u8g2_UserInterfaceMessage(&u8g2, title1, title2, title3, buttons); }
    281. 

  281.     uint8_t userInterfaceInputValue(const char *title, const char *pre, uint8_t *value, uint8_t lo, uint8_t hi, uint8_t digits, const char *post) {
    282. 

  282.       return u8g2_UserInterfaceInputValue(&u8g2, title, pre, value, lo, hi, digits, post); }
    283. 

  283.     
    284. 

  284. 

  285.      /* LiquidCrystal compatible functions */
    286. 

  286.     void home(void) { tx = 0; ty = 0;  u8x8_utf8_init(u8g2_GetU8x8(&u8g2)); }
    287. 

  287.     void clear(void) { home(); clearDisplay(); clearBuffer();  }
    288. 

  288.     void noDisplay(void) { u8g2_SetPowerSave(&u8g2, 1); }
    289. 

  289.     void display(void) { u8g2_SetPowerSave(&u8g2, 0); }
    290. 

  290.     void setCursor(u8g2_uint_t x, u8g2_uint_t y) { tx = x; ty = y; }
    291. 

  291.  
    292. 

  292.     /* u8glib compatible functions */
    293. 

  293.     void sleepOn(void) { u8g2_SetPowerSave(&u8g2, 1); }
    294. 

  294.     void sleepOff(void) { u8g2_SetPowerSave(&u8g2, 0); }    
    295. 

  295.     void setColorIndex(uint8_t color_index) { u8g2_SetDrawColor(&u8g2, color_index); }
    296. 

  296.     uint8_t getColorIndex(void) { return u8g2_GetDrawColor(&u8g2); }
    297. 

  297.     int8_t getFontAscent(void) { return u8g2_GetAscent(&u8g2); }
    298. 

  298.     int8_t getFontDescent(void) { return u8g2_GetDescent(&u8g2); }
    299. 

  299.     u8g2_uint_t getHeight() { return u8g2_GetDisplayHeight(&u8g2); }
    300. 

  300.     u8g2_uint_t getWidth() { return u8g2_GetDisplayWidth(&u8g2); }
    301. 

  301.     
    302. 

  302. };
    303. 

  303. 

  304. /* 
    305. 

  305.   U8G2_<controller>_<display>_<memory>_<communication> 
    306. 

  306.   memory
    307. 

  307.     "1"	one page
    308. 

  308.     "2"	two pages
    309. 

  309.     "f"	full frame buffer
    310. 

  310.   communication
    311. 

  311.     "SW SPI"
    312. 

    313. 

  313. */
    314. 

  314. 

  315. 

  316. #ifdef U8X8_USE_PINS
    317. 

  317. 

  318. /* Arduino constructor list start */
    319. 

  319. /* generated code (codebuild), u8g2 project */
    320. 

  320. class U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI : public U8G2 {
    321. 

  321.   public: U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    322. 

  322.     u8g2_Setup_ssd1305_128x32_noname_1(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    323. 

  323.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    324. 

  324.   }
    325. 

  325. };
    326. 

  326. class U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI : public U8G2 {
    327. 

  327.   public: U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    328. 

  328.     u8g2_Setup_ssd1305_128x32_noname_1(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    329. 

  329.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    330. 

  330.   }
    331. 

  331. };
    332. 

  332. class U8G2_SSD1305_128X32_NONAME_1_2ND_4W_HW_SPI : public U8G2 {
    333. 

  333.   public: U8G2_SSD1305_128X32_NONAME_1_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    334. 

  334.     u8g2_Setup_ssd1305_128x32_noname_1(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    335. 

  335.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    336. 

  336.   }
    337. 

  337. };
    338. 

  338. class U8G2_SSD1305_128X32_NONAME_1_6800 : public U8G2 {
    339. 

  339.   public: U8G2_SSD1305_128X32_NONAME_1_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    340. 

  340.     u8g2_Setup_ssd1305_128x32_noname_1(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    341. 

  341.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    342. 

  342.   }
    343. 

  343. };
    344. 

  344. class U8G2_SSD1305_128X32_NONAME_1_8080 : public U8G2 {
    345. 

  345.   public: U8G2_SSD1305_128X32_NONAME_1_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    346. 

  346.     u8g2_Setup_ssd1305_128x32_noname_1(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    347. 

  347.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    348. 

  348.   }
    349. 

  349. };
    350. 

  350. class U8G2_SSD1305_128X32_NONAME_2_4W_SW_SPI : public U8G2 {
    351. 

  351.   public: U8G2_SSD1305_128X32_NONAME_2_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    352. 

  352.     u8g2_Setup_ssd1305_128x32_noname_2(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    353. 

  353.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    354. 

  354.   }
    355. 

  355. };
    356. 

  356. class U8G2_SSD1305_128X32_NONAME_2_4W_HW_SPI : public U8G2 {
    357. 

  357.   public: U8G2_SSD1305_128X32_NONAME_2_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    358. 

  358.     u8g2_Setup_ssd1305_128x32_noname_2(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    359. 

  359.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    360. 

  360.   }
    361. 

  361. };
    362. 

  362. class U8G2_SSD1305_128X32_NONAME_2_2ND_4W_HW_SPI : public U8G2 {
    363. 

  363.   public: U8G2_SSD1305_128X32_NONAME_2_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    364. 

  364.     u8g2_Setup_ssd1305_128x32_noname_2(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    365. 

  365.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    366. 

  366.   }
    367. 

  367. };
    368. 

  368. class U8G2_SSD1305_128X32_NONAME_2_6800 : public U8G2 {
    369. 

  369.   public: U8G2_SSD1305_128X32_NONAME_2_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    370. 

  370.     u8g2_Setup_ssd1305_128x32_noname_2(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    371. 

  371.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    372. 

  372.   }
    373. 

  373. };
    374. 

  374. class U8G2_SSD1305_128X32_NONAME_2_8080 : public U8G2 {
    375. 

  375.   public: U8G2_SSD1305_128X32_NONAME_2_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    376. 

  376.     u8g2_Setup_ssd1305_128x32_noname_2(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    377. 

  377.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    378. 

  378.   }
    379. 

  379. };
    380. 

  380. class U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI : public U8G2 {
    381. 

  381.   public: U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    382. 

  382.     u8g2_Setup_ssd1305_128x32_noname_f(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    383. 

  383.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    384. 

  384.   }
    385. 

  385. };
    386. 

  386. class U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI : public U8G2 {
    387. 

  387.   public: U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    388. 

  388.     u8g2_Setup_ssd1305_128x32_noname_f(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    389. 

  389.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    390. 

  390.   }
    391. 

  391. };
    392. 

  392. class U8G2_SSD1305_128X32_NONAME_F_2ND_4W_HW_SPI : public U8G2 {
    393. 

  393.   public: U8G2_SSD1305_128X32_NONAME_F_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    394. 

  394.     u8g2_Setup_ssd1305_128x32_noname_f(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    395. 

  395.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    396. 

  396.   }
    397. 

  397. };
    398. 

  398. class U8G2_SSD1305_128X32_NONAME_F_6800 : public U8G2 {
    399. 

  399.   public: U8G2_SSD1305_128X32_NONAME_F_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    400. 

  400.     u8g2_Setup_ssd1305_128x32_noname_f(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    401. 

  401.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    402. 

  402.   }
    403. 

  403. };
    404. 

  404. class U8G2_SSD1305_128X32_NONAME_F_8080 : public U8G2 {
    405. 

  405.   public: U8G2_SSD1305_128X32_NONAME_F_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    406. 

  406.     u8g2_Setup_ssd1305_128x32_noname_f(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    407. 

  407.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    408. 

  408.   }
    409. 

  409. };
    410. 

  410. class U8G2_SSD1305_128X32_NONAME_1_SW_I2C : public U8G2 {
    411. 

  411.   public: U8G2_SSD1305_128X32_NONAME_1_SW_I2C(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    412. 

  412.     u8g2_Setup_ssd1305_i2c_128x32_noname_1(&u8g2, rotation, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_arduino);
    413. 

  413.     u8x8_SetPin_SW_I2C(getU8x8(), clock,  data,  reset);
    414. 

  414.   }
    415. 

  415. };
    416. 

  416. class U8G2_SSD1305_128X32_NONAME_1_HW_I2C : public U8G2 {
    417. 

  417.   public: U8G2_SSD1305_128X32_NONAME_1_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE, uint8_t clock = U8X8_PIN_NONE, uint8_t data = U8X8_PIN_NONE) : U8G2() {
    418. 

  418.     u8g2_Setup_ssd1305_i2c_128x32_noname_1(&u8g2, rotation, u8x8_byte_arduino_hw_i2c, u8x8_gpio_and_delay_arduino);
    419. 

  419.     u8x8_SetPin_HW_I2C(getU8x8(), reset, clock, data);
    420. 

  420.   }
    421. 

  421. };
    422. 

  422. class U8G2_SSD1305_128X32_NONAME_1_2ND_HW_I2C : public U8G2 {
    423. 

  423.   public: U8G2_SSD1305_128X32_NONAME_1_2ND_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    424. 

  424.     u8g2_Setup_ssd1305_i2c_128x32_noname_1(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_i2c, u8x8_gpio_and_delay_arduino);
    425. 

  425.     u8x8_SetPin_HW_I2C(getU8x8(), reset);
    426. 

  426.   }
    427. 

  427. };
    428. 

  428. class U8G2_SSD1305_128X32_NONAME_2_SW_I2C : public U8G2 {
    429. 

  429.   public: U8G2_SSD1305_128X32_NONAME_2_SW_I2C(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    430. 

  430.     u8g2_Setup_ssd1305_i2c_128x32_noname_2(&u8g2, rotation, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_arduino);
    431. 

  431.     u8x8_SetPin_SW_I2C(getU8x8(), clock,  data,  reset);
    432. 

  432.   }
    433. 

  433. };
    434. 

  434. class U8G2_SSD1305_128X32_NONAME_2_HW_I2C : public U8G2 {
    435. 

  435.   public: U8G2_SSD1305_128X32_NONAME_2_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE, uint8_t clock = U8X8_PIN_NONE, uint8_t data = U8X8_PIN_NONE) : U8G2() {
    436. 

  436.     u8g2_Setup_ssd1305_i2c_128x32_noname_2(&u8g2, rotation, u8x8_byte_arduino_hw_i2c, u8x8_gpio_and_delay_arduino);
    437. 

  437.     u8x8_SetPin_HW_I2C(getU8x8(), reset, clock, data);
    438. 

  438.   }
    439. 

  439. };
    440. 

  440. class U8G2_SSD1305_128X32_NONAME_2_2ND_HW_I2C : public U8G2 {
    441. 

  441.   public: U8G2_SSD1305_128X32_NONAME_2_2ND_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    442. 

  442.     u8g2_Setup_ssd1305_i2c_128x32_noname_2(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_i2c, u8x8_gpio_and_delay_arduino);
    443. 

  443.     u8x8_SetPin_HW_I2C(getU8x8(), reset);
    444. 

  444.   }
    445. 

  445. };
    446. 

  446. class U8G2_SSD1305_128X32_NONAME_F_SW_I2C : public U8G2 {
    447. 

  447.   public: U8G2_SSD1305_128X32_NONAME_F_SW_I2C(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    448. 

  448.     u8g2_Setup_ssd1305_i2c_128x32_noname_f(&u8g2, rotation, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_arduino);
    449. 

  449.     u8x8_SetPin_SW_I2C(getU8x8(), clock,  data,  reset);
    450. 

  450.   }
    451. 

  451. };
    452. 

  452. class U8G2_SSD1305_128X32_NONAME_F_HW_I2C : public U8G2 {
    453. 

  453.   public: U8G2_SSD1305_128X32_NONAME_F_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE, uint8_t clock = U8X8_PIN_NONE, uint8_t data = U8X8_PIN_NONE) : U8G2() {
    454. 

  454.     u8g2_Setup_ssd1305_i2c_128x32_noname_f(&u8g2, rotation, u8x8_byte_arduino_hw_i2c, u8x8_gpio_and_delay_arduino);
    455. 

  455.     u8x8_SetPin_HW_I2C(getU8x8(), reset, clock, data);
    456. 

  456.   }
    457. 

  457. };
    458. 

  458. class U8G2_SSD1305_128X32_NONAME_F_2ND_HW_I2C : public U8G2 {
    459. 

  459.   public: U8G2_SSD1305_128X32_NONAME_F_2ND_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    460. 

  460.     u8g2_Setup_ssd1305_i2c_128x32_noname_f(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_i2c, u8x8_gpio_and_delay_arduino);
    461. 

  461.     u8x8_SetPin_HW_I2C(getU8x8(), reset);
    462. 

  462.   }
    463. 

  463. };
    464. 

  464. class U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI : public U8G2 {
    465. 

  465.   public: U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    466. 

  466.     u8g2_Setup_ssd1306_128x64_noname_1(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    467. 

  467.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    468. 

  468.   }
    469. 

  469. };
    470. 

  470. class U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI : public U8G2 {
    471. 

  471.   public: U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    472. 

  472.     u8g2_Setup_ssd1306_128x64_noname_1(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    473. 

  473.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    474. 

  474.   }
    475. 

  475. };
    476. 

  476. class U8G2_SSD1306_128X64_NONAME_1_2ND_4W_HW_SPI : public U8G2 {
    477. 

  477.   public: U8G2_SSD1306_128X64_NONAME_1_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    478. 

  478.     u8g2_Setup_ssd1306_128x64_noname_1(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    479. 

  479.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    480. 

  480.   }
    481. 

  481. };
    482. 

  482. class U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI : public U8G2 {
    483. 

  483.   public: U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    484. 

  484.     u8g2_Setup_ssd1306_128x64_noname_1(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    485. 

  485.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    486. 

  486.   }
    487. 

  487. };
    488. 

  488. class U8G2_SSD1306_128X64_NONAME_1_6800 : public U8G2 {
    489. 

  489.   public: U8G2_SSD1306_128X64_NONAME_1_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    490. 

  490.     u8g2_Setup_ssd1306_128x64_noname_1(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    491. 

  491.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    492. 

  492.   }
    493. 

  493. };
    494. 

  494. class U8G2_SSD1306_128X64_NONAME_1_8080 : public U8G2 {
    495. 

  495.   public: U8G2_SSD1306_128X64_NONAME_1_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    496. 

  496.     u8g2_Setup_ssd1306_128x64_noname_1(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    497. 

  497.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    498. 

  498.   }
    499. 

  499. };
    500. 

  500. class U8G2_SSD1306_128X64_VCOMH0_1_4W_SW_SPI : public U8G2 {
    501. 

  501.   public: U8G2_SSD1306_128X64_VCOMH0_1_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    502. 

  502.     u8g2_Setup_ssd1306_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    503. 

  503.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    504. 

  504.   }
    505. 

  505. };
    506. 

  506. class U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI : public U8G2 {
    507. 

  507.   public: U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    508. 

  508.     u8g2_Setup_ssd1306_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    509. 

  509.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    510. 

  510.   }
    511. 

  511. };
    512. 

  512. class U8G2_SSD1306_128X64_VCOMH0_1_2ND_4W_HW_SPI : public U8G2 {
    513. 

  513.   public: U8G2_SSD1306_128X64_VCOMH0_1_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    514. 

  514.     u8g2_Setup_ssd1306_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    515. 

  515.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    516. 

  516.   }
    517. 

  517. };
    518. 

  518. class U8G2_SSD1306_128X64_VCOMH0_1_3W_SW_SPI : public U8G2 {
    519. 

  519.   public: U8G2_SSD1306_128X64_VCOMH0_1_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    520. 

  520.     u8g2_Setup_ssd1306_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    521. 

  521.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    522. 

  522.   }
    523. 

  523. };
    524. 

  524. class U8G2_SSD1306_128X64_VCOMH0_1_6800 : public U8G2 {
    525. 

  525.   public: U8G2_SSD1306_128X64_VCOMH0_1_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    526. 

  526.     u8g2_Setup_ssd1306_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    527. 

  527.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    528. 

  528.   }
    529. 

  529. };
    530. 

  530. class U8G2_SSD1306_128X64_VCOMH0_1_8080 : public U8G2 {
    531. 

  531.   public: U8G2_SSD1306_128X64_VCOMH0_1_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    532. 

  532.     u8g2_Setup_ssd1306_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    533. 

  533.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    534. 

  534.   }
    535. 

  535. };
    536. 

  536. class U8G2_SSD1306_128X64_ALT0_1_4W_SW_SPI : public U8G2 {
    537. 

  537.   public: U8G2_SSD1306_128X64_ALT0_1_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    538. 

  538.     u8g2_Setup_ssd1306_128x64_alt0_1(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    539. 

  539.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    540. 

  540.   }
    541. 

  541. };
    542. 

  542. class U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI : public U8G2 {
    543. 

  543.   public: U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    544. 

  544.     u8g2_Setup_ssd1306_128x64_alt0_1(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    545. 

  545.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    546. 

  546.   }
    547. 

  547. };
    548. 

  548. class U8G2_SSD1306_128X64_ALT0_1_2ND_4W_HW_SPI : public U8G2 {
    549. 

  549.   public: U8G2_SSD1306_128X64_ALT0_1_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    550. 

  550.     u8g2_Setup_ssd1306_128x64_alt0_1(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    551. 

  551.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    552. 

  552.   }
    553. 

  553. };
    554. 

  554. class U8G2_SSD1306_128X64_ALT0_1_3W_SW_SPI : public U8G2 {
    555. 

  555.   public: U8G2_SSD1306_128X64_ALT0_1_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    556. 

  556.     u8g2_Setup_ssd1306_128x64_alt0_1(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    557. 

  557.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    558. 

  558.   }
    559. 

  559. };
    560. 

  560. class U8G2_SSD1306_128X64_ALT0_1_6800 : public U8G2 {
    561. 

  561.   public: U8G2_SSD1306_128X64_ALT0_1_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    562. 

  562.     u8g2_Setup_ssd1306_128x64_alt0_1(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    563. 

  563.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    564. 

  564.   }
    565. 

  565. };
    566. 

  566. class U8G2_SSD1306_128X64_ALT0_1_8080 : public U8G2 {
    567. 

  567.   public: U8G2_SSD1306_128X64_ALT0_1_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    568. 

  568.     u8g2_Setup_ssd1306_128x64_alt0_1(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    569. 

  569.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    570. 

  570.   }
    571. 

  571. };
    572. 

  572. class U8G2_SSD1306_128X64_NONAME_2_4W_SW_SPI : public U8G2 {
    573. 

  573.   public: U8G2_SSD1306_128X64_NONAME_2_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    574. 

  574.     u8g2_Setup_ssd1306_128x64_noname_2(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    575. 

  575.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    576. 

  576.   }
    577. 

  577. };
    578. 

  578. class U8G2_SSD1306_128X64_NONAME_2_4W_HW_SPI : public U8G2 {
    579. 

  579.   public: U8G2_SSD1306_128X64_NONAME_2_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    580. 

  580.     u8g2_Setup_ssd1306_128x64_noname_2(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    581. 

  581.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    582. 

  582.   }
    583. 

  583. };
    584. 

  584. class U8G2_SSD1306_128X64_NONAME_2_2ND_4W_HW_SPI : public U8G2 {
    585. 

  585.   public: U8G2_SSD1306_128X64_NONAME_2_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    586. 

  586.     u8g2_Setup_ssd1306_128x64_noname_2(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    587. 

  587.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    588. 

  588.   }
    589. 

  589. };
    590. 

  590. class U8G2_SSD1306_128X64_NONAME_2_3W_SW_SPI : public U8G2 {
    591. 

  591.   public: U8G2_SSD1306_128X64_NONAME_2_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    592. 

  592.     u8g2_Setup_ssd1306_128x64_noname_2(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    593. 

  593.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    594. 

  594.   }
    595. 

  595. };
    596. 

  596. class U8G2_SSD1306_128X64_NONAME_2_6800 : public U8G2 {
    597. 

  597.   public: U8G2_SSD1306_128X64_NONAME_2_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    598. 

  598.     u8g2_Setup_ssd1306_128x64_noname_2(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    599. 

  599.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    600. 

  600.   }
    601. 

  601. };
    602. 

  602. class U8G2_SSD1306_128X64_NONAME_2_8080 : public U8G2 {
    603. 

  603.   public: U8G2_SSD1306_128X64_NONAME_2_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    604. 

  604.     u8g2_Setup_ssd1306_128x64_noname_2(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    605. 

  605.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    606. 

  606.   }
    607. 

  607. };
    608. 

  608. class U8G2_SSD1306_128X64_VCOMH0_2_4W_SW_SPI : public U8G2 {
    609. 

  609.   public: U8G2_SSD1306_128X64_VCOMH0_2_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    610. 

  610.     u8g2_Setup_ssd1306_128x64_vcomh0_2(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    611. 

  611.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    612. 

  612.   }
    613. 

  613. };
    614. 

  614. class U8G2_SSD1306_128X64_VCOMH0_2_4W_HW_SPI : public U8G2 {
    615. 

  615.   public: U8G2_SSD1306_128X64_VCOMH0_2_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    616. 

  616.     u8g2_Setup_ssd1306_128x64_vcomh0_2(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    617. 

  617.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    618. 

  618.   }
    619. 

  619. };
    620. 

  620. class U8G2_SSD1306_128X64_VCOMH0_2_2ND_4W_HW_SPI : public U8G2 {
    621. 

  621.   public: U8G2_SSD1306_128X64_VCOMH0_2_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    622. 

  622.     u8g2_Setup_ssd1306_128x64_vcomh0_2(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    623. 

  623.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    624. 

  624.   }
    625. 

  625. };
    626. 

  626. class U8G2_SSD1306_128X64_VCOMH0_2_3W_SW_SPI : public U8G2 {
    627. 

  627.   public: U8G2_SSD1306_128X64_VCOMH0_2_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    628. 

  628.     u8g2_Setup_ssd1306_128x64_vcomh0_2(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    629. 

  629.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    630. 

  630.   }
    631. 

  631. };
    632. 

  632. class U8G2_SSD1306_128X64_VCOMH0_2_6800 : public U8G2 {
    633. 

  633.   public: U8G2_SSD1306_128X64_VCOMH0_2_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    634. 

  634.     u8g2_Setup_ssd1306_128x64_vcomh0_2(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    635. 

  635.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    636. 

  636.   }
    637. 

  637. };
    638. 

  638. class U8G2_SSD1306_128X64_VCOMH0_2_8080 : public U8G2 {
    639. 

  639.   public: U8G2_SSD1306_128X64_VCOMH0_2_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    640. 

  640.     u8g2_Setup_ssd1306_128x64_vcomh0_2(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    641. 

  641.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    642. 

  642.   }
    643. 

  643. };
    644. 

  644. class U8G2_SSD1306_128X64_ALT0_2_4W_SW_SPI : public U8G2 {
    645. 

  645.   public: U8G2_SSD1306_128X64_ALT0_2_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    646. 

  646.     u8g2_Setup_ssd1306_128x64_alt0_2(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    647. 

  647.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    648. 

  648.   }
    649. 

  649. };
    650. 

  650. class U8G2_SSD1306_128X64_ALT0_2_4W_HW_SPI : public U8G2 {
    651. 

  651.   public: U8G2_SSD1306_128X64_ALT0_2_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    652. 

  652.     u8g2_Setup_ssd1306_128x64_alt0_2(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    653. 

  653.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    654. 

  654.   }
    655. 

  655. };
    656. 

  656. class U8G2_SSD1306_128X64_ALT0_2_2ND_4W_HW_SPI : public U8G2 {
    657. 

  657.   public: U8G2_SSD1306_128X64_ALT0_2_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    658. 

  658.     u8g2_Setup_ssd1306_128x64_alt0_2(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    659. 

  659.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    660. 

  660.   }
    661. 

  661. };
    662. 

  662. class U8G2_SSD1306_128X64_ALT0_2_3W_SW_SPI : public U8G2 {
    663. 

  663.   public: U8G2_SSD1306_128X64_ALT0_2_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    664. 

  664.     u8g2_Setup_ssd1306_128x64_alt0_2(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    665. 

  665.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    666. 

  666.   }
    667. 

  667. };
    668. 

  668. class U8G2_SSD1306_128X64_ALT0_2_6800 : public U8G2 {
    669. 

  669.   public: U8G2_SSD1306_128X64_ALT0_2_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    670. 

  670.     u8g2_Setup_ssd1306_128x64_alt0_2(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    671. 

  671.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    672. 

  672.   }
    673. 

  673. };
    674. 

  674. class U8G2_SSD1306_128X64_ALT0_2_8080 : public U8G2 {
    675. 

  675.   public: U8G2_SSD1306_128X64_ALT0_2_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    676. 

  676.     u8g2_Setup_ssd1306_128x64_alt0_2(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    677. 

  677.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    678. 

  678.   }
    679. 

  679. };
    680. 

  680. class U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI : public U8G2 {
    681. 

  681.   public: U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    682. 

  682.     u8g2_Setup_ssd1306_128x64_noname_f(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    683. 

  683.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    684. 

  684.   }
    685. 

  685. };
    686. 

  686. class U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI : public U8G2 {
    687. 

  687.   public: U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    688. 

  688.     u8g2_Setup_ssd1306_128x64_noname_f(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    689. 

  689.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    690. 

  690.   }
    691. 

  691. };
    692. 

  692. class U8G2_SSD1306_128X64_NONAME_F_2ND_4W_HW_SPI : public U8G2 {
    693. 

  693.   public: U8G2_SSD1306_128X64_NONAME_F_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    694. 

  694.     u8g2_Setup_ssd1306_128x64_noname_f(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    695. 

  695.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    696. 

  696.   }
    697. 

  697. };
    698. 

  698. class U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI : public U8G2 {
    699. 

  699.   public: U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    700. 

  700.     u8g2_Setup_ssd1306_128x64_noname_f(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    701. 

  701.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    702. 

  702.   }
    703. 

  703. };
    704. 

  704. class U8G2_SSD1306_128X64_NONAME_F_6800 : public U8G2 {
    705. 

  705.   public: U8G2_SSD1306_128X64_NONAME_F_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    706. 

  706.     u8g2_Setup_ssd1306_128x64_noname_f(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    707. 

  707.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    708. 

  708.   }
    709. 

  709. };
    710. 

  710. class U8G2_SSD1306_128X64_NONAME_F_8080 : public U8G2 {
    711. 

  711.   public: U8G2_SSD1306_128X64_NONAME_F_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    712. 

  712.     u8g2_Setup_ssd1306_128x64_noname_f(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    713. 

  713.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    714. 

  714.   }
    715. 

  715. };
    716. 

  716. class U8G2_SSD1306_128X64_VCOMH0_F_4W_SW_SPI : public U8G2 {
    717. 

  717.   public: U8G2_SSD1306_128X64_VCOMH0_F_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    718. 

  718.     u8g2_Setup_ssd1306_128x64_vcomh0_f(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    719. 

  719.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    720. 

  720.   }
    721. 

  721. };
    722. 

  722. class U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI : public U8G2 {
    723. 

  723.   public: U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    724. 

  724.     u8g2_Setup_ssd1306_128x64_vcomh0_f(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    725. 

  725.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    726. 

  726.   }
    727. 

  727. };
    728. 

  728. class U8G2_SSD1306_128X64_VCOMH0_F_2ND_4W_HW_SPI : public U8G2 {
    729. 

  729.   public: U8G2_SSD1306_128X64_VCOMH0_F_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    730. 

  730.     u8g2_Setup_ssd1306_128x64_vcomh0_f(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    731. 

  731.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    732. 

  732.   }
    733. 

  733. };
    734. 

  734. class U8G2_SSD1306_128X64_VCOMH0_F_3W_SW_SPI : public U8G2 {
    735. 

  735.   public: U8G2_SSD1306_128X64_VCOMH0_F_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    736. 

  736.     u8g2_Setup_ssd1306_128x64_vcomh0_f(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    737. 

  737.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    738. 

  738.   }
    739. 

  739. };
    740. 

  740. class U8G2_SSD1306_128X64_VCOMH0_F_6800 : public U8G2 {
    741. 

  741.   public: U8G2_SSD1306_128X64_VCOMH0_F_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    742. 

  742.     u8g2_Setup_ssd1306_128x64_vcomh0_f(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    743. 

  743.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    744. 

  744.   }
    745. 

  745. };
    746. 

  746. class U8G2_SSD1306_128X64_VCOMH0_F_8080 : public U8G2 {
    747. 

  747.   public: U8G2_SSD1306_128X64_VCOMH0_F_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    748. 

  748.     u8g2_Setup_ssd1306_128x64_vcomh0_f(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    749. 

  749.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    750. 

  750.   }
    751. 

  751. };
    752. 

  752. class U8G2_SSD1306_128X64_ALT0_F_4W_SW_SPI : public U8G2 {
    753. 

  753.   public: U8G2_SSD1306_128X64_ALT0_F_4W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    754. 

  754.     u8g2_Setup_ssd1306_128x64_alt0_f(&u8g2, rotation, u8x8_byte_arduino_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
    755. 

  755.     u8x8_SetPin_4Wire_SW_SPI(getU8x8(), clock, data, cs, dc, reset);
    756. 

  756.   }
    757. 

  757. };
    758. 

  758. class U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI : public U8G2 {
    759. 

  759.   public: U8G2_SSD1306_128X64_ALT0_F_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    760. 

  760.     u8g2_Setup_ssd1306_128x64_alt0_f(&u8g2, rotation, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
    761. 

  761.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    762. 

  762.   }
    763. 

  763. };
    764. 

  764. class U8G2_SSD1306_128X64_ALT0_F_2ND_4W_HW_SPI : public U8G2 {
    765. 

  765.   public: U8G2_SSD1306_128X64_ALT0_F_2ND_4W_HW_SPI(const u8g2_cb_t *rotation, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    766. 

  766.     u8g2_Setup_ssd1306_128x64_alt0_f(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_spi, u8x8_gpio_and_delay_arduino);
    767. 

  767.     u8x8_SetPin_4Wire_HW_SPI(getU8x8(), cs, dc, reset);
    768. 

  768.   }
    769. 

  769. };
    770. 

  770. class U8G2_SSD1306_128X64_ALT0_F_3W_SW_SPI : public U8G2 {
    771. 

  771.   public: U8G2_SSD1306_128X64_ALT0_F_3W_SW_SPI(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    772. 

  772.     u8g2_Setup_ssd1306_128x64_alt0_f(&u8g2, rotation, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
    773. 

  773.     u8x8_SetPin_3Wire_SW_SPI(getU8x8(), clock, data, cs, reset);
    774. 

  774.   }
    775. 

  775. };
    776. 

  776. class U8G2_SSD1306_128X64_ALT0_F_6800 : public U8G2 {
    777. 

  777.   public: U8G2_SSD1306_128X64_ALT0_F_6800(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    778. 

  778.     u8g2_Setup_ssd1306_128x64_alt0_f(&u8g2, rotation, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
    779. 

  779.     u8x8_SetPin_8Bit_6800(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    780. 

  780.   }
    781. 

  781. };
    782. 

  782. class U8G2_SSD1306_128X64_ALT0_F_8080 : public U8G2 {
    783. 

  783.   public: U8G2_SSD1306_128X64_ALT0_F_8080(const u8g2_cb_t *rotation, 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 enable, uint8_t cs, uint8_t dc, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    784. 

  784.     u8g2_Setup_ssd1306_128x64_alt0_f(&u8g2, rotation, u8x8_byte_arduino_8bit_8080mode, u8x8_gpio_and_delay_arduino);
    785. 

  785.     u8x8_SetPin_8Bit_8080(getU8x8(), d0, d1, d2, d3, d4, d5, d6, d7, enable, cs, dc, reset);
    786. 

  786.   }
    787. 

  787. };
    788. 

  788. class U8G2_SSD1306_128X64_NONAME_1_SW_I2C : public U8G2 {
    789. 

  789.   public: U8G2_SSD1306_128X64_NONAME_1_SW_I2C(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    790. 

  790.     u8g2_Setup_ssd1306_i2c_128x64_noname_1(&u8g2, rotation, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_arduino);
    791. 

  791.     u8x8_SetPin_SW_I2C(getU8x8(), clock,  data,  reset);
    792. 

  792.   }
    793. 

  793. };
    794. 

  794. class U8G2_SSD1306_128X64_NONAME_1_HW_I2C : public U8G2 {
    795. 

  795.   public: U8G2_SSD1306_128X64_NONAME_1_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE, uint8_t clock = U8X8_PIN_NONE, uint8_t data = U8X8_PIN_NONE) : U8G2() {
    796. 

  796.     u8g2_Setup_ssd1306_i2c_128x64_noname_1(&u8g2, rotation, u8x8_byte_arduino_hw_i2c, u8x8_gpio_and_delay_arduino);
    797. 

  797.     u8x8_SetPin_HW_I2C(getU8x8(), reset, clock, data);
    798. 

  798.   }
    799. 

  799. };
    800. 

  800. class U8G2_SSD1306_128X64_NONAME_1_2ND_HW_I2C : public U8G2 {
    801. 

  801.   public: U8G2_SSD1306_128X64_NONAME_1_2ND_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    802. 

  802.     u8g2_Setup_ssd1306_i2c_128x64_noname_1(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_i2c, u8x8_gpio_and_delay_arduino);
    803. 

  803.     u8x8_SetPin_HW_I2C(getU8x8(), reset);
    804. 

  804.   }
    805. 

  805. };
    806. 

  806. class U8G2_SSD1306_128X64_VCOMH0_1_SW_I2C : public U8G2 {
    807. 

  807.   public: U8G2_SSD1306_128X64_VCOMH0_1_SW_I2C(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    808. 

  808.     u8g2_Setup_ssd1306_i2c_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_arduino);
    809. 

  809.     u8x8_SetPin_SW_I2C(getU8x8(), clock,  data,  reset);
    810. 

  810.   }
    811. 

  811. };
    812. 

  812. class U8G2_SSD1306_128X64_VCOMH0_1_HW_I2C : public U8G2 {
    813. 

  813.   public: U8G2_SSD1306_128X64_VCOMH0_1_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE, uint8_t clock = U8X8_PIN_NONE, uint8_t data = U8X8_PIN_NONE) : U8G2() {
    814. 

  814.     u8g2_Setup_ssd1306_i2c_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_arduino_hw_i2c, u8x8_gpio_and_delay_arduino);
    815. 

  815.     u8x8_SetPin_HW_I2C(getU8x8(), reset, clock, data);
    816. 

  816.   }
    817. 

  817. };
    818. 

  818. class U8G2_SSD1306_128X64_VCOMH0_1_2ND_HW_I2C : public U8G2 {
    819. 

  819.   public: U8G2_SSD1306_128X64_VCOMH0_1_2ND_HW_I2C(const u8g2_cb_t *rotation, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    820. 

  820.     u8g2_Setup_ssd1306_i2c_128x64_vcomh0_1(&u8g2, rotation, u8x8_byte_arduino_2nd_hw_i2c, u8x8_gpio_and_delay_arduino);
    821. 

  821.     u8x8_SetPin_HW_I2C(getU8x8(), reset);
    822. 

  822.   }
    823. 

  823. };
    824. 

  824. class U8G2_SSD1306_128X64_ALT0_1_SW_I2C : public U8G2 {
    825. 

  825.   public: U8G2_SSD1306_128X64_ALT0_1_SW_I2C(const u8g2_cb_t *rotation, uint8_t clock, uint8_t data, uint8_t reset = U8X8_PIN_NONE) : U8G2() {
    826. 

  826.     u8g2_Setup…
    827.